bufferediodevice.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_CORE
#include <promeki/iodevice.h>
#include <promeki/buffer.h>
#include <promeki/list.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class BufferedIODevice : public IODevice {
                PROMEKI_OBJECT(BufferedIODevice, IODevice)
        public:
                BufferedIODevice(ObjectBase *parent = nullptr);
 
                virtual ~BufferedIODevice();
 
                int64_t read(void *data, int64_t maxSize) override;
 
                int64_t bytesAvailable() const override;
 
                Error setReadBuffer(Buffer &&buf);
 
                const Buffer &readBuffer() const { return _readBuf; }
 
                size_t readBufferSize() const { return _readBuf.availSize(); }
 
                Buffer readLine(size_t maxLength = 0);
 
                Buffer readAll();
 
                Buffer readBytes(size_t maxBytes);
 
                bool canReadLine() const;
 
                int64_t peek(void *buf, size_t maxBytes) const;
 
                Buffer peek(size_t maxBytes) const;
 
                void setUnbuffered(bool enable);
 
                bool isUnbuffered() const { return _unbuffered; }
 
                int64_t write(const void *data, int64_t maxSize) override;
 
                void flush() override;
 
                void setWriteBuffered(bool enable);
 
                bool isWriteBuffered() const { return _writeBuffered; }
 
                size_t writeBufferCapacity() const { return _writeBufCapacity; }
 
                void setWriteBufferCapacity(size_t bytes);
 
        protected:
                virtual int64_t readFromDevice(void *data, int64_t maxSize) = 0;
 
                virtual int64_t writeToDevice(const void *data, int64_t maxSize) = 0;
 
                virtual int64_t deviceBytesAvailable() const;
 
                size_t bufferedBytesUnconsumed() const { return _readBufFill - _readBufPos; }
 
                size_t bufferedBytesPending() const { return _writeBuf.size(); }
 
                void ensureReadBuffer();
 
                void resetReadBuffer();
 
        private:
                static constexpr size_t DefaultReadBufSize = 8192;
 
                static constexpr size_t DefaultWriteBufSize = 8192;
 
                bool   _unbuffered = false;      
                Buffer _readBuf;                 
                size_t _readBufPos = 0;          
                size_t _readBufFill = 0;         
                bool   _bufferAllocated = false; 
 
                bool       _writeBuffered = false;                 
                size_t     _writeBufCapacity = DefaultWriteBufSize; 
                List<char> _writeBuf;                              
 
                int64_t fillBuffer();
 
                void compactBuffer();
};
 
PROMEKI_NAMESPACE_END
 
#endif // PROMEKI_ENABLE_CORE