#ifndef __pxx_vector_ih__
#define __pxx_vector_ih__

#include "pxx_vector.hh"
#include "pxx_common.ih"
#include "pxx_default_allocator.ih"

#include <new>

namespace pxx
{

template <typename type_t>
Vector<type_t>::Vector (size_t _length /* = 0 */) :
  length (_length)
{
//  PMETHOD;
  size_t n;
  if ((default_allocator.get_features() & ALLOCATOR_HAS_GET_REAL_SIZE) != 0) {
    n = default_allocator.get_real_size(sizeof(type_t) * length);
  } else {
    n = exps_of_two[get_order(sizeof(type_t) * length)];
  }
  data = static_cast<type_t*>(default_allocator.allocate(n));
  capacity = n / sizeof(type_t) ;
  for (size_t i = 0; i < length; i++) {
    new(data + i) type_t();
  }
}

template <typename type_t>
Vector<type_t>::Vector (Vector const& _s) :
  length (_s.length)
{
//  PMETHOD;
  new(this) Vector(_s.length);
  for (size_t i = 0; i < length; i++) {
    data[i] = _s.data[i];
  }
}

template <typename type_t>
Vector<type_t>::~Vector ()
{
//  PMETHOD;
  for (size_t i = 0; i < length; i++) {
//    delete (data + i) (data + i);
    (data + i)->~type_t();
  }
  default_allocator.deallocate(data);
}

template <typename type_t>
Vector<type_t>& Vector<type_t>::operator = (Vector const& _s)
{
  if (this != &_s) {
    this->~Vector();
    new(this) Vector(_s);
  }
  return self;
}

template <typename type_t>
type_t const* Vector<type_t>::get_data () const
{
  return data;
}

template <typename type_t>
void Vector<type_t>::decrease (size_t _extra)
{ 
  size_t i;
  if (_extra > length) {
    for ( i = 0; i < length; i++)
      (data + i)-> ~type_t();
    length = 0;
  } else {
    for ( i = length - _extra; i < length; i++)
      (data + i)-> ~type_t();
    length -= _extra;
  }
}

template <typename type_t>
void Vector<type_t>::expand (size_t _extra)
{
  size_t n;
  if (capacity - length < _extra) {
    if ((default_allocator.get_features() & ALLOCATOR_HAS_GET_REAL_SIZE) != 0) {
      n = default_allocator.get_real_size(sizeof(type_t) * (length + _extra));
    } else {
      n = exps_of_two[get_order(sizeof(type_t) * (length + _extra))];
    }
    data = static_cast<type_t*>(default_allocator.reallocate(data, n));
    capacity = n / sizeof(type_t) ;
  }
  for (size_t i = 0; i < _extra; i++) {
    new(data + length + i) type_t();
  }
  length += _extra;
}

template <typename type_t>
type_t const& Vector<type_t>::operator [] (size_t _index) const
{
  if (_index < length) {
    return data[_index];
  } else {
    throw OutOfRange();
  }
}

template <typename type_t>
type_t& Vector<type_t>::operator [] (size_t _index)
{
  if (_index < length) {
    return data[_index];
  } else {
    throw OutOfRange();
  }
}

template <typename type_t>
size_t Vector<type_t>::get_length () const
{
  return length;
}

template <typename type_t>
size_t Vector<type_t>::get_capacity () const
{
  return capacity;
}

}

#endif // __pxx_vector_ih__