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