Initial community commit

Src/external_dependencies/openmpt-trunk/include/unrar/array.hpp

@@ -0,0 +1,191 @@
+#ifndef _RAR_ARRAY_
+#define _RAR_ARRAY_
+
+extern ErrorHandler ErrHandler;
+
+template <class T> class Array
+{
+  private:
+    T *Buffer;
+    size_t BufSize;
+    size_t AllocSize;
+    size_t MaxSize;
+    bool Secure; // Clean memory if true.
+  public:
+    Array();
+    Array(size_t Size);
+    Array(const Array &Src); // Copy constructor.
+    ~Array();
+    inline void CleanData();
+    inline T& operator [](size_t Item) const;
+    inline T* operator + (size_t Pos);
+    inline size_t Size(); // Returns the size in items, not in bytes.
+    void Add(size_t Items);
+    void Alloc(size_t Items);
+    void Reset();
+    void SoftReset();
+    void operator = (Array<T> &Src);
+    void Push(T Item);
+    void Append(T *Item,size_t Count);
+    T* Addr(size_t Item) {return Buffer+Item;}
+    void SetMaxSize(size_t Size) {MaxSize=Size;}
+    T* Begin() {return Buffer;}
+    T* End() {return Buffer==NULL ? NULL:Buffer+BufSize;}
+    void SetSecure() {Secure=true;}
+};
+
+
+template <class T> void Array<T>::CleanData()
+{
+  Buffer=NULL;
+  BufSize=0;
+  AllocSize=0;
+  MaxSize=0;
+  Secure=false;
+}
+
+
+template <class T> Array<T>::Array()
+{
+  CleanData();
+}
+
+
+template <class T> Array<T>::Array(size_t Size)
+{
+  CleanData();
+  Add(Size);
+}
+
+
+// Copy constructor in case we need to pass an object as value.
+template <class T> Array<T>::Array(const Array &Src)
+{
+  CleanData();
+  Alloc(Src.BufSize);
+  if (Src.BufSize!=0)
+    memcpy((void *)Buffer,(void *)Src.Buffer,Src.BufSize*sizeof(T));
+}
+
+
+template <class T> Array<T>::~Array()
+{
+  if (Buffer!=NULL)
+  {
+    if (Secure)
+      cleandata(Buffer,AllocSize*sizeof(T));
+    free(Buffer);
+  }
+}
+
+
+template <class T> inline T& Array<T>::operator [](size_t Item) const
+{
+  return Buffer[Item];
+}
+
+
+template <class T> inline T* Array<T>::operator +(size_t Pos)
+{
+  return Buffer+Pos;
+}
+
+
+template <class T> inline size_t Array<T>::Size()
+{
+  return BufSize;
+}
+
+
+template <class T> void Array<T>::Add(size_t Items)
+{
+  BufSize+=Items;
+  if (BufSize>AllocSize)
+  {
+    if (MaxSize!=0 && BufSize>MaxSize)
+    {
+      ErrHandler.GeneralErrMsg(L"Maximum allowed array size (%u) is exceeded",MaxSize);
+      ErrHandler.MemoryError();
+    }
+
+    size_t Suggested=AllocSize+AllocSize/4+32;
+    size_t NewSize=Max(BufSize,Suggested);
+
+    T *NewBuffer;
+    if (Secure)
+    {
+      NewBuffer=(T *)malloc(NewSize*sizeof(T));
+      if (NewBuffer==NULL)
+        ErrHandler.MemoryError();
+      if (Buffer!=NULL)
+      {
+        memcpy(NewBuffer,Buffer,AllocSize*sizeof(T));
+        cleandata(Buffer,AllocSize*sizeof(T));
+        free(Buffer);
+      }
+    }
+    else
+    {
+      NewBuffer=(T *)realloc(Buffer,NewSize*sizeof(T));
+      if (NewBuffer==NULL)
+        ErrHandler.MemoryError();
+    }
+    Buffer=NewBuffer;
+    AllocSize=NewSize;
+  }
+}
+
+
+template <class T> void Array<T>::Alloc(size_t Items)
+{
+  if (Items>AllocSize)
+    Add(Items-BufSize);
+  else
+    BufSize=Items;
+}
+
+
+template <class T> void Array<T>::Reset()
+{
+  if (Buffer!=NULL)
+  {
+    free(Buffer);
+    Buffer=NULL;
+  }
+  BufSize=0;
+  AllocSize=0;
+}
+
+
+// Reset buffer size, but preserve already allocated memory if any,
+// so we can reuse it without wasting time to allocation.
+template <class T> void Array<T>::SoftReset()
+{
+  BufSize=0;
+}
+
+
+template <class T> void Array<T>::operator =(Array<T> &Src)
+{
+  Reset();
+  Alloc(Src.BufSize);
+  if (Src.BufSize!=0)
+    memcpy((void *)Buffer,(void *)Src.Buffer,Src.BufSize*sizeof(T));
+}
+
+
+template <class T> void Array<T>::Push(T Item)
+{
+  Add(1);
+  (*this)[Size()-1]=Item;
+}
+
+
+template <class T> void Array<T>::Append(T *Items,size_t Count)
+{
+  size_t CurSize=Size();
+  Add(Count);
+  memcpy(Buffer+CurSize,Items,Count*sizeof(T));
+}
+
+#endif