'21.07'21.07

1 files changed, 277 insertions, 0 deletions

diff --git a/CPP/Common/MyBuffer.h b/CPP/Common/MyBuffer.h
new file mode 100644
index 0000000..18ab6fa
--- /dev/null
+++ b/CPP/Common/MyBuffer.h
@@ -0,0 +1,277 @@
+// Common/MyBuffer.h
+
+#ifndef __COMMON_MY_BUFFER_H
+#define __COMMON_MY_BUFFER_H
+
+#include "Defs.h"
+#include "MyTypes.h"
+
+/* 7-Zip now uses CBuffer only as CByteBuffer.
+   So there is no need to use MY_ARRAY_NEW macro in CBuffer code. */
+
+template <class T> class CBuffer
+{
+  T *_items;
+  size_t _size;
+
+public:
+  void Free()
+  {
+    if (_items)
+    {
+      delete []_items;
+      _items = 0;
+    }
+    _size = 0;
+  }
+  
+  CBuffer(): _items(0), _size(0) {};
+  CBuffer(size_t size): _items(0), _size(0) { _items = new T[size]; _size = size; }
+  CBuffer(const CBuffer &buffer): _items(0), _size(0)
+  {
+    size_t size = buffer._size;
+    if (size != 0)
+    {
+      _items = new T[size];
+      memcpy(_items, buffer._items, size * sizeof(T));
+      _size = size;
+    }
+  }
+
+  ~CBuffer() { delete []_items; }
+
+  operator       T *()       { return _items; }
+  operator const T *() const { return _items; }
+  size_t Size() const { return _size; }
+
+  void Alloc(size_t size)
+  {
+    if (size != _size)
+    {
+      Free();
+      if (size != 0)
+      {
+        _items = new T[size];
+        _size = size;
+      }
+    }
+  }
+
+  void AllocAtLeast(size_t size)
+  {
+    if (size > _size)
+    {
+      Free();
+      _items = new T[size];
+      _size = size;
+    }
+  }
+
+  void CopyFrom(const T *data, size_t size)
+  {
+    Alloc(size);
+    if (size != 0)
+      memcpy(_items, data, size * sizeof(T));
+  }
+
+  void ChangeSize_KeepData(size_t newSize, size_t keepSize)
+  {
+    if (newSize == _size)
+      return;
+    T *newBuffer = NULL;
+    if (newSize != 0)
+    {
+      newBuffer = new T[newSize];
+      if (keepSize > _size)
+        keepSize = _size;
+      if (keepSize != 0)
+        memcpy(newBuffer, _items, MyMin(keepSize, newSize) * sizeof(T));
+    }
+    delete []_items;
+    _items = newBuffer;
+    _size = newSize;
+  }
+
+  void Wipe()
+  {
+    if (_size != 0)
+      memset(_items, 0, _size * sizeof(T));
+  }
+
+  CBuffer& operator=(const CBuffer &buffer)
+  {
+    if (&buffer != this)
+      CopyFrom(buffer, buffer._size);
+    return *this;
+  }
+};
+
+template <class T>
+bool operator==(const CBuffer<T>& b1, const CBuffer<T>& b2)
+{
+  size_t size1 = b1.Size();
+  if (size1 != b2.Size())
+    return false;
+  if (size1 == 0)
+    return true;
+  return memcmp(b1, b2, size1 * sizeof(T)) == 0;
+}
+
+template <class T>
+bool operator!=(const CBuffer<T>& b1, const CBuffer<T>& b2)
+{
+  size_t size1 = b1.Size();
+  if (size1 != b2.Size())
+    return true;
+  if (size1 == 0)
+    return false;
+  return memcmp(b1, b2, size1 * sizeof(T)) != 0;
+}
+
+
+// typedef CBuffer<char> CCharBuffer;
+// typedef CBuffer<wchar_t> CWCharBuffer;
+typedef CBuffer<unsigned char> CByteBuffer;
+
+
+class CByteBuffer_Wipe: public CByteBuffer
+{
+  CLASS_NO_COPY(CByteBuffer_Wipe)
+public:
+  // CByteBuffer_Wipe(): CBuffer<unsigned char>() {}
+  CByteBuffer_Wipe(size_t size): CBuffer<unsigned char>(size) {}
+  ~CByteBuffer_Wipe() { Wipe(); }
+};
+
+
+
+template <class T> class CObjArray
+{
+protected:
+  T *_items;
+private:
+  // we disable copy
+  CObjArray(const CObjArray &buffer);
+  void operator=(const CObjArray &buffer);
+public:
+  void Free()
+  {
+    delete []_items;
+    _items = 0;
+  }
+  CObjArray(size_t size): _items(0)
+  {
+    if (size != 0)
+    {
+      MY_ARRAY_NEW(_items, T, size)
+      // _items = new T[size];
+    }
+  }
+  CObjArray(): _items(0) {};
+  ~CObjArray() { delete []_items; }
+  
+  operator       T *()       { return _items; }
+  operator const T *() const { return _items; }
+  
+  void Alloc(size_t newSize)
+  {
+    delete []_items;
+    _items = 0;
+    MY_ARRAY_NEW(_items, T, newSize)
+    // _items = new T[newSize];
+  }
+};
+
+typedef CObjArray<unsigned char> CByteArr;
+typedef CObjArray<bool> CBoolArr;
+typedef CObjArray<int> CIntArr;
+typedef CObjArray<unsigned> CUIntArr;
+
+
+template <class T> class CObjArray2
+{
+  T *_items;
+  unsigned _size;
+
+  // we disable copy
+  CObjArray2(const CObjArray2 &buffer);
+  void operator=(const CObjArray2 &buffer);
+public:
+  
+  void Free()
+  {
+    delete []_items;
+    _items = 0;
+    _size = 0;
+  }
+  CObjArray2(): _items(0), _size(0) {};
+  /*
+  CObjArray2(const CObjArray2 &buffer): _items(0), _size(0)
+  {
+    size_t newSize = buffer._size;
+    if (newSize != 0)
+    {
+      T *newBuffer = new T[newSize];;
+      _items = newBuffer;
+      _size = newSize;
+      const T *src = buffer;
+      for (size_t i = 0; i < newSize; i++)
+        newBuffer[i] = src[i];
+    }
+  }
+  */
+  /*
+  CObjArray2(size_t size): _items(0), _size(0)
+  {
+    if (size != 0)
+    {
+      _items = new T[size];
+      _size = size;
+    }
+  }
+  */
+
+  ~CObjArray2() { delete []_items; }
+  
+  operator       T *()       { return _items; }
+  operator const T *() const { return _items; }
+  
+  unsigned Size() const { return (unsigned)_size; }
+  bool IsEmpty() const { return _size == 0; }
+
+  // SetSize doesn't keep old items. It allocates new array if size is not equal
+  void SetSize(unsigned size)
+  {
+    if (size == _size)
+      return;
+    T *newBuffer = NULL;
+    if (size != 0)
+    {
+      MY_ARRAY_NEW(newBuffer, T, size)
+      // newBuffer = new T[size];
+    }
+    delete []_items;
+    _items = newBuffer;
+    _size = size;
+  }
+
+  /*
+  CObjArray2& operator=(const CObjArray2 &buffer)
+  {
+    Free();
+    size_t newSize = buffer._size;
+    if (newSize != 0)
+    {
+      T *newBuffer = new T[newSize];;
+      _items = newBuffer;
+      _size = newSize;
+      const T *src = buffer;
+      for (size_t i = 0; i < newSize; i++)
+        newBuffer[i] = src[i];
+    }
+    return *this;
+  }
+  */
+};
+
+#endif