#ifndef MAP_HPP
# define MAP_HPP

//# include "colors.h"
//# include <iostream>
//# include <string>
//# include <memory>		// std::allocator
//# include <algorithm>	// std::min, std::max
//# include <stdexcept>	// out_of_range, length_error, logic_error
//# include <cstddef>		// NULL, std::size_t, std::ptrdiff_t
//
//# include "enable_if.hpp"
//# include "is_integral.hpp"
//# include "reverse_iterator.hpp"
//# include "equal.hpp"
//# include "lexicographical_compare.hpp"

namespace ft {

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

public:

//	typedef T										value_type;
//	typedef Allocator								allocator_type;
//	typedef std::size_t								size_type;
//	typedef std::ptrdiff_t							difference_type;
//
//	typedef T *										iterator;
//	typedef T const *								const_iterator;
//	typedef ft::reverse_iterator<iterator>			reverse_iterator;
//	typedef ft::reverse_iterator<const_iterator>	const_reverse_iterator;
//
//	//	dependent qualified name :
//	//	https://en.cppreference.com/w/cpp/keyword/typename
//	typedef typename Allocator::reference			reference;
//	typedef typename Allocator::const_reference		const_reference;



	/************
	 * copliens :
	 ************/
//// constructors ------------------------------
//	explicit map (const key_compare& comp = key_compare(),
//		const allocator_type& alloc = allocator_type());
//	template <class InputIterator>
//		map (InputIterator first, InputIterator last,
//			const key_compare& comp = key_compare(),
//			const allocator_type& alloc = allocator_type());
//	map (const map& x);
//// destructor --------------------------------
//	~map();
//// operator= ---------------------------------
//	map& operator= (const map& x);


	/*************
	 * 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 :
	 ************/
//// empty -------------------------------------
//	bool		empty() const;
//// size --------------------------------------
//	size_type	size() const;
//// max_size ----------------------------------
//	size_type	max_size() const;


	/******************
	 * element access :
	 ******************/
//// operator[] --------------------------------
//	mapped_type &	operator[] (const key_type& k);


	/*************
	 * modifiers :
	 *************/
//// insert ------------------------------------
//	pair<iterator,bool>	insert (const value_type& val);
//	iterator			insert (iterator position, const value_type& val);
//	template <class InputIterator>
//		void			insert (InputIterator first, InputIterator last);
//// erase -------------------------------------
//	void				erase (iterator position);
//	size_type			erase (const key_type& k);
//	void				erase (iterator first, iterator last);
//// swap --------------------------------------
//	void				swap (map& x);
//// clear -------------------------------------
//	void				clear();


	/*************
	 * observers :
	 *************/
//// key_comp ----------------------------------
//	key_compare		key_comp() const;
//// value_comp --------------------------------
//	value_compare	value_comp() const;


	/**************
	 * operations :
	 **************/
//// find --------------------------------------
//	iterator							find (const key_type& k);
//	const_iterator						find (const key_type& k) const;
//// count -------------------------------------
//	size_type							count (const key_type& k) const;
//// lower_bound -------------------------------
//	iterator							lower_bound (const key_type& k);
//	const_iterator						lower_bound (const key_type& k) const;
//// upper_bound -------------------------------
//	iterator							upper_bound (const key_type& k);
//	const_iterator						upper_bound (const key_type& k) const;
//// equal_range -------------------------------
//	pair<const_iterator,const_iterator>	equal_range (const key_type& k) const;
//	pair<iterator,iterator>				equal_range (const key_type& k);


	/*************
	 * allocator :
	 *************/
//// get_allocator -----------------------------
//	allocator_type	get_allocator() const;

private:

//	size_type		_size;
//	size_type		_capacity;
//	value_type *	_mem_ptr;
//	allocator_type	_allocator;
//
//	void			_destroy(iterator first, iterator last);
//	void			_increment_capacity(size_type n);

};

} // namespace ft

# include "map.tpp"

#endif