// InBuffer.h #ifndef ZIP7_INC_IN_BUFFER_H #define ZIP7_INC_IN_BUFFER_H #include "../../Common/MyException.h" #include "../IStream.h" #ifndef Z7_NO_EXCEPTIONS struct CInBufferException: public CSystemException { CInBufferException(HRESULT errorCode): CSystemException(errorCode) {} }; #endif class CInBufferBase { protected: Byte *_buf; Byte *_bufLim; Byte *_bufBase; ISequentialInStream *_stream; UInt64 _processedSize; size_t _bufSize; // actually it's number of Bytes for next read. The buf can be larger // only up to 32-bits values now are supported! bool _wasFinished; bool ReadBlock(); bool ReadByte_FromNewBlock(Byte &b); Byte ReadByte_FromNewBlock(); public: #ifdef Z7_NO_EXCEPTIONS HRESULT ErrorCode; #endif UInt32 NumExtraBytes; CInBufferBase() throw(); // the size of portion of data in real stream that was already read from this object // it doesn't include unused data in buffer // it doesn't include virtual Extra bytes after the end of real stream data UInt64 GetStreamSize() const { return _processedSize + (size_t)(_buf - _bufBase); } // the size of virtual data that was read from this object // it doesn't include unused data in buffers // it includes any virtual Extra bytes after the end of real data UInt64 GetProcessedSize() const { return _processedSize + NumExtraBytes + (size_t)(_buf - _bufBase); } bool WasFinished() const { return _wasFinished; } void SetStream(ISequentialInStream *stream) { _stream = stream; } void SetBuf(Byte *buf, size_t bufSize, size_t end, size_t pos) { _bufBase = buf; _bufSize = bufSize; _processedSize = 0; _buf = buf + pos; _bufLim = buf + end; _wasFinished = false; #ifdef Z7_NO_EXCEPTIONS ErrorCode = S_OK; #endif NumExtraBytes = 0; } void Init() throw(); Z7_FORCE_INLINE bool ReadByte(Byte &b) { if (_buf >= _bufLim) return ReadByte_FromNewBlock(b); b = *_buf++; return true; } Z7_FORCE_INLINE bool ReadByte_FromBuf(Byte &b) { if (_buf >= _bufLim) return false; b = *_buf++; return true; } Z7_FORCE_INLINE Byte ReadByte() { if (_buf >= _bufLim) return ReadByte_FromNewBlock(); return *_buf++; } size_t ReadBytes(Byte *buf, size_t size); size_t Skip(size_t size); }; class CInBuffer: public CInBufferBase { public: ~CInBuffer() { Free(); } bool Create(size_t bufSize) throw(); // only up to 32-bits values now are supported! void Free() throw(); }; #endif