iodevice.h

Go to the documentation of this file.

 
#pragma once
 
#include <cstdint>
#include <promeki/core/namespace.h>
#include <promeki/core/objectbase.h>
#include <promeki/core/error.h>
#include <promeki/core/result.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class IODevice : public ObjectBase {
        PROMEKI_OBJECT(IODevice, ObjectBase)
        public:
                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