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