// Copyright {Jagger Software Limited} 2003

#if !defined CONTAINER_BOUNDED_VECTOR_INCLUDED || \
     defined CONTAINER_BOUNDED_VECTOR_TEMPLATE_INCLUDED
#error      "container/bounded_vector-template.hpp" #included directly
#endif
#define      CONTAINER_BOUNDED_VECTOR_TEMPLATE_INCLUDED

#include "container/construct.hpp"
#include "container/destruct.hpp"
#include <stdexcept>

namespace
{
    size_t positive(int value)
    {
        if (value < 0)
        {
            throw std::logic_error("container::bounded_vector<T>::c'tor(arg1 < zero)");
        }
        return static_cast<size_t>(value);
    }
}

namespace container // bounded_vector - 'tors
{
    using namespace std;

    template<typename element_type>
    bounded_vector<element_type>::bounded_vector(int value)
        : fixed_capacity(positive(value))
        , used_length(0)
        , elements(allocate(fixed_capacity))
    {
    }
   
    template<typename element_type>
    bounded_vector<element_type>::bounded_vector(size_t value)
        : fixed_capacity(value)
        , used_length(0)
        , elements(allocate(fixed_capacity))
    {
    }

    template<typename element_type>
    bounded_vector<element_type>::bounded_vector(const self_type & other)
        : fixed_capacity(other.fixed_capacity)
        , used_length(0)
        , elements(bounded)
    {
        copy(other.begin(), other.end(), back_inserter(*this));
    }

    template<typename element_type>
    bounded_vector<element_type>::~bounded_vector()
    {
        clear();
        deallocate(elements);
    }
}

namespace container // bounded_vector - assignment
{
    template<typename element_type>
    bounded_vector<element_type> & 
    bounded_vector<element_type>::operator=(const self_type & rhs)
    {
        self_type(rhs).swap(*this);

        return *this;
    }
}

namespace container // bounded_vector - capacity
{
    template<typename element_type>
    size_t
    bounded_vector<element_type>::size() const
    {
        return used_length;
    }

    template<typename element_type>
    size_t
    bounded_vector<element_type>::max_size() const
    {
        return capacity();
    }

    template<typename element_type>
    size_t
    bounded_vector<element_type>::capacity() const
    {
        return fixed_capacity;
    }

    template<typename element_type>
    bool 
    bounded_vector<element_type>::empty() const
    {
        return size() == 0;
    }

    template<typename element_type>
    bool 
    bounded_vector<element_type>::full() const
    {
        return size() == capacity();
    }

    template<typename element_type>
    void 
    bounded_vector<element_type>::clear()
    {
        while (!empty())
        {
            pop_back();
        }
    }

    template<typename element_type>
    void 
    bounded_vector<element_type>::swap(self_type & other)
    {
        ::swap(fixed_capacity, other.fixed_capacity);
        ::swap(used_length, other.used_length);
        ::swap(elements, other.elements);
    }
}

namespace container // bounded_vector - iteration
{
    template<typename element_type>
    typename bounded_vector<element_type>::iterator 
    bounded_vector<element_type>::begin()
    {
        return elements;
    }

    template<typename element_type>
    typename bounded_vector<element_type>::iterator 
    bounded_vector<element_type>::end()
    {
        return elements + size();
    }

    template<typename element_type>
    typename bounded_vector<element_type>::const_iterator 
    bounded_vector<element_type>::begin() const
    {
        return elements;
    }

    template<typename element_type>
    typename bounded_vector<element_type>::const_iterator 
    bounded_vector<element_type>::end() const
    {
        return elements + size();
    }
}

namespace container // bounded_vector - reverse iteration
{
    template<typename element_type>
    typename bounded_vector<element_type>::reverse_iterator 
    bounded_vector<element_type>::rbegin()
    {
        return reverse_iterator(end());
    }

    template<typename element_type>
    typename bounded_vector<element_type>::reverse_iterator 
    bounded_vector<element_type>::rend()
    {
        return reverse_iterator(begin());
    }

    template<typename element_type>
    typename bounded_vector<element_type>::const_reverse_iterator 
    bounded_vector<element_type>::rbegin() const
    {
        return const_reverse_iterator(end());
    }

    template<typename element_type>
    typename bounded_vector<element_type>::const_reverse_iterator 
    bounded_vector<element_type>::rend() const
    {
        return const_reverse_iterator(begin());
    }
}
        
namespace container // bounded_vector - end element access
{
    template<typename element_type>
    element_type & 
    bounded_vector<element_type>::front()
    {
        check_not_empty();
        return *begin();
    }

    template<typename element_type>
    element_type & 
    bounded_vector<element_type>::back()
    {
        check_not_empty();
        return *(end() - 1);
    }

    template<typename element_type>
    const element_type & 
    bounded_vector<element_type>::front() const
    {
        check_not_empty();
        return *begin();
    }

    template<typename element_type>
    const element_type & 
    bounded_vector<element_type>::back() const
    {
        check_not_empty();
        return *(end() - 1);
    }

    template<typename element_type>
    void 
    bounded_vector<element_type>::push_back(const element_type & pushed)
    {
        check_not_full();
        construct(&elements[used_length], pushed);
        ++used_length;
    }

    template<typename element_type>
    void 
    bounded_vector<element_type>::pop_back()
    {
        check_not_empty();
        --used_length;
        destruct(&elements[used_length]);
    }
}

namespace container // bounded_vector - subscripting
{
    template<typename element_type>
    element_type & 
    bounded_vector<element_type>::operator[](size_t at)
    {
        range_check(at);
        return elements[at];
    }

    template<typename element_type>
    const element_type & 
    bounded_vector<element_type>::operator[](size_t at) const
    {
        range_check(at);
        return elements[at];
    }
}

namespace container // bounded_vector - validation
{
    template<typename element_type>
    void
    bounded_vector<element_type>::check_not_empty() const
    {
        if (empty())
        {
            throw std::logic_error("container::bounded_vector<T>::empty()");
        }
    }
    
    template<typename element_type>
    void
    bounded_vector<element_type>::check_not_full() const
    {
        if (full())
        {
            throw std::logic_error("container::bounded_vector<T>::full()");
        }
    }

    template<typename element_type>
    void
    bounded_vector<element_type>::range_check(size_t at) const
    {
        if (at >= size())
        {
            throw std::out_of_range("container::bounded_vector<T>[at]");
        }
    }
}

namespace container // bounded_vector - implementation
{
    template<typename element_type>
    element_type *
    bounded_vector<element_type>::allocate(size_t amount)
    {
        void * const block = ::operator new(amount * sizeof(element_type));
        return static_cast<element_type *>(block);
    }

    template<typename element_type>
    void
    bounded_vector<element_type>::deallocate(element_type * ptr)
    {
        void * const block = static_cast<void *>(ptr);
        ::operator delete(block);
    }
}