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
|
// OutBuffer.h
#ifndef ZIP7_INC_OUT_BUFFER_H
#define ZIP7_INC_OUT_BUFFER_H
#include "../IStream.h"
#include "../../Common/MyCom.h"
#include "../../Common/MyException.h"
#ifndef Z7_NO_EXCEPTIONS
struct COutBufferException: public CSystemException
{
COutBufferException(HRESULT errorCode): CSystemException(errorCode) {}
};
#endif
class COutBuffer
{
protected:
Byte *_buf;
UInt32 _pos;
UInt32 _limitPos;
UInt32 _streamPos;
UInt32 _bufSize;
ISequentialOutStream *_stream;
UInt64 _processedSize;
Byte *_buf2;
bool _overDict;
HRESULT FlushPart() throw();
public:
#ifdef Z7_NO_EXCEPTIONS
HRESULT ErrorCode;
#endif
COutBuffer(): _buf(NULL), _pos(0), _stream(NULL), _buf2(NULL) {}
~COutBuffer() { Free(); }
bool Create(UInt32 bufSize) throw();
void Free() throw();
void SetMemStream(Byte *buf) { _buf2 = buf; }
void SetStream(ISequentialOutStream *stream) { _stream = stream; }
void Init() throw();
HRESULT Flush() throw();
void FlushWithCheck();
void WriteByte(Byte b)
{
UInt32 pos = _pos;
_buf[pos] = b;
pos++;
_pos = pos;
if (pos == _limitPos)
FlushWithCheck();
}
void WriteBytes(const void *data, size_t size)
{
for (size_t i = 0; i < size; i++)
WriteByte(((const Byte *)data)[i]);
}
Byte *GetOutBuffer(size_t &avail)
{
const UInt32 pos = _pos;
avail = (size_t)(_limitPos - pos);
return _buf + pos;
}
void SkipWrittenBytes(size_t num)
{
const UInt32 pos = _pos;
const UInt32 rem = _limitPos - pos;
if (rem > num)
{
_pos = pos + (UInt32)num;
return;
}
// (rem <= num)
// the caller must not call it with (rem < num)
// so (rem == num)
_pos = _limitPos;
FlushWithCheck();
}
/*
void WriteBytesBig(const void *data, size_t size)
{
while (size)
{
UInt32 pos = _pos;
UInt32 rem = _limitPos - pos;
if (rem > size)
{
_pos = pos + size;
memcpy(_buf + pos, data, size);
return;
}
memcpy(_buf + pos, data, rem);
_pos = pos + rem;
FlushWithCheck();
}
}
*/
UInt64 GetProcessedSize() const throw();
};
#endif
|
