file.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_CORE
#include <cstdint>
#include <promeki/namespace.h>
#include <promeki/platform.h>
#include <promeki/string.h>
#include <promeki/filepath.h>
#include <promeki/error.h>
#include <promeki/result.h>
#include <promeki/bufferediodevice.h>
#include <promeki/uniqueptr.h>
 
// Forward-declared so file.h does not need to pull <cirf/types.h>
// into every consumer of File. The pointer is only ever stored as
// a member; methods that need to dereference it include
// <cirf/types.h> in file.cpp.
struct cirf_file;
typedef struct cirf_file cirf_file_t;
 
PROMEKI_NAMESPACE_BEGIN
 
class File : public BufferedIODevice {
                PROMEKI_OBJECT(File, BufferedIODevice)
        public:
                using UPtr = UniquePtr<File>;
 
                enum Flags {
                        NoFlags = 0x00,  
                        Create = 0x01,   
                        Append = 0x02,   
                        Truncate = 0x04, 
                        Exclusive = 0x08 
                };
 
                struct IOVec {
                                const void *data; 
                                size_t      size; 
                };
 
#if defined(PROMEKI_PLATFORM_WINDOWS)
                using FileHandle = HANDLE;
                static constexpr FileHandle FileHandleClosedValue = nullptr;
#else
                using FileHandle = int;
                static constexpr FileHandle FileHandleClosedValue = -1;
#endif
 
                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;
 
                int64_t writev(const IOVec *iov, int count);
 
                Error preallocate(int64_t offset, int64_t length);
 
                Result<size_t> directIOAlignment() const;
 
                Error readBulk(Buffer &buf, int64_t size);
 
                int64_t writeBulk(const void *data, int64_t size);
 
                Error sync(bool dataOnly = true);
 
                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; }
 
                bool isResource() const { return _resourceFile != nullptr; }
 
        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; 
                const cirf_file_t *_resourceFile = nullptr;  
                int64_t            _resourcePos = 0;         
};
 
PROMEKI_NAMESPACE_END
 
#endif // PROMEKI_ENABLE_CORE