1 // StreamObjects.h
2
3 #ifndef __STREAM_OBJECTS_H
4 #define __STREAM_OBJECTS_H
5
6 #include "../../Common/MyBuffer.h"
7 #include "../../Common/MyCom.h"
8 #include "../../Common/MyVector.h"
9
10 #include "../IStream.h"
11
12 class CBufferInStream:
13 public IInStream,
14 public CMyUnknownImp
15 {
16 UInt64 _pos;
17 public:
18 CByteBuffer Buf;
Init()19 void Init() { _pos = 0; }
20
21 MY_UNKNOWN_IMP2(ISequentialInStream, IInStream)
22
23 STDMETHOD(Read)(void *data, UInt32 size, UInt32 *processedSize);
24 STDMETHOD(Seek)(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition);
25 };
26
27
28 struct CReferenceBuf:
29 public IUnknown,
30 public CMyUnknownImp
31 {
32 CByteBuffer Buf;
33 MY_UNKNOWN_IMP
34 };
35
36
37 class CBufInStream:
38 public IInStream,
39 public CMyUnknownImp
40 {
41 const Byte *_data;
42 UInt64 _pos;
43 size_t _size;
44 CMyComPtr<IUnknown> _ref;
45 public:
46 void Init(const Byte *data, size_t size, IUnknown *ref = NULL)
47 {
48 _data = data;
49 _size = size;
50 _pos = 0;
51 _ref = ref;
52 }
Init(CReferenceBuf * ref)53 void Init(CReferenceBuf *ref) { Init(ref->Buf, ref->Buf.Size(), ref); }
54
55 MY_UNKNOWN_IMP2(ISequentialInStream, IInStream)
56 STDMETHOD(Read)(void *data, UInt32 size, UInt32 *processedSize);
57 STDMETHOD(Seek)(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition);
58 };
59
60
61 void Create_BufInStream_WithReference(const void *data, size_t size, IUnknown *ref, ISequentialInStream **stream);
62 void Create_BufInStream_WithNewBuffer(const void *data, size_t size, ISequentialInStream **stream);
Create_BufInStream_WithNewBuffer(const CByteBuffer & buf,ISequentialInStream ** stream)63 inline void Create_BufInStream_WithNewBuffer(const CByteBuffer &buf, ISequentialInStream **stream)
64 { Create_BufInStream_WithNewBuffer(buf, buf.Size(), stream); }
65
66
67 class CByteDynBuffer
68 {
69 size_t _capacity;
70 Byte *_buf;
71 CLASS_NO_COPY(CByteDynBuffer);
72 public:
CByteDynBuffer()73 CByteDynBuffer(): _capacity(0), _buf(NULL) {};
74 // there is no copy constructor. So don't copy this object.
~CByteDynBuffer()75 ~CByteDynBuffer() { Free(); }
76 void Free() throw();
GetCapacity()77 size_t GetCapacity() const { return _capacity; }
78 operator Byte*() const { return _buf; }
79 operator const Byte*() const { return _buf; }
80 bool EnsureCapacity(size_t capacity) throw();
81 };
82
83
84 class CDynBufSeqOutStream:
85 public ISequentialOutStream,
86 public CMyUnknownImp
87 {
88 CByteDynBuffer _buffer;
89 size_t _size;
90 public:
CDynBufSeqOutStream()91 CDynBufSeqOutStream(): _size(0) {}
Init()92 void Init() { _size = 0; }
GetSize()93 size_t GetSize() const { return _size; }
GetBuffer()94 const Byte *GetBuffer() const { return _buffer; }
95 void CopyToBuffer(CByteBuffer &dest) const;
96 Byte *GetBufPtrForWriting(size_t addSize);
UpdateSize(size_t addSize)97 void UpdateSize(size_t addSize) { _size += addSize; }
98
99 MY_UNKNOWN_IMP1(ISequentialOutStream)
100 STDMETHOD(Write)(const void *data, UInt32 size, UInt32 *processedSize);
101 };
102
103
104 class CBufPtrSeqOutStream:
105 public ISequentialOutStream,
106 public CMyUnknownImp
107 {
108 Byte *_buffer;
109 size_t _size;
110 size_t _pos;
111 public:
Init(Byte * buffer,size_t size)112 void Init(Byte *buffer, size_t size)
113 {
114 _buffer = buffer;
115 _pos = 0;
116 _size = size;
117 }
GetPos()118 size_t GetPos() const { return _pos; }
119
120 MY_UNKNOWN_IMP1(ISequentialOutStream)
121 STDMETHOD(Write)(const void *data, UInt32 size, UInt32 *processedSize);
122 };
123
124
125 class CSequentialOutStreamSizeCount:
126 public ISequentialOutStream,
127 public CMyUnknownImp
128 {
129 CMyComPtr<ISequentialOutStream> _stream;
130 UInt64 _size;
131 public:
SetStream(ISequentialOutStream * stream)132 void SetStream(ISequentialOutStream *stream) { _stream = stream; }
Init()133 void Init() { _size = 0; }
GetSize()134 UInt64 GetSize() const { return _size; }
135
136 MY_UNKNOWN_IMP1(ISequentialOutStream)
137 STDMETHOD(Write)(const void *data, UInt32 size, UInt32 *processedSize);
138 };
139
140
141 class CCachedInStream:
142 public IInStream,
143 public CMyUnknownImp
144 {
145 UInt64 *_tags;
146 Byte *_data;
147 size_t _dataSize;
148 unsigned _blockSizeLog;
149 unsigned _numBlocksLog;
150 UInt64 _size;
151 UInt64 _pos;
152 protected:
153 virtual HRESULT ReadBlock(UInt64 blockIndex, Byte *dest, size_t blockSize) = 0;
154 public:
CCachedInStream()155 CCachedInStream(): _tags(NULL), _data(NULL) {}
~CCachedInStream()156 virtual ~CCachedInStream() { Free(); } // the destructor must be virtual (release calls it) !!!
157 void Free() throw();
158 bool Alloc(unsigned blockSizeLog, unsigned numBlocksLog) throw();
159 void Init(UInt64 size) throw();
160
161 MY_UNKNOWN_IMP2(ISequentialInStream, IInStream)
162 STDMETHOD(Read)(void *data, UInt32 size, UInt32 *processedSize);
163 STDMETHOD(Seek)(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition);
164 };
165
166 #endif
167