#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