1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
|
// StreamObjects.h
#ifndef __STREAMOBJECTS_H
#define __STREAMOBJECTS_H
#include "../../Common/DynamicBuffer.h"
#include "../../Common/MyCom.h"
#include "../IStream.h"
/*
class COutStreamImp:
public ISequentialStream,
public CMyUnknownImp
{
CByteDynamicBuffer _buffer;
size_t _size;
public:
COutStreamImp(): _size(0) {}
void Init(){ _size = 0; }
size_t GetSize() const { return _size; }
const CByteDynamicBuffer& GetBuffer() const { return _buffer; }
MY_UNKNOWN_IMP
STDMETHODIMP Read(void *data, ULONG size, ULONG *processedSize);
STDMETHODIMP Write(void const *data, ULONG size, ULONG *processedSize);
};
class CInStreamImp:
public ISequentialStream,
public CMyUnknownImp
{
Byte *_dataPointer;
size_t _size;
size_t _pos;
public:
CInStreamImp(): _size(0xFFFFFFFF), _pos(0), _dataPointer(NULL) {}
void Init(Byte *dataPointer, size_t size);
MY_UNKNOWN_IMP
STDMETHODIMP Read(void *data, ULONG size, ULONG *processedSize);
STDMETHODIMP Write(void const *data, ULONG size, ULONG *processedSize);
};
*/
class CSequentialInStreamImp:
public ISequentialInStream,
public CMyUnknownImp
{
const Byte *_dataPointer;
size_t _size;
size_t _pos;
public:
void Init(const Byte *dataPointer, size_t size)
{
_dataPointer = dataPointer;
_size = size;
_pos = 0;
}
MY_UNKNOWN_IMP
STDMETHOD(Read)(void *data, UInt32 size, UInt32 *processedSize);
STDMETHOD(ReadPart)(void *data, UInt32 size, UInt32 *processedSize);
};
class CWriteBuffer
{
CByteDynamicBuffer _buffer;
size_t _size;
public:
CWriteBuffer(): _size(0) {}
// void Init(size_t size = 0)
void Init()
{
/*
if (size > 0)
_buffer.EnsureCapacity(size);
*/
_size = 0;
}
void Write(const void *data, size_t size);
size_t GetSize() const { return _size; }
const CByteDynamicBuffer& GetBuffer() const { return _buffer; }
};
class CSequentialOutStreamImp:
public ISequentialOutStream,
public CMyUnknownImp
{
CWriteBuffer _writeBuffer;
public:
void Init()
{
_writeBuffer.Init();
}
/*
void Init(size_t size = 0)
{
_writeBuffer.Init(size);
}
*/
size_t GetSize() const { return _writeBuffer.GetSize(); }
const CByteDynamicBuffer& GetBuffer() const { return _writeBuffer.GetBuffer(); }
MY_UNKNOWN_IMP
STDMETHOD(Write)(const void *data, UInt32 size, UInt32 *processedSize);
STDMETHOD(WritePart)(const void *data, UInt32 size, UInt32 *processedSize);
};
class CSequentialOutStreamImp2:
public ISequentialOutStream,
public CMyUnknownImp
{
Byte *_buffer;
public:
size_t _size;
size_t _pos;
void Init(Byte *buffer, size_t size)
{
_buffer = buffer;
_pos = 0;
_size = size;
}
MY_UNKNOWN_IMP
STDMETHOD(Write)(const void *data, UInt32 size, UInt32 *processedSize);
STDMETHOD(WritePart)(const void *data, UInt32 size, UInt32 *processedSize);
};
class CSequentialInStreamSizeCount:
public ISequentialInStream,
public CMyUnknownImp
{
CMyComPtr<ISequentialInStream> _stream;
UInt64 _size;
public:
void Init(ISequentialInStream *stream)
{
_stream = stream;
_size = 0;
}
UInt64 GetSize() const { return _size; }
MY_UNKNOWN_IMP
STDMETHOD(Read)(void *data, UInt32 size, UInt32 *processedSize);
STDMETHOD(ReadPart)(void *data, UInt32 size, UInt32 *processedSize);
};
class CSequentialInStreamRollback:
public ISequentialInStream,
public CMyUnknownImp
{
CMyComPtr<ISequentialInStream> _stream;
Byte *_buffer;
size_t _bufferSize;
UInt64 _size;
size_t _currentSize;
size_t _currentPos;
public:
CSequentialInStreamRollback(size_t bufferSize):
_bufferSize(bufferSize),
_buffer(0)
{
_buffer = new Byte[bufferSize];
}
~CSequentialInStreamRollback()
{
delete _buffer;
}
void Init(ISequentialInStream *stream)
{
_stream = stream;
_size = 0;
_currentSize = 0;
_currentPos = 0;
}
UInt64 GetSize() const { return _size; }
MY_UNKNOWN_IMP
STDMETHOD(Read)(void *data, UInt32 size, UInt32 *processedSize);
STDMETHOD(ReadPart)(void *data, UInt32 size, UInt32 *processedSize);
HRESULT Rollback(size_t rollbackSize);
};
class CSequentialOutStreamSizeCount:
public ISequentialOutStream,
public CMyUnknownImp
{
CMyComPtr<ISequentialOutStream> _stream;
UInt64 _size;
public:
void Init(ISequentialOutStream *stream)
{
_stream = stream;
_size = 0;
}
UInt64 GetSize() const { return _size; }
MY_UNKNOWN_IMP
STDMETHOD(Write)(const void *data, UInt32 size, UInt32 *processedSize);
STDMETHOD(WritePart)(const void *data, UInt32 size, UInt32 *processedSize);
};
#endif
|
