/* 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_sp2_list_h_

 #define _include_sp2_list_h_

 #include "Objects.h"

 #include "FixedArray.h"

 #include "Zone.h"

 #include "Heap-inl.h"

 #include "Handles-inl.h"

 namespace ke {

 template <typename T>

 class List : public Object

 {

   public:

     static List *New(Zone *zone, Heap::Tenure tenure = Heap::Tenure_Default) {

         Local<List> list(zone, List::cast(zone->allocate(MapKind_List, sizeof(List), tenure)));

         if (!list)

             return NULL;

         list->length_ = 0;

         list->array_ = NULL;

         return list;

     }

     bool append(Zone *zone, Handle<T> obj) {

         Local<List> list(zone, this);

         if (!Grow(zone, list, 1))

             return false;

         list->array_->set(zone, list->length_, obj);

         list->length_++;

         return true;

     }

     T *at(unsigned i) {

         return T::cast(array_->at(i));

     }

     unsigned length() {

         return length_;

     }

   private:

     static bool Grow(Zone *zone, Handle<List> list, unsigned amount) {

         if (!IsUint32AddSafe(list->length(), amount)) {

             zone->reportAllocationOverflow();

             return false;

         }

         unsigned newlen = list->length() + amount;

         if (list->array_ && newlen < list->array_->length())

             return true;

         unsigned maxsize = list->array_ ? list->array_->length() : 8;

         if (!IsUint32AddSafe(maxsize, amount)) {

             zone->reportAllocationOverflow();

             return false;

         }

         while (newlen > maxsize) {

             if (!IsUint32MultiplySafe(maxsize, 2)) {

                 zone->reportAllocationOverflow();

                 return false;

             }

             maxsize *= 2;

         }

         Local<FixedArray> array(zone, FixedArray::New(zone, maxsize, Heap::Tenure_Default));

         if (!array)

             return false;

         for (unsigned i = 0; i < list->length_; i++)

             array->set(zone, i, list->array_->at(i));

         list->array_ = array;

         return true;

     }

   public:

     // Begin GC descriptor.

     static inline size_t offsetOfArray() {

         return OFFSETOF(List, array_);

     }

     // End GC descriptor.

     static inline List *cast(Object *obj) {

         assert(!obj || obj->is(MapKind_List));

         return reinterpret_cast<List *>(obj);

     }

   private:

     unsigned length_;

     FixedArray *array_;

 };

 } // namespace ke

 #endif // _include_sp2_list_h_