iodevice.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/objectbase.h>
#include <promeki/error.h>
#include <promeki/result.h>
#include <promeki/uniqueptr.h>
#include <promeki/sharedptr.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class IODevice : public ObjectBase {
                PROMEKI_OBJECT(IODevice, ObjectBase)
        public:
                using UPtr = UniquePtr<IODevice>;
 
                using Shared = SharedPtr<IODevice, false>;
 
                enum OpenMode {
                        NotOpen = 0x00,                   
                        ReadOnly = 0x01,                  
                        WriteOnly = 0x02,                 
                        ReadWrite = ReadOnly | WriteOnly, 
                        Append = 0x04 | WriteOnly         
                };
 
                IODevice(ObjectBase *parent = nullptr) : ObjectBase(parent) {}
 
                virtual ~IODevice();
 
                virtual Error open(OpenMode mode) = 0;
 
                virtual Error close() = 0;
 
                virtual bool isOpen() const = 0;
 
                virtual int64_t read(void *data, int64_t maxSize) = 0;
 
                virtual int64_t write(const void *data, int64_t maxSize) = 0;
 
                virtual void flush();
 
                virtual int64_t bytesAvailable() const;
 
                virtual bool waitForReadyRead(unsigned int timeoutMs = 0);
 
                virtual bool waitForBytesWritten(unsigned int timeoutMs = 0);
 
                virtual bool isSequential() const;
 
                virtual Error seek(int64_t pos);
 
                virtual int64_t pos() const;
 
                virtual Result<int64_t> size() const;
 
                virtual bool atEnd() const;
 
                OpenMode openMode() const { return _openMode; }
 
                bool isReadable() const { return _openMode & ReadOnly; }
 
                bool isWritable() const { return _openMode & WriteOnly; }
 
                Error error() const { return _error; }
 
                void clearError() {
                        _error = Error();
                        return;
                }
 
                PROMEKI_SIGNAL(readyRead);
 
                PROMEKI_SIGNAL(bytesWritten, int64_t);
 
                PROMEKI_SIGNAL(errorOccurred, Error);
 
                PROMEKI_SIGNAL(aboutToClose);
 
        protected:
                void setOpenMode(OpenMode mode) {
                        _openMode = mode;
                        return;
                }
 
                void setError(const Error &err) {
                        _error = err;
                        if (err.isError()) errorOccurredSignal.emit(err);
                        return;
                }
 
        private:
                OpenMode _openMode = NotOpen;
                Error    _error;
};
 
PROMEKI_NAMESPACE_END
 
#endif // PROMEKI_ENABLE_CORE