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