/* vim: set ts=4 sw=4 tw=99 et:

  *

  * Copyright (C) 2012 David Anderson

  *

  * This file is part of SourcePawn.

  *

  * SourcePawn is free software: you can redistribute it and/or modify it under

  * the terms of the GNU General Public License as published by the Free

  * Software Foundation, either version 3 of the License, or (at your option)

  * any later version.

  * 

  * SourcePawn is distributed in the hope that it will be useful, but WITHOUT ANY

  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS

  * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

  *

  * You should have received a copy of the GNU General Public License along with

  * SourcePawn. If not, see http://www.gnu.org/licenses/.

  */

 #ifndef _INCLUDE_KEIMA_TPL_CPP_VECTOR_H_

 #define _INCLUDE_KEIMA_TPL_CPP_VECTOR_H_

 #include <new>

 #include <stdlib.h>

 #include "AllocatorPolicies.h"

 #include "Utility.h"

 namespace ke {

 template <typename T, typename AllocPolicy = ZoneAllocatorPolicy>

 class Vector : public AllocPolicy

 {

   public:

     Vector(AllocPolicy = AllocPolicy())

       : data(NULL),

         nitems(0),

         maxsize(0)

     { }

     ~Vector() {

         for (size_t i = 0; i < nitems; i++)

             data[i].~T();

         this->free(data);

     }

     bool append(const T& item) {

         if (!GrowIfNeeded(1))

             return false;

         new (&data[nitems]) T(item);

         nitems++;

         return true;

     }

     void infallibleAppend(const T &item) {

         assert(GrowIfNeeded(1));

         new (&data[nitems]) T(item);

         nitems++;

     }

     T popCopy() {

         T t = at(length() - 1);

         pop();

         return t;

     }

     void pop() {

         assert(nitems);

         data[nitems - 1].~T();

         nitems--;

     }

     bool empty() const {

         return length() == 0;

     }

     size_t length() const {

         return nitems;

     }

     T& at(size_t i) {

         assert(i < length());

         return data[i];

     }

     const T& at(size_t i) const {

         assert(i < length());

         return data[i];

     }

     T& operator [](size_t i) {

         return at(i);

     }

     const T& operator [](size_t i) const {

         return at(i);

     }

     void clear() {

         nitems = 0;

     }

     T *buffer() const {

         return data;

     }

     bool ensure(size_t desired) {

         if (desired <= length())

             return true;

         return GrowIfNeeded(desired - length());

     }

   private:

     bool GrowIfNeeded(size_t needed)

     {

         if (!IsUintPtrAddSafe(nitems, needed)) {

             this->reportAllocationOverflow();

             return false;

         }

         if (maxsize == 0)

             maxsize = 8;

         while (nitems + needed > maxsize) {

             if (!IsUintPtrMultiplySafe(maxsize, 2)) {

                 this->reportAllocationOverflow();

                 return false;

             }

             maxsize *= 2;

         }

         T* newdata = (T*)this->malloc(sizeof(T) * maxsize);

         if (newdata == NULL)

             return false;

         for (size_t i = 0; i < nitems; i++) {

             new (&newdata[i]) T(data[i]);

             data[i].~T();

         }

         this->free(data);

         data = newdata;

         return true;

     }

   private:

     T* data;

     size_t nitems;

     size_t maxsize;

 };

 }

 #endif /* _INCLUDE_KEIMA_TPL_CPP_VECTOR_H_ */