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_