File.hpp

Go to the documentation of this file.

// ======================================================================
// \title Os/File.hpp
// \brief common function definitions for Os::File
// ======================================================================
#ifndef Os_File_hpp_
#define Os_File_hpp_

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

namespace Os {
    struct FileHandle {};

    // This class encapsulates a very simple file interface that has the most often-used features
    class FileInterface {
        public:
            enum Mode {
                OPEN_NO_MODE,   
                OPEN_READ, 
                OPEN_CREATE, 
                OPEN_WRITE, 
                OPEN_SYNC_WRITE, 
                OPEN_APPEND, 
                MAX_OPEN_MODE 
            };

            enum Status {
                OP_OK, 
                DOESNT_EXIST, 
                NO_SPACE, 
                NO_PERMISSION, 
                BAD_SIZE, 
                NOT_OPENED, 
                FILE_EXISTS, 
                NOT_SUPPORTED, 
                INVALID_MODE, 
                INVALID_ARGUMENT, 
                OTHER_ERROR, 
                MAX_STATUS 
            };

            enum OverwriteType {
                NO_OVERWRITE, 
                OVERWRITE, 
                MAX_OVERWRITE_TYPE
            };

            enum SeekType {
                RELATIVE, 
                ABSOLUTE, 
                MAX_SEEK_TYPE
            };

            enum WaitType {
                NO_WAIT, 
                WAIT, 
                MAX_WAIT_TYPE
            };

            virtual ~FileInterface() = default;

            virtual Status open(const char* path, Mode mode, OverwriteType overwrite) = 0;

            virtual void close() = 0;

            virtual Status size(FwSignedSizeType& size_result) = 0;

            virtual Status position(FwSignedSizeType& position_result) = 0;

            virtual Status preallocate(FwSignedSizeType offset, FwSignedSizeType length) = 0;

            virtual Status seek(FwSignedSizeType offset, SeekType seekType) = 0;

            virtual Status flush() = 0;

            virtual Status read(U8* buffer, FwSignedSizeType &size, WaitType wait) = 0;

            virtual Status write(const U8* buffer, FwSignedSizeType &size, WaitType wait) = 0;

            virtual FileHandle* getHandle() = 0;

            static FileInterface* getDelegate(FileHandleStorage& aligned_placement_new_memory, const FileInterface* to_copy=nullptr);
    };


    class File final : public FileInterface {
      public:
        File();
        ~File() final;

        File(const File& other);

        File& operator=(const File& other);

        bool isOpen() const;

        // ------------------------------------
        // Functions supplying default values
        // ------------------------------------

        Os::FileInterface::Status open(const char* path, Mode mode);

        Status read(U8* buffer, FwSignedSizeType &size);

        Status write(const U8* buffer, FwSignedSizeType &size);


        // ------------------------------------
        // Functions overrides
        // ------------------------------------

        Os::FileInterface::Status open(const char* path, Mode mode, OverwriteType overwrite) override;

        void close() override;

        Status size(FwSignedSizeType& size_result) override;

        Status position(FwSignedSizeType& position_result) override;

        Status preallocate(FwSignedSizeType offset, FwSignedSizeType length) override;

        Status seek(FwSignedSizeType offset, SeekType seekType) override;

        Status flush() override;


        Status read(U8* buffer, FwSignedSizeType &size, WaitType wait) override;

        Status readline(U8* buffer, FwSignedSizeType &size, WaitType wait);

        Status write(const U8* buffer, FwSignedSizeType &size, WaitType wait) override;

        FileHandle* getHandle() override;

        Status calculateCrc(U32& crc);

        Status incrementalCrc(FwSignedSizeType& size);

        Status finalizeCrc(U32& crc);

      private:


      PRIVATE:
        static const U32 INITIAL_CRC = 0xFFFFFFFF; 
        Mode m_mode = Mode::OPEN_NO_MODE; 
        const CHAR* m_path = nullptr; 

        U32 m_crc = File::INITIAL_CRC; 
        U8 m_crc_buffer[FW_FILE_CHUNK_SIZE];

        // This section is used to store the implementation-defined file handle. To Os::File 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) FileHandleStorage m_handle_storage; 
        FileInterface& m_delegate; 
    };
}
#endif