1 // Common/MyBuffer.h 2 3 #ifndef __COMMON_MY_BUFFER_H 4 #define __COMMON_MY_BUFFER_H 5 6 #include "Defs.h" 7 8 template <class T> class CBuffer 9 { 10 T *_items; 11 size_t _size; 12 13 void CopyToEmpty(const CBuffer &buffer) 14 { 15 if (buffer._size > 0) 16 { 17 _items = new T[buffer._size]; 18 memcpy(_items, buffer._items, buffer._size * sizeof(T)); 19 _size = buffer._size; 20 } 21 } 22 public: 23 void Free() 24 { 25 if (_items) 26 { 27 delete []_items; 28 _items = 0; 29 } 30 _size = 0; 31 } 32 33 CBuffer(): _items(0), _size(0) {}; 34 CBuffer(size_t size): _items(0), _size(0) { _items = new T[size]; _size = size; } 35 CBuffer(const CBuffer &buffer): _items(0), _size(0) { CopyToEmpty(buffer); } 36 ~CBuffer() { delete []_items; } 37 38 operator T *() { return _items; }; 39 operator const T *() const { return _items; }; 40 size_t Size() const { return _size; } 41 42 void Alloc(size_t size) 43 { 44 if (size != _size) 45 { 46 Free(); 47 if (size != 0) 48 { 49 _items = new T[size]; 50 _size = size; 51 } 52 } 53 } 54 55 void AllocAtLeast(size_t size) 56 { 57 if (size > _size) 58 { 59 Free(); 60 _items = new T[size]; 61 _size = size; 62 } 63 } 64 65 void CopyFrom(const T *data, size_t size) 66 { 67 Alloc(size); 68 memcpy(_items, data, size * sizeof(T)); 69 } 70 71 void ChangeSize_KeepData(size_t newSize, size_t keepSize) 72 { 73 if (newSize == _size) 74 return; 75 T *newBuffer = NULL; 76 if (newSize > 0) 77 { 78 newBuffer = new T[newSize]; 79 if (_size > 0) 80 memcpy(newBuffer, _items, MyMin(MyMin(_size, keepSize), newSize) * sizeof(T)); 81 } 82 delete []_items; 83 _items = newBuffer; 84 _size = newSize; 85 } 86 87 CBuffer& operator=(const CBuffer &buffer) 88 { 89 Free(); 90 CopyToEmpty(buffer); 91 return *this; 92 } 93 }; 94 95 template <class T> 96 bool operator==(const CBuffer<T>& b1, const CBuffer<T>& b2) 97 { 98 size_t size1 = b1.Size(); 99 if (size1 != b2.Size()) 100 return false; 101 return memcmp(b1, b2, size1 * sizeof(T)) == 0; 102 } 103 104 template <class T> 105 bool operator!=(const CBuffer<T>& b1, const CBuffer<T>& b2) 106 { 107 size_t size1 = b1.Size(); 108 if (size1 == b2.Size()) 109 return false; 110 return memcmp(b1, b2, size1 * sizeof(T)) != 0; 111 } 112 113 114 typedef CBuffer<char> CCharBuffer; 115 typedef CBuffer<wchar_t> CWCharBuffer; 116 typedef CBuffer<unsigned char> CByteBuffer; 117 118 119 template <class T> class CObjArray 120 { 121 protected: 122 T *_items; 123 private: 124 // we disable constructors 125 CObjArray(const CObjArray &buffer); 126 void operator=(const CObjArray &buffer); 127 public: 128 void Free() 129 { 130 delete []_items; 131 _items = 0; 132 } 133 CObjArray(size_t size): _items(0) { if (size != 0) _items = new T[size]; } 134 CObjArray(): _items(0) {}; 135 ~CObjArray() { delete []_items; } 136 137 operator T *() { return _items; }; 138 operator const T *() const { return _items; }; 139 140 void Alloc(size_t newSize) 141 { 142 delete []_items; 143 _items = 0; 144 _items = new T[newSize]; 145 } 146 }; 147 148 typedef CObjArray<unsigned char> CByteArr; 149 typedef CObjArray<bool> CBoolArr; 150 typedef CObjArray<int> CIntArr; 151 152 // #define CRecArray CObjArray 153 154 template <class T> class CObjArray2 155 { 156 // protected: 157 T *_items; 158 unsigned _size; 159 160 CObjArray2(const CObjArray2 &buffer); 161 void operator=(const CObjArray2 &buffer); 162 public: 163 164 void Free() 165 { 166 delete []_items; 167 _items = 0; 168 _size = 0; 169 } 170 CObjArray2(): _items(0), _size(0) {}; 171 /* 172 CObjArray2(const CObjArray2 &buffer): _items(0), _size(0) 173 { 174 size_t newSize = buffer._size; 175 if (newSize > 0) 176 { 177 T *newBuffer = new T[newSize];; 178 _items = newBuffer; 179 _size = newSize; 180 const T *src = buffer; 181 for (size_t i = 0; i < newSize; i++) 182 newBuffer[i] = src[i]; 183 } 184 } 185 */ 186 /* 187 CObjArray2(size_t size): _items(0), _size(0) 188 { 189 if (size != 0) 190 { 191 _items = new T[size]; 192 _size = size; 193 } 194 } 195 */ 196 197 ~CObjArray2() { delete []_items; } 198 199 operator T *() { return _items; }; 200 operator const T *() const { return _items; }; 201 202 unsigned Size() const { return (unsigned)_size; } 203 bool IsEmpty() const { return _size == 0; } 204 205 // SetSize doesn't keep old items. It allocates new array if size is not equal 206 void SetSize(unsigned size) 207 { 208 if (size == _size) 209 return; 210 T *newBuffer = NULL; 211 if (size > 0) 212 newBuffer = new T[size]; 213 delete []_items; 214 _items = newBuffer; 215 _size = size; 216 } 217 218 /* 219 CObjArray2& operator=(const CObjArray2 &buffer) 220 { 221 Free(); 222 size_t newSize = buffer._size; 223 if (newSize > 0) 224 { 225 T *newBuffer = new T[newSize];; 226 _items = newBuffer; 227 _size = newSize; 228 const T *src = buffer; 229 for (size_t i = 0; i < newSize; i++) 230 newBuffer[i] = src[i]; 231 } 232 return *this; 233 } 234 */ 235 }; 236 237 #endif 238
