//#include "vector.hpp"

#define COPLIEN_COLOR B_CYAN

namespace ft {

/*********************************************
 * CONSTRUCTORS
 *********************************************/

template <class T, class Allocator>
vector<T, Allocator>::vector()
: _size(0)
, _capacity(0)
, _mem_ptr(NULL)
{
//	std::cout << COPLIEN_COLOR "vector constructor" RESET "\n";
	_allocator = allocator_type();
	return;
}

template <class T, class Allocator>
vector<T, Allocator>::vector( vector const & src ) {
//	std::cout << COPLIEN_COLOR "vector copy constructor" RESET "\n";
	*this = src;
	return;
}

/*********************************************
 * DESTRUCTORS
 *********************************************/

template <class T, class Allocator>
vector<T, Allocator>::~vector() {
//	std::cout << COPLIEN_COLOR "vector destructor" RESET "\n";
	return;
}

/*********************************************
 * OPERATORS
 *********************************************/

template <class T, class Allocator>
vector<T, Allocator> &	vector<T, Allocator>::operator=( vector const & rhs ) {
//	Base::operator=(rhs);
	if ( this != &rhs )
	{
		_size = rhs.size();
	}
	return *this;
}

//std::ostream &	operator<<(std::ostream & o, vector const & rhs)
//{
//	o << rhs.getFoo();
//	return (o);
//}


/*********************************************
 * PUBLIC MEMBER FUNCTIONS
 *********************************************/

	/*************
	 * iterators :
	 *************/
// begin -------------------------------------
template <class T, class Allocator>
typename vector<T, Allocator>::iterator	vector<T, Allocator>::begin() {return _mem_ptr;}
// end ---------------------------------------
template <class T, class Allocator>
typename vector<T, Allocator>::iterator	vector<T, Allocator>::end() {return &_mem_ptr[_size];}
// rbegin ------------------------------------
// rend --------------------------------------

	/************
	 * capacity :
	 ************/
// size --------------------------------------
template <class T, class Allocator>
typename vector<T, Allocator>::size_type	vector<T, Allocator>::size() const {return _size;}
// max_size ----------------------------------
// resize ------------------------------------
// capacity ----------------------------------
// empty -------------------------------------
// reserve -----------------------------------
template <class T, class Allocator>
void	vector<T, Allocator>::reserve(size_type new_cap) {
	value_type *	tmp_ptr;
	iterator		first = begin();
	iterator		last = end();

	if (new_cap > _allocator.max_size())
		throw std::length_error("new_cap > max_size");
	if (_capacity == _allocator.max_size())
		throw std::length_error("capacity == max_size");
	if (new_cap <= _capacity)
		return ;

	_capacity = new_cap;
	tmp_ptr = _allocator.allocate(new_cap);

	if (_mem_ptr)
	{
		// TMP replacing assign()
		for (size_type i = 0; i < _size; i++)
			tmp_ptr[i] = _mem_ptr[i];
		// TMP END
		_destroy(first, last);
		_allocator.deallocate(_mem_ptr, _capacity);
	}
	_mem_ptr = tmp_ptr;
}

	/******************
	 * element access :
	 ******************/
// operator[] --------------------------------
template <class T, class Allocator>
typename vector<T, Allocator>::reference	vector<T, Allocator>::operator[](size_type n) {return _mem_ptr[n];}
// at ----------------------------------------
// front -------------------------------------
// back --------------------------------------

	/*************
	 * modifiers :
	 *************/
// assign ------------------------------------
// push_back ---------------------------------
template <class T, class Allocator>
void	vector<T, Allocator>::push_back(const value_type & element) {
	if (_size >= _capacity)
		reserve(std::min(_size + 1, _allocator.max_size() / 2) * 2);
	_allocator.construct(&_mem_ptr[_size], element);
	_size++;
}
// pop_back ----------------------------------
// insert ------------------------------------
// erase -------------------------------------
// swap --------------------------------------
// clear -------------------------------------




/*********************************************
 * PRIVATE MEMBER FUNCTIONS
 *********************************************/

template <class T, class Allocator>
void	vector<T, Allocator>::_destroy(iterator first, iterator last) {
	while (first != last)
	{
		_allocator.destroy(first);
		first++;
	}
}

/*********************************************
 * NESTED CLASS
 *********************************************/

//void	vector::Class::function() {}

/*********************************************
 * STATICS
 *********************************************/

//std::string const	vector::_bar = "bar";

}