#pragma once
#include "allocator.h"
#include <algorithm>
namespace stingray_plugin_foundation {
struct NoAllocator;
// An Array<> is a simplified Vector<> for POD types that does not call
// constructors or destructors for its elements (it doesn't even zero the
// memory). It also assumes that the members can be moved and copied with
// a memmove operation and compared with memcmp.
template <class T>
class Array
{
public:
    // Type definitions
    typedef Array<T>        this_type;
    typedef T               value_type;
    typedef T*              pointer;
    typedef const T*        const_pointer;
    typedef T&              reference;
    typedef const T&        const_reference;
    typedef pointer         iterator;
    typedef const_pointer   const_iterator;
    // Constructors
    // Creates an array that uses the specified allocator to allocate  memory.
    Array(Allocator &allocator);
    // Creates an array and presizes it to the specified size.
    Array(unsigned size, Allocator &allocator);
    // Creates an array without an allocator, one must be provided later with
    // set_allocator() before the array is resized.
    Array(const NoAllocator &);
    // Sets the allocator of the array. You can only call this before any
    // allocations have been made by the array.
    void set_allocator(Allocator &allocator);
    Array( const Array<T> &o );
    ~Array() {reset();}
    // Asignment operator -- note that we do not support chained assignments.
    void operator=(const Array<T> &o);
    // std::vector interface
    iterator begin() {return _data;}
    const_iterator begin() const {return _data;}
    iterator end() {return _data + _size;}
    const_iterator end() const {return _data + _size;}
    unsigned size() const {return _size;}
    unsigned capacity() const {return _capacity;}
    bool any() const {return _size != 0;}
    bool empty() const {return _size == 0;}
    reference operator[](unsigned i);
    const_reference operator[](unsigned i) const;
    void reserve(unsigned capacity);
    reference front() {return _data[0];}
    const_reference front() const {return _data[0];}
    reference back() {return _data[_size-1];}
    const_reference back() const {return _data[_size-1];}
    template <class ASSIGNABLE> void push_back(const ASSIGNABLE &item);
    void pop_back();
    void swap(Array<T> &o);
    template <class ASSIGNABLE> iterator insert(iterator pos, const ASSIGNABLE & x);
    iterator insert(iterator pos);
    void insert(iterator pos, const_iterator from, const_iterator to);
    iterator erase(iterator pos);
    iterator erase(iterator first, iterator last);
    void clear() {resize(0);}
    void resize(unsigned size);
    // Serializes the array to the stream.
    template <class STREAM> void serialize(STREAM &stream);
    bool operator==(const Array<T> &o) const;
    bool operator<(const Array<T> &o) const;
    // Array extensions
    // Resets the array to initial state (no memory allocated).
    void reset() {set_capacity(0);}
    // Extends the array with the specified number of elements and returns a pointer to the first new element.
    pointer extend(unsigned elements) { resize(size() + elements); return _data + _size - elements; }
    // Extends the array with one elements and returns a reference to the newly created element.
    reference extend() { resize(size() + 1); return back(); }
    // Returns the allocator of the array.
    Allocator &allocator() const {return *_allocator;}
    // Sets the capacity of the array to exactly the specified ammount.
    // This operation always reallocates the memory of the array, no
    // swap trick is necessary to enforce reallocation.
    void set_capacity(unsigned capacity);
    // Trims the array so that the capacity corresponds to its current size.
    void trim() {set_capacity(size());}
    // Finds the first occurrence of x in the array and returns it.
    template <typename EQUATABLE> iterator find(const EQUATABLE &x) {return std::find(begin(), end(), x);}
    // Finds the first occurrence of x in the array and returns it.
    template <typename EQUATABLE> const_iterator find(const EQUATABLE &x) const {return std::find(begin(), end(), x);}
    // Returns the index of x in the array (or size() if it is not in the array).
    template <typename EQUATABLE> unsigned index_of(const EQUATABLE &x) const {return (unsigned)(find(x) - begin());}
    // Returns if x is in the array
    template <typename EQUATABLE> bool has(const EQUATABLE &x) const {return (find(x) != end());}
    // Erases the first occurrence of x in the array.
    template <typename EQUATABLE> void erase(const EQUATABLE &item);
    // "Steals" the data buffer from the array. The array will be empty after this operation. The "stealer" is
    // responsible for deallocating the stolen buffer.
    pointer steal();
private:
    void move(pointer to, pointer from, unsigned n);
    void copy(pointer to, const_pointer from, unsigned n);
    void grow(unsigned min_capacity = 0);
private:
    unsigned        _size;
    unsigned        _capacity;
    pointer         _data;
    Allocator *     _allocator;
};
} // namespace stingray_plugin_foundation
#include "array.inl"
array.h - Engine C API Reference
