#ifndef VECTOR_HPP
# define VECTOR_HPP

# include "colors.h"
# include <iostream>
# include <string>
# include <memory>		// std::allocator
# include <algorithm>	// std::min
# include "enable_if.hpp"
# include "is_integral.hpp"

namespace ft {

template <
	class T,
	class Allocator = std::allocator<T>
> class vector {

public:

	typedef T									value_type;
	typedef Allocator							allocator_type;
	typedef std::size_t							size_type;

	typedef T *									iterator;

	typedef typename allocator_type::reference	reference;


	/************
	 * copliens :
	 ************/
// constructor -------------------------------
	explicit vector (const allocator_type & alloc = allocator_type());
	explicit vector (size_type n, const value_type& val = value_type(),
			const allocator_type& alloc = allocator_type());
	template <class InputIterator>
		vector (InputIterator first, InputIterator last,
			const allocator_type& alloc = allocator_type());
	vector( vector const & src );
// destructor --------------------------------
	~vector();
// operator= ---------------------------------
	vector &	operator=( vector const & rhs );


	/*************
	 * iterators :
	 *************/
// begin -------------------------------------
	iterator				begin();
	//const_iterator			begin() const;
// end ---------------------------------------
	iterator				end();
	//const_iterator			end() const;
// rbegin ------------------------------------
	//reverse_iterator		rbegin();
	//const_reverse_iterator	rbegin() const;
// rend --------------------------------------
	//reverse_iterator		rend();
	//const_reverse_iterator	rend() const;

	/************
	 * capacity :
	 ************/
// size --------------------------------------
	size_type	size() const;
// max_size ----------------------------------
	//size_type	max_size() const;
// resize ------------------------------------
	//void		resize(size_type n, value_type val = value_type());
// capacity ----------------------------------
	size_type	capacity() const;
// empty -------------------------------------
	//bool		empty() const;
// reserve -----------------------------------
	void		reserve(size_type n);

	/******************
	 * element access :
	 ******************/
// operator[] --------------------------------
	reference		operator[](size_type n);
	//const_reference	operator[](size_type n) const;
// at ----------------------------------------
	//reference		at(size_type n);
	//const_reference	at(size_type n) const;
// front -------------------------------------
	//reference		front();
	//const_reference	front() const;
// back --------------------------------------
	//reference		back();
	//const_reference	back() const;

	/*************
	 * modifiers :
	 *************/
// assign ------------------------------------
	template <class InputIterator>
		typename enable_if< !is_integral<InputIterator>::value,void >::type
		assign(InputIterator first, InputIterator last);
	//	template <class InputIterator>
	//		void	assign(InputIterator first, InputIterator last
	//		typename enable_if< !is_integral<InputIterator>::value, bool >::type == true);
//	template <class InputIterator>
//		typename enable_if< is_integral<InputIterator>::value,void >::type
//		assign(size_type n, const value_type& val);
	void		assign(size_type n, const value_type& val);
// push_back ---------------------------------
	void		push_back(const value_type & val);
// pop_back ----------------------------------
	//void		pop_back();
// insert ------------------------------------
	//iterator	insert(iterator position, const value_type& val);
	//void		insert(iterator position, size_type n, const value_type& val);
	//template <class InputIterator>
	//	void	insert(iterator position, InputIterator first, InputIterator last);
// erase -------------------------------------
	//iterator	erase(iterator position);
	//iterator	erase(iterator first, iterator last);
// swap --------------------------------------
	//void		swap(vector& x);
// clear -------------------------------------
	void		clear();


private:

	size_type		_size;
	size_type		_capacity;
	value_type *	_mem_ptr;
	allocator_type	_allocator;

	void			_destroy(iterator first, iterator last);

};

//std::ostream &	operator<<(std::ostream & o, vector const & rhs);

} // namespace ft

# include "vector.tpp"

#endif