file.h

Go to the documentation of this file.

 
#pragma once
 
#include <cstdint>
#include <promeki/core/namespace.h>
#include <promeki/core/platform.h>
#include <promeki/core/string.h>
#include <promeki/core/filepath.h>
#include <promeki/core/error.h>
#include <promeki/core/result.h>
#include <promeki/core/bufferediodevice.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class File : public BufferedIODevice {
        PROMEKI_OBJECT(File, BufferedIODevice)
        public:
                enum Flags {
                        NoFlags         = 0x00,  
                        Create          = 0x01,  
                        Append          = 0x02,  
                        Truncate        = 0x04,  
                        Exclusive       = 0x08   
                };
 
#if defined(PROMEKI_PLATFORM_WINDOWS)
                using FileHandle = HANDLE;
                static constexpr FileHandle FileHandleClosedValue = nullptr;
#else
                using FileHandle = int;
                static constexpr FileHandle FileHandleClosedValue = -1;
#endif
 
                File(const File &) = delete;
                File &operator=(const File &) = delete;
 
                File(ObjectBase *parent = nullptr);
 
                File(const String &fn, ObjectBase *parent = nullptr);
 
                File(const char *fn, ObjectBase *parent = nullptr);
 
                File(const FilePath &fp, ObjectBase *parent = nullptr);
 
                ~File();
 
                const String &filename() const { return _filename; }
 
                void setFilename(const String &fn) { _filename = fn; }
 
                int flags() const { return _fileFlags; }
 
                FileHandle handle() const { return _handle; }
 
                Error open(OpenMode mode) override;
 
                Error open(OpenMode mode, int fileFlags);
 
                Error close() override;
 
                bool isOpen() const override;
 
                int64_t write(const void *data, int64_t maxSize) override;
 
                bool isSequential() const override;
 
                Error seek(int64_t offset) override;
 
                int64_t pos() const override;
 
                Result<int64_t> size() const override;
 
                bool atEnd() const override;
 
                Result<int64_t> seekFromCurrent(int64_t offset) const;
 
                Result<int64_t> seekFromEnd(int64_t offset) const;
 
                Error truncate(int64_t offset) const;
 
                Result<size_t> directIOAlignment() const;
 
                Error readBulk(Buffer &buf, int64_t size);
 
                Error setDirectIO(bool enable);
 
                bool isDirectIO() const { return _directIO; }
 
                Error setSynchronous(bool enable);
 
                bool isSynchronous() const { return _synchronous; }
 
                Error setNonBlocking(bool enable);
 
                bool isNonBlocking() const { return _nonBlocking; }
 
        protected:
 
                int64_t readFromDevice(void *data, int64_t maxSize) override;
 
                int64_t deviceBytesAvailable() const override;
 
        private:
                bool            _directIO = false;         
                bool            _synchronous = false;      
                bool            _nonBlocking = false;      
                String          _filename;
                int             _fileFlags = NoFlags;
                FileHandle      _handle = FileHandleClosedValue;
                bool            _savedUnbuffered = false;  
};
 
PROMEKI_NAMESPACE_END