FileSystem.hpp

Go to the documentation of this file.

// ======================================================================
// \title Os/FileSystem.hpp
// \brief Os::FileSystem interface definition
// ======================================================================

#ifndef _OS_FILESYSTEM_HPP_
#define _OS_FILESYSTEM_HPP_

#include <FpConfig.hpp>
#include <Os/Os.hpp>
#include <Os/Directory.hpp>
#include <Os/File.hpp>

namespace Os {

struct FileSystemHandle {};

class FileSystemInterface {
  public:

    // Size of file chunks to use for file system operations (e.g. copyFile)
    static constexpr FwSignedSizeType FILE_SYSTEM_FILE_CHUNK_SIZE = FW_FILE_CHUNK_SIZE; 

    enum Status {
        OP_OK, 
        ALREADY_EXISTS, 
        NO_SPACE, 
        NO_PERMISSION, 
        NOT_DIR, 
        IS_DIR, 
        NOT_EMPTY, 
        INVALID_PATH, 
        DOESNT_EXIST, 
        FILE_LIMIT, 
        BUSY, 
        NO_MORE_FILES, 
        BUFFER_TOO_SMALL, 
        EXDEV_ERROR, // Operation not supported across devices (e.g. rename)
        OVERFLOW_ERROR, // Operation failed due to overflow in calculation of the result
        NOT_SUPPORTED, 
        OTHER_ERROR, 
    };

    enum PathType {
        FILE,      
        DIRECTORY, 
        NOT_EXIST, 
    };

    FileSystemInterface() = default;

    virtual ~FileSystemInterface() = default;

    FileSystemInterface(const FileSystemInterface& other) = delete;

    FileSystemInterface& operator=(const FileSystemInterface& other) = delete;

    virtual FileSystemHandle* getHandle() = 0;

    static FileSystemInterface* getDelegate(FileSystemHandleStorage& aligned_new_memory);


    // ------------------------------------------------------------------
    // FileSystem operations to be implemented by an OSAL implementation
    // ------------------------------------------------------------------
    // These functions are to be overridden in each OS implementation
    // See an example in in Os/Posix/FileSystem.hpp

    virtual Status _removeDirectory(const char* path) = 0;

    virtual Status _removeFile(const char* path) = 0;

    virtual Status _rename(const char* sourcePath, const char* destPath) = 0;

    virtual Status _getFreeSpace(const char* path, FwSizeType& totalBytes, FwSizeType& freeBytes) = 0;

    virtual Status _getWorkingDirectory(char* path, FwSizeType bufferSize) = 0;

    virtual Status _changeWorkingDirectory(const char* path) = 0;

};

class FileSystem final : public FileSystemInterface {
  private:
    FileSystem();         
  public:
    ~FileSystem() final;  

    FileSystemHandle* getHandle() override;


    // ------------------------------------------------------------
    // Implementation-specific FileSystem member functions
    // ------------------------------------------------------------

    Status _removeDirectory(const char* path) override;

    Status _removeFile(const char* path) override;

    Status _rename(const char* sourcePath, const char* destPath) override;

    Status _getFreeSpace(const char* path, FwSizeType& totalBytes, FwSizeType& freeBytes) override;

    Status _getWorkingDirectory(char* path, FwSizeType bufferSize) override;

    Status _changeWorkingDirectory(const char* path) override;


    // ------------------------------------------------------------
    // Implementation-specific FileSystem static functions
    // ------------------------------------------------------------
    // These are static variants that are exposed to the user, and call the above member functions

    static Status removeDirectory(const char* path);

    static Status removeFile(const char* path);

    static Status rename(const char* sourcePath, const char* destPath);

    static Status getFreeSpace(const char* path, FwSizeType& totalBytes, FwSizeType& freeBytes);

    static Status getWorkingDirectory(char* path, FwSizeType bufferSize);

    static Status changeWorkingDirectory(const char* path);


    // ------------------------------------------------------------
    // Additional functions built on top of OS-specific operations
    // ------------------------------------------------------------

    static bool exists(const char* path);

    static PathType getPathType(const char* path);
    
    static Status touch(const char* path);
    
    static Status createDirectory(const char* path, bool errorIfAlreadyExists=false);
    
    static Status appendFile(const char* sourcePath, const char* destPath, bool createMissingDest=false);
    
    static Status copyFile(const char* sourcePath, const char* destPath);
    
    static Status moveFile(const char* sourcePath, const char* destPath);
    
    static Status getFileSize(const char* path, FwSignedSizeType& size);


  public:
    static void init();

    static FileSystem& getSingleton();

  private:
    // ------------------------------------------------------------
    // Internal helper functions
    // ------------------------------------------------------------

    static Status handleFileError(File::Status fileStatus);

    static Status handleDirectoryError(Directory::Status dirStatus);

    static Status copyFileData(File& source, File& destination, FwSignedSizeType size);

  private:
    // This section is used to store the implementation-defined FileSystem handle. To Os::FileSystem and fprime, this type is
    // opaque and thus normal allocation cannot be done. Instead, we allow the implementor to store then handle in
    // the byte-array here and set `handle` to that address for storage.

    alignas(FW_HANDLE_ALIGNMENT) FileSystemHandleStorage m_handle_storage;  
    FileSystemInterface& m_delegate;          
};



}

#endif