file.h

Go to the documentation of this file.

 
#ifndef FILE_CLASS_EXT_HEADER
#define FILE_CLASS_EXT_HEADER
 
#include <stdint.h>
#include <a_util/filesystem.h>
#include <a_util/datetime.h>
#include <a_util/memory.h>
#include <system_error>

namespace utils5ext
{

using FilePos  = int64_t;
using FileSize = FilePos;

#ifdef _WIN32
    typedef void* FileHandle;
#else
    typedef int FileHandle;
#endif

namespace exceptions {
    class EndOfFile : public std::runtime_error
    {
    public:
        EndOfFile() : runtime_error("end of file")
        {
        }

        EndOfFile(const std::string& what) : runtime_error(what)
        {
        }
    };

    class ErrorFileAccess : public std::system_error {
    public:
        ErrorFileAccess(const std::string& what);
        ErrorFileAccess(int system_error_code, const std::string& what);
    };

    class ErrorFileAlreadyExists : public ErrorFileAccess
    {
    public:
        ErrorFileAlreadyExists(int system_error_code, const std::string& what)
            : ErrorFileAccess(system_error_code, what)
        {
        }
    };
}

class File
{
    public:
        typedef enum
        {
            om_read                   = 0x0001,

            om_write                  = 0x0002,

            om_append                 = 0x0004,

            om_read_write              = 0x0008,

            om_no_overwrite            = 0x0010,

            om_shared_read             = 0x0100,

            om_shared_write            = 0x0200,

            om_sequential_access       = 0x0400,

            om_temporary_file          = 0x0800,

            om_short_lived             = 0x1000,

            om_text_mode               = 0x2000,

            om_write_through           = 0x4000,

            om_disable_file_system_cache = 0x8000
 
        } OpenMode;

        typedef enum
        {
            fp_begin   = 0,

            fp_current = 1,

            fp_end     = 2
        } FilePosRef;
 
    protected:
        FileHandle _file;                  
        uint8_t*   _read_cache;            
        size_t     _file_cache_usage;      
        size_t     _file_cache_offset;     
        size_t     _file_cache_size;       
        bool       _read_cache_enabled;    
        bool       _reference;             
        bool       _system_cache_disabled; 
        int        _sector_size;           
        FilePos    _sector_bytes_to_skip;  
 
    public:
        File() noexcept;

        virtual ~File();

        void open(const a_util::filesystem::Path& filename, uint32_t mode);

        void close();

        void attach(File& file);

        void detach();

        void setReadCache(size_t read_cache_size);

        size_t read(void* buffer, size_t buffer_size);

        void readAll(void* buffer, size_t buffer_size);

        size_t skip(size_t number_of_bytes);

        size_t write(const void* buffer, size_t buffer_size);

        void writeAll(const void* buffer, size_t buffer_size);

        void write(const std::string& string);

        void readLine(std::string& string);

        void writeLine(const std::string& string);

        FileSize getSize() const;

        FilePos getFilePos() const;

        FilePos setFilePos(FilePos offset, FilePosRef move_mode);

        bool isEof();

        bool isValid() const;

        void truncate(FilePos size);
 
    protected:
        void initialize();

        void allocReadCache(size_t cache_size);

        void freeReadCache();

        void* internalMalloc(size_t size, bool use_segment_size=false);

        void internalFree(void* memory, bool use_segment_size=false);
};

a_util::datetime::DateTime getTimeAccess(const a_util::filesystem::Path filename);

a_util::datetime::DateTime getTimeCreation(const a_util::filesystem::Path filename);

a_util::datetime::DateTime getTimeChange(const a_util::filesystem::Path filename);

size_t getDefaultSectorSize() noexcept;

void* allocPageAlignedMemory(size_t size, size_t page_size);

void freePageAlignedMemory(void* memory);

size_t getSectorSizeFor(const a_util::filesystem::Path& filename) noexcept;

inline void memZero(void* data, size_t bytes)
{
    a_util::memory::set(data, bytes, 0x00, bytes);
}

void fileRename(const a_util::filesystem::Path& from, const a_util::filesystem::Path& to);
 
} // namespace utils5ext
 
#endif // _FILE_CLASS_EXT_HEADER_