1 // Common/MyBuffer.h 2 3 #ifndef ZIP7_INC_COMMON_MY_BUFFER_H 4 #define ZIP7_INC_COMMON_MY_BUFFER_H 5 6 #include <string.h> 7 8 #include "Defs.h" 9 #include "MyTypes.h" 10 11 /* 7-Zip now uses CBuffer only as CByteBuffer. 12 So there is no need to use Z7_ARRAY_NEW macro in CBuffer code. */ 13 14 template <class T> class CBuffer 15 { 16 T *_items; 17 size_t _size; 18 19 public: Free()20 void Free() 21 { 22 if (_items) 23 { 24 delete []_items; 25 _items = NULL; 26 } 27 _size = 0; 28 } 29 CBuffer()30 CBuffer(): _items(NULL), _size(0) {} CBuffer(size_t size)31 CBuffer(size_t size): _items(NULL), _size(0) 32 { 33 if (size != 0) 34 { 35 _items = new T[size]; 36 _size = size; 37 } 38 } CBuffer(const CBuffer & buffer)39 CBuffer(const CBuffer &buffer): _items(NULL), _size(0) 40 { 41 const size_t size = buffer._size; 42 if (size != 0) 43 { 44 _items = new T[size]; 45 memcpy(_items, buffer._items, size * sizeof(T)); 46 _size = size; 47 } 48 } 49 ~CBuffer()50 ~CBuffer() { delete []_items; } 51 52 operator T *() { return _items; } 53 operator const T *() const { return _items; } ConstData()54 const T* ConstData() const { return _items; } NonConstData()55 T* NonConstData() const { return _items; } NonConstData()56 T* NonConstData() { return _items; } 57 // const T* Data() const { return _items; } 58 // T* Data() { return _items; } 59 Size()60 size_t Size() const { return _size; } 61 Alloc(size_t size)62 void Alloc(size_t size) 63 { 64 if (size != _size) 65 { 66 Free(); 67 if (size != 0) 68 { 69 _items = new T[size]; 70 _size = size; 71 } 72 } 73 } 74 AllocAtLeast(size_t size)75 void AllocAtLeast(size_t size) 76 { 77 if (size > _size) 78 { 79 Free(); 80 _items = new T[size]; 81 _size = size; 82 } 83 } 84 CopyFrom(const T * data,size_t size)85 void CopyFrom(const T *data, size_t size) 86 { 87 Alloc(size); 88 if (size != 0) 89 memcpy(_items, data, size * sizeof(T)); 90 } 91 ChangeSize_KeepData(size_t newSize,size_t keepSize)92 void ChangeSize_KeepData(size_t newSize, size_t keepSize) 93 { 94 if (newSize == _size) 95 return; 96 T *newBuffer = NULL; 97 if (newSize != 0) 98 { 99 newBuffer = new T[newSize]; 100 if (keepSize > _size) 101 keepSize = _size; 102 if (keepSize != 0) 103 memcpy(newBuffer, _items, MyMin(keepSize, newSize) * sizeof(T)); 104 } 105 delete []_items; 106 _items = newBuffer; 107 _size = newSize; 108 } 109 Wipe()110 void Wipe() 111 { 112 if (_size != 0) 113 memset(_items, 0, _size * sizeof(T)); 114 } 115 116 CBuffer& operator=(const CBuffer &buffer) 117 { 118 if (&buffer != this) 119 CopyFrom(buffer, buffer._size); 120 return *this; 121 } 122 }; 123 124 template <class T> 125 bool operator==(const CBuffer<T>& b1, const CBuffer<T>& b2) 126 { 127 size_t size1 = b1.Size(); 128 if (size1 != b2.Size()) 129 return false; 130 if (size1 == 0) 131 return true; 132 return memcmp(b1, b2, size1 * sizeof(T)) == 0; 133 } 134 135 template <class T> 136 bool operator!=(const CBuffer<T>& b1, const CBuffer<T>& b2) 137 { 138 size_t size1 = b1.Size(); 139 if (size1 != b2.Size()) 140 return true; 141 if (size1 == 0) 142 return false; 143 return memcmp(b1, b2, size1 * sizeof(T)) != 0; 144 } 145 146 147 // typedef CBuffer<char> CCharBuffer; 148 // typedef CBuffer<wchar_t> CWCharBuffer; 149 typedef CBuffer<Byte> CByteBuffer; 150 151 152 class CByteBuffer_Wipe: public CByteBuffer 153 { Z7_CLASS_NO_COPY(CByteBuffer_Wipe)154 Z7_CLASS_NO_COPY(CByteBuffer_Wipe) 155 public: 156 // CByteBuffer_Wipe(): CBuffer<Byte>() {} 157 CByteBuffer_Wipe(size_t size): CBuffer<Byte>(size) {} ~CByteBuffer_Wipe()158 ~CByteBuffer_Wipe() { Wipe(); } 159 }; 160 161 162 163 template <class T> class CObjArray 164 { 165 protected: 166 T *_items; 167 private: 168 // we disable copy 169 CObjArray(const CObjArray &buffer); 170 void operator=(const CObjArray &buffer); 171 public: Free()172 void Free() 173 { 174 delete []_items; 175 _items = NULL; 176 } CObjArray(size_t size)177 CObjArray(size_t size): _items(NULL) 178 { 179 if (size != 0) 180 { 181 Z7_ARRAY_NEW(_items, T, size) 182 // _items = new T[size]; 183 } 184 } CObjArray()185 CObjArray(): _items(NULL) {} ~CObjArray()186 ~CObjArray() { delete []_items; } 187 188 operator T *() { return _items; } 189 operator const T *() const { return _items; } ConstData()190 const T* ConstData() const { return _items; } NonConstData()191 T* NonConstData() const { return _items; } NonConstData()192 T* NonConstData() { return _items; } 193 // const T* Data() const { return _items; } 194 // T* Data() { return _items; } 195 Alloc(size_t newSize)196 void Alloc(size_t newSize) 197 { 198 delete []_items; 199 _items = NULL; 200 Z7_ARRAY_NEW(_items, T, newSize) 201 // _items = new T[newSize]; 202 } 203 }; 204 205 typedef CObjArray<Byte> CByteArr; 206 typedef CObjArray<bool> CBoolArr; 207 typedef CObjArray<int> CIntArr; 208 typedef CObjArray<unsigned> CUIntArr; 209 210 211 template <class T> class CObjArray2 212 { 213 T *_items; 214 unsigned _size; 215 216 // we disable copy 217 CObjArray2(const CObjArray2 &buffer); 218 void operator=(const CObjArray2 &buffer); 219 public: 220 Free()221 void Free() 222 { 223 delete []_items; 224 _items = NULL; 225 _size = 0; 226 } CObjArray2()227 CObjArray2(): _items(NULL), _size(0) {} 228 /* 229 CObjArray2(const CObjArray2 &buffer): _items(NULL), _size(0) 230 { 231 size_t newSize = buffer._size; 232 if (newSize != 0) 233 { 234 T *newBuffer = new T[newSize];; 235 _items = newBuffer; 236 _size = newSize; 237 const T *src = buffer; 238 for (size_t i = 0; i < newSize; i++) 239 newBuffer[i] = src[i]; 240 } 241 } 242 */ 243 /* 244 CObjArray2(size_t size): _items(NULL), _size(0) 245 { 246 if (size != 0) 247 { 248 _items = new T[size]; 249 _size = size; 250 } 251 } 252 */ 253 ~CObjArray2()254 ~CObjArray2() { delete []_items; } 255 256 operator T *() { return _items; } 257 operator const T *() const { return _items; } 258 Size()259 unsigned Size() const { return (unsigned)_size; } IsEmpty()260 bool IsEmpty() const { return _size == 0; } 261 262 // SetSize doesn't keep old items. It allocates new array if size is not equal SetSize(unsigned size)263 void SetSize(unsigned size) 264 { 265 if (size == _size) 266 return; 267 T *newBuffer = NULL; 268 if (size != 0) 269 { 270 Z7_ARRAY_NEW(newBuffer, T, size) 271 // newBuffer = new T[size]; 272 } 273 delete []_items; 274 _items = newBuffer; 275 _size = size; 276 } 277 278 /* 279 CObjArray2& operator=(const CObjArray2 &buffer) 280 { 281 Free(); 282 size_t newSize = buffer._size; 283 if (newSize != 0) 284 { 285 T *newBuffer = new T[newSize];; 286 _items = newBuffer; 287 _size = newSize; 288 const T *src = buffer; 289 for (size_t i = 0; i < newSize; i++) 290 newBuffer[i] = src[i]; 291 } 292 return *this; 293 } 294 */ 295 }; 296 297 #endif 298