map filled luky style

headers/map.hpp

@@ -36,137 +36,138 @@ public:
 
 	typedef Bst<Key,T,Compare,Alloc>					bst_map;
 
-//	typedef typename bst_map::iterator					iterator;
-//	typedef typename bst_map::const_iterator			const_iterator;
-//	typedef typename bst_map::reverse_iterator			reverse_iterator;
-//	typedef typename bst_map::const_reverse_iterator	const_reverse_iterator;
+	typedef typename bst_map::iterator					iterator;
+	typedef typename bst_map::const_iterator			const_iterator;
+	typedef typename bst_map::reverse_iterator			reverse_iterator;
+	typedef typename bst_map::const_reverse_iterator	const_reverse_iterator;
 
 
 	/****************
 	 * member class :
 	 ****************/
-//	// https://en.cppreference.com/w/cpp/container/map/value_compare
-//	class value_compare : public std::binary_function<value_type, value_type, bool>
-//	{
-//		friend class map;
-//		protected:
-//			Compare comp;
-//			value_compare(Compare c) : comp(c) {}
-//		public:
-//			bool operator() (const value_type& x, const value_type& y) const
-//				{ return comp(x.first, y.first); }
-//	};
+	// https://en.cppreference.com/w/cpp/container/map/value_compare
+	// https://stackoverflow.com/questions/4571355/why-would-one-use-nested-classes-in-c
+	class value_compare : public std::binary_function<value_type, value_type, bool> {
+
+		friend class map;
+		protected:
+			Compare comp;
+			value_compare(Compare c) : comp(c) {}
+		public:
+			bool operator() (const value_type& x, const value_type& y) const
+				{ return comp(x.first, y.first); }
+	};
 
 
 	/************
 	 * copliens :
 	 ************/
-//// constructors ------------------------------
+// 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);
+	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;
+// 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;
+// empty -------------------------------------
+	bool		empty() const;
+// size --------------------------------------
+	size_type	size() const;
+// max_size ----------------------------------
+	size_type	max_size() const;
 
 
 	/******************
 	 * element access :
 	 ******************/
-//// operator[] --------------------------------
+// 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();
+// 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;
+// 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);
+// 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;
+// get_allocator -----------------------------
+	allocator_type	get_allocator() const;
 
 private:
 
+	bst_map			_bst;
 	allocator_type	_allocator;
 	key_compare		_comp;
-	bst_map			_bst;
 
 };
 
@@ -174,27 +175,27 @@ private:
 	/************************
 	 * non-member functions :
 	 ************************/
-//// operator == -------------------------------
-//template< class K, class T, class Comp, class Alloc > bool operator==
-//	( const std::map<K,T,Comp,Alloc>& lhs, const std::map<K,T,Comp,Alloc>& rhs );
-//// operator != -------------------------------
-//template< class K, class T, class Comp, class Alloc > bool operator!=
-//	( const std::map<K,T,Comp,Alloc>& lhs, const std::map<K,T,Comp,Alloc>& rhs );
-//// operator < --------------------------------
-//template< class K, class T, class Comp, class Alloc > bool operator<
-//	( const std::map<K,T,Comp,Alloc>& lhs, const std::map<K,T,Comp,Alloc>& rhs );
-//// operator <= -------------------------------
-//template< class K, class T, class Comp, class Alloc > bool operator<=
-//	( const std::map<K,T,Comp,Alloc>& lhs, const std::map<K,T,Comp,Alloc>& rhs );
-//// operator > --------------------------------
-//template< class K, class T, class Comp, class Alloc > bool operator>
-//	( const std::map<K,T,Comp,Alloc>& lhs, const std::map<K,T,Comp,Alloc>& rhs );
-//// operator >= -------------------------------
-//template< class K, class T, class Comp, class Alloc > bool operator>=
-//	( const std::map<K,T,Comp,Alloc>& lhs, const std::map<K,T,Comp,Alloc>& rhs );
-//// swap (map) -----------------------------
-//template< class Key, class T, class Compare, class Alloc > void swap
-//	( std::map<Key,T,Compare,Alloc>& lhs, std::map<Key,T,Compare,Alloc>& rhs );
+// operator == -------------------------------
+template< class K, class T, class Comp, class Alloc > bool operator==
+	( const std::map<K,T,Comp,Alloc>& lhs, const std::map<K,T,Comp,Alloc>& rhs );
+// operator != -------------------------------
+template< class K, class T, class Comp, class Alloc > bool operator!=
+	( const std::map<K,T,Comp,Alloc>& lhs, const std::map<K,T,Comp,Alloc>& rhs );
+// operator < --------------------------------
+template< class K, class T, class Comp, class Alloc > bool operator<
+	( const std::map<K,T,Comp,Alloc>& lhs, const std::map<K,T,Comp,Alloc>& rhs );
+// operator <= -------------------------------
+template< class K, class T, class Comp, class Alloc > bool operator<=
+	( const std::map<K,T,Comp,Alloc>& lhs, const std::map<K,T,Comp,Alloc>& rhs );
+// operator > --------------------------------
+template< class K, class T, class Comp, class Alloc > bool operator>
+	( const std::map<K,T,Comp,Alloc>& lhs, const std::map<K,T,Comp,Alloc>& rhs );
+// operator >= -------------------------------
+template< class K, class T, class Comp, class Alloc > bool operator>=
+	( const std::map<K,T,Comp,Alloc>& lhs, const std::map<K,T,Comp,Alloc>& rhs );
+// swap (map) -----------------------------
+template< class Key, class T, class Compare, class Alloc > void swap
+	( std::map<Key,T,Compare,Alloc>& lhs, std::map<Key,T,Compare,Alloc>& rhs );
 
 
 } // namespace ft

templates/map.tpp

@@ -10,141 +10,253 @@ namespace ft {
 	/************
 	 * copliens :
 	 ************/
-//// constructors ------------------------------
+// constructors ------------------------------
 MP_TPL MP::
 	map (const key_compare & comp, const allocator_type & alloc)
-	: _allocator(alloc)
+	: _bst()
+	, _allocator(alloc)
 	, _comp(comp) {
 
 	return;
 }
-//	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);
+MP_TPL template <class InputIt> MP::
+	map (InputIt first, InputIt last, const key_compare& comp, const allocator_type& alloc)
+	: _bst(first, last)
+	, _allocator(alloc)
+	, _comp(comp) {
+}
+MP_TPL MP::
+	map (const map& x)
+	: _bst()
+	, _allocator(x._allocator)
+	, _comp(x._comp) {
+
+	*this = x;
+}
+// destructor --------------------------------
+MP_TPL MP::
+	~map() { clear(); }
+// operator= ---------------------------------
+MP_TPL MP& MP::
+	operator= (const map& x) {
+
+	if (this == &x)
+		return (*this);
+
+	map	new_map(x.begin(), x.end());
+	swap(new_map);
+	return (*this);
+}
 
 
 	/*************
 	 * 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;
+// begin -------------------------------------
+MP_TPL typename MP::iterator MP::
+	begin() { return (_bst.begin()); }
+MP_TPL typename MP::const_iterator MP::
+	begin() const { return (_bst.begin()); }
+// end ---------------------------------------
+MP_TPL typename MP::iterator MP::
+	end() { return (_bst.end()); }
+MP_TPL typename MP::const_iterator MP::
+	end() const { return (_bst.end()); }
+// rbegin ------------------------------------
+MP_TPL typename MP::reverse_iterator MP::
+	rbegin() { return (_bst.rbegin()); }
+MP_TPL typename MP::const_reverse_iterator MP::
+	rbegin() const { return (_bst.rbegin()); }
+// rend --------------------------------------
+MP_TPL typename MP::reverse_iterator MP::
+	rend() { return (_bst.rend()); }
+MP_TPL typename MP::const_reverse_iterator MP::
+	rend() const { return (_bst.rend()); }
 
 
 	/************
 	 * capacity :
 	 ************/
-//// empty -------------------------------------
-//	bool		empty() const;
-//// size --------------------------------------
-//	size_type	size() const;
-//// max_size ----------------------------------
-//	size_type	max_size() const;
+// empty -------------------------------------
+MP_TPL bool MP::
+	empty() const { return (_bst.empty()); }
+// size --------------------------------------
+MP_TPL typename MP::size_type MP::
+	size() const { return (_bst.size()); }
+// max_size ----------------------------------
+MP_TPL typename MP::size_type MP::
+	max_size() const { return (_bst.max_size()); }
 
 
 	/******************
 	 * element access :
 	 ******************/
-//// operator[] --------------------------------
+// operator[] --------------------------------
 MP_TPL typename MP::mapped_type& MP::
-	operator[] (const key_type& k) {
-
-	return _bst[k];
-}
+	operator[] (const key_type& k) { return _bst[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();
+// insert ------------------------------------
+MP_TPL pair<typename MP::iterator, bool> MP::
+	insert (const value_type& val) { return (_bst.insert(val)); }
+MP_TPL typename MP::iterator MP::
+	insert (iterator pos, const value_type& val) { return (_bst.insert(pos, val)); }
+MP_TPL template <class InputIt> void MP::
+		insert (InputIt first, InputIt last) { return (_bst.insert(first, last)); }
+// erase -------------------------------------
+MP_TPL void MP::
+	erase (iterator pos) { return (_bst.erase(pos)); }
+MP_TPL typename MP::size_type MP::
+	erase (const key_type& k) { return (_bst.erase(k)); }
+MP_TPL void MP::
+	erase (iterator first, iterator last) { return (_bst.erase(first, last)); }
+// swap --------------------------------------
+MP_TPL void MP::
+	swap (map& x) {
+
+	bst_map      tmp;
+
+	tmp.swap(_bst);
+	_bst.swap(x._bst);
+	x._bst.swap(tmp);
+}
+
+// clear -------------------------------------
+MP_TPL void MP::
+	clear() {
+
+	_bst.clear();
+}
 
 
 	/*************
 	 * observers :
 	 *************/
-//// key_comp ----------------------------------
-//	key_compare		key_comp() const;
-//// value_comp --------------------------------
-//	value_compare	value_comp() const;
+// key_comp ----------------------------------
+MP_TPL typename MP::key_compare MP::
+	key_comp() const { return (value_compare(_comp).comp); }
+// value_comp --------------------------------
+MP_TPL typename MP::value_compare MP::
+	value_comp() const { return (value_compare(_comp)); }
 
 
 	/**************
 	 * 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);
+// find --------------------------------------
+MP_TPL typename MP::iterator MP::
+	find (const key_type& k) { return (_bst.find(k)); }
+MP_TPL typename MP::const_iterator MP::
+	find (const key_type& k) const { return (_bst.find(k)); }
+// count -------------------------------------
+MP_TPL typename MP::size_type MP::
+	count (const key_type& k) const { return (_bst.count(k)); }
+// lower_bound -------------------------------
+MP_TPL typename MP::iterator MP::
+	lower_bound (const key_type& k) {
+
+	iterator	it = begin();
+	iterator	it_end = end();
+
+	while (it != it_end)
+	{
+		if (_comp(it->first, k) == false)
+			return (it);
+		++it;
+	}
+	return (it_end);
+}
+MP_TPL typename MP::const_iterator MP::
+	lower_bound (const key_type& k) const {
+
+	const_iterator	it = begin();
+	const_iterator	it_end = end();
+
+	while (it != it_end)
+	{
+		if (_comp(it->first, k) == false)
+			return (it);
+		++it;
+	}
+	return (it_end);
+}
+// upper_bound -------------------------------
+MP_TPL typename MP::iterator MP::
+	upper_bound (const key_type& k) {
+
+	iterator	it = begin();
+	iterator	it_end = end();
+
+	while (it != it_end)
+	{
+		if (_comp(k, it->first))
+			return (it);
+		++it;
+	}
+	return (it_end);
+}
+MP_TPL typename MP::const_iterator MP::
+	upper_bound (const key_type& k) const {
+
+	const_iterator	it = begin();
+	const_iterator	it_end = end();
+
+	while (it != it_end)
+	{
+		if (_comp(k, it->first))
+			return (it);
+		++it;
+	}
+	return (it_end);
+}
+// equal_range -------------------------------
+MP_TPL pair<typename MP::const_iterator, typename MP::const_iterator> MP::
+	equal_range (const key_type& k) const {
+
+	return ft::make_pair( lower_bound(k), upper_bound(k) );
+}
+MP_TPL pair<typename MP::iterator, typename MP::iterator> MP::
+	equal_range (const key_type& k) {
+
+	return ft::make_pair( lower_bound(k), upper_bound(k) );
+}
 
 
 	/*************
 	 * allocator :
 	 *************/
-//// get_allocator -----------------------------
-//	allocator_type	get_allocator() const;
+// get_allocator -----------------------------
+MP_TPL typename MP::allocator_type MP::
+	get_allocator() const { return (_allocator); }
 
 
 	/************************
 	 * non-member functions :
 	 ************************/
-//// operator == -------------------------------
-//template< class K, class T, class Comp, class Alloc > bool operator==
-//	( const std::map<K,T,Comp,Alloc>& lhs, const std::map<K,T,Comp,Alloc>& rhs );
-//// operator != -------------------------------
-//template< class K, class T, class Comp, class Alloc > bool operator!=
-//	( const std::map<K,T,Comp,Alloc>& lhs, const std::map<K,T,Comp,Alloc>& rhs );
-//// operator < --------------------------------
-//template< class K, class T, class Comp, class Alloc > bool operator<
-//	( const std::map<K,T,Comp,Alloc>& lhs, const std::map<K,T,Comp,Alloc>& rhs );
-//// operator <= -------------------------------
-//template< class K, class T, class Comp, class Alloc > bool operator<=
-//	( const std::map<K,T,Comp,Alloc>& lhs, const std::map<K,T,Comp,Alloc>& rhs );
-//// operator > --------------------------------
-//template< class K, class T, class Comp, class Alloc > bool operator>
-//	( const std::map<K,T,Comp,Alloc>& lhs, const std::map<K,T,Comp,Alloc>& rhs );
-//// operator >= -------------------------------
-//template< class K, class T, class Comp, class Alloc > bool operator>=
-//	( const std::map<K,T,Comp,Alloc>& lhs, const std::map<K,T,Comp,Alloc>& rhs );
-//// swap (map) -----------------------------
-//template< class Key, class T, class Compare, class Alloc > void swap
-//	( std::map<Key,T,Compare,Alloc>& lhs, std::map<Key,T,Compare,Alloc>& rhs );
+// operator == -------------------------------
+template< class Key, class T, class Compare, class Alloc > bool operator==
+	( const MP& lhs, const MP& rhs ) { return (lhs._bst == rhs._bst); }
+// operator != -------------------------------
+template< class Key, class T, class Compare, class Alloc > bool operator!=
+	( const MP& lhs, const MP& rhs ) { return (lhs._bst != rhs._bst); }
+// operator < --------------------------------
+template< class Key, class T, class Compare, class Alloc > bool operator<
+	( const MP& lhs, const MP& rhs ) { return (lhs._bst < rhs._bst); }
+// operator <= -------------------------------
+template< class Key, class T, class Compare, class Alloc > bool operator<=
+	( const MP& lhs, const MP& rhs ) { return (lhs._bst <= rhs._bst); }
+// operator > --------------------------------
+template< class Key, class T, class Compare, class Alloc > bool operator>
+	( const MP& lhs, const MP& rhs ) { return (lhs._bst > rhs._bst); }
+// operator >= -------------------------------
+template< class Key, class T, class Compare, class Alloc > bool operator>=
+	( const MP& lhs, const MP& rhs ) { return (lhs._bst >= rhs._bst); }
+// swap (map) -----------------------------
+template< class Key, class T, class Compare, class Alloc > void swap
+	( const MP& lhs, const MP& rhs ) { lhs.swap(rhs); }
 
 } // namespace ft
 

tests/tests_map.cpp

@@ -14,8 +14,7 @@ TEST_M(tests_map_simple)
 
 	mp[VALT('a')] = VALU(10);
 
-//	it = mp.begin();
-//	PRINT(mp)
+	PRINT(mp)
 
 	DELETE
 }