// map standard header
#pragma once
#ifndef _MAP_
#define _MAP_
#ifndef RC_INVOKED
#include <xtree>

 #pragma pack(push,_CRT_PACKING)
 #pragma warning(push,3)
_STD_BEGIN
		// TEMPLATE CLASS _Tmap_traits
template<class _Kty,	// key type
	class _Ty,	// mapped type
	class _Pr,	// comparator predicate type
	class _Alloc,	// actual allocator type (should be value allocator)
	bool _Mfl>	// true if multiple equivalent keys are permitted
	class _Tmap_traits
		: public _Container_base
	{	// traits required to make _Tree behave like a map
public:
	typedef pair<_Kty, _Ty> _Val_type;
	typedef _Kty key_type;
	typedef pair<const _Kty, _Ty> value_type;
	typedef _Pr key_compare;

	typedef typename _Alloc::template rebind<value_type>::other
		allocator_type;

	enum
		{	// make multi parameter visible as an enum constant
		_Multi = _Mfl};

	_Tmap_traits()
		: comp()
		{	// construct with default comparator
		}

	_Tmap_traits(_Pr _Parg)
		: comp(_Parg)
		{	// construct with specified comparator
		}

	class value_compare
		: public binary_function<value_type, value_type, bool>
		{	// functor for comparing two element values
		friend class _Tmap_traits<_Kty, _Ty, _Pr, _Alloc, _Mfl>;

	public:
		bool operator()(const value_type& _Left,
			const value_type& _Right) const
			{	// test if _Left precedes _Right by comparing just keys
			return (comp(_Left.first, _Right.first));
			}

		value_compare(key_compare _Pred)
			: comp(_Pred)
			{	// construct with specified predicate
			}

	protected:
		key_compare comp;	// the comparator predicate for keys
		};

	template<class _Ty1,
		class _Ty2>
		static const _Kty& _Kfn(const _STD pair<_Ty1, _Ty2>& _Val)
		{	// extract key from element value
		return (_Val.first);
		}

	_Pr comp;	// the comparator predicate for keys
	};

		// TEMPLATE CLASS map
template<class _Kty,
	class _Ty,
	class _Pr = less<_Kty>,
	class _Alloc = allocator<pair<const _Kty, _Ty> > >
	class map
		: public _Tree<_Tmap_traits<_Kty, _Ty, _Pr, _Alloc, false> >
	{	// ordered red-black tree of {key, mapped} values, unique keys
public:
	typedef map<_Kty, _Ty, _Pr, _Alloc> _Myt;
	typedef _Tree<_Tmap_traits<_Kty, _Ty, _Pr, _Alloc, false> > _Mybase;
	typedef _Kty key_type;
	typedef _Ty mapped_type;
	typedef _Ty referent_type;	// retained
	typedef _Pr key_compare;
	typedef typename _Mybase::value_compare value_compare;
	typedef typename _Mybase::allocator_type allocator_type;
	typedef typename _Mybase::size_type size_type;
	typedef typename _Mybase::difference_type difference_type;
	typedef typename _Mybase::pointer pointer;
	typedef typename _Mybase::const_pointer const_pointer;
	typedef typename _Mybase::reference reference;
	typedef typename _Mybase::const_reference const_reference;
	typedef typename _Mybase::iterator iterator;
	typedef typename _Mybase::const_iterator const_iterator;
	typedef typename _Mybase::reverse_iterator reverse_iterator;
	typedef typename _Mybase::const_reverse_iterator
		const_reverse_iterator;
	typedef typename _Mybase::value_type value_type;

	map()
		: _Mybase(key_compare(), allocator_type())
		{	// construct empty map from defaults
		}

	map(const _Myt& _Right)
		: _Mybase(_Right)
		{	// construct map by copying _Right
		}

	explicit map(const key_compare& _Pred)
		: _Mybase(_Pred, allocator_type())
		{	// construct empty map from comparator
		}

	map(const key_compare& _Pred, const allocator_type& _Al)
		: _Mybase(_Pred, _Al)
		{	// construct empty map from comparator and allocator
		}

	template<class _Iter>
		map(_Iter _First, _Iter _Last)
		: _Mybase(key_compare(), allocator_type())
		{	// construct map from [_First, _Last), defaults
		this->insert(_First, _Last);
		}

	template<class _Iter>
		map(_Iter _First, _Iter _Last,
			const key_compare& _Pred)
		: _Mybase(_Pred, allocator_type())
		{	// construct map from [_First, _Last), comparator
		this->insert(_First, _Last);
		}

	template<class _Iter>
		map(_Iter _First, _Iter _Last,
			const key_compare& _Pred, const allocator_type& _Al)
		: _Mybase(_Pred, _Al)
		{	// construct map from [_First, _Last), comparator, and allocator
		this->insert(_First, _Last);
		}

	_Myt& operator=(const _Myt& _Right)
		{	// assign by copying _Right
		_Mybase::operator=(_Right);
		return (*this);
		}

	map(_Myt&& _Right)
		: _Mybase(_STD move(_Right))
		{	// construct map by moving _Right
		}

	_Myt& operator=(_Myt&& _Right)
		{	// assign by moving _Right
		_Mybase::operator=(_STD move(_Right));
		return (*this);
		}

	mapped_type& operator[](key_type&& _Keyval)
		{	// find element matching _Keyval or insert with default mapped
		iterator _Where = this->lower_bound(_Keyval);
		if (_Where == this->end()
			|| this->comp(_Keyval, this->_Key(_Where._Mynode())))
			_Where = this->insert(_Where,
				_STD pair<key_type, mapped_type>(
					_STD move(_Keyval),
					mapped_type()));
		return ((*_Where).second);
		}

	void swap(_Myt& _Right)
		{	// exchange contents with non-movable _Right
		_Mybase::swap(_Right);
		}

	void swap(_Myt&& _Right)
		{	// exchange contents with movable _Right
		_Mybase::swap(_STD move(_Right));
		}

 #if _HAS_CPP0X

 #else /* _HAS_CPP0X */

 #if _HAS_STRICT_CONFORMANCE
	void erase(const_iterator _Where)
		{	// erase element at _Where
		_Mybase::erase(_Where);
		}

	size_type erase(const key_type& _Keyval)
		{	// erase and count all that match _Keyval
		return (_Mybase::erase(_Keyval));
		}

	void erase(const_iterator _First, const_iterator _Last)
		{	// erase [_First, _Last)
		_Mybase::erase(_First, _Last);
		}
 #endif /* _HAS_STRICT_CONFORMANCE */

 #endif /* _HAS_CPP0X */

	mapped_type& operator[](const key_type& _Keyval)
		{	// find element matching _Keyval or insert with default mapped
		iterator _Where = this->lower_bound(_Keyval);
		if (_Where == this->end()
			|| this->comp(_Keyval, this->_Key(_Where._Mynode())))
			_Where = this->insert(_Where,
				value_type(_Keyval, mapped_type()));
		return ((*_Where).second);
		}

 #if _HAS_CPP0X
	mapped_type& at(const key_type& _Keyval)
		{	// find element matching _Keyval
		iterator _Where = this->lower_bound(_Keyval);
		if (_Where == this->end()
			|| this->comp(_Keyval, this->_Key(_Where._Mynode())))
			_Xout_of_range("invalid map<K, T> key");
		return ((*_Where).second);
		}

	const mapped_type& at(const key_type& _Keyval) const
		{	// find element matching _Keyval
		const_iterator _Where = this->lower_bound(_Keyval);
		if (_Where == this->end()
			|| this->comp(_Keyval, this->_Key(_Where._Mynode())))
			_Xout_of_range("invalid map<K, T> key");
		return ((*_Where).second);
		}
 #endif /* _HAS_CPP0X */
	};

template<class _Kty,
	class _Ty,
	class _Pr,
	class _Alloc> inline
	void swap(map<_Kty, _Ty, _Pr, _Alloc>& _Left,
		map<_Kty, _Ty, _Pr, _Alloc>& _Right)
	{	// swap _Left and _Right maps
	_Left.swap(_Right);
	}

template<class _Kty,
	class _Ty,
	class _Pr,
	class _Alloc> inline
	void swap(map<_Kty, _Ty, _Pr, _Alloc>& _Left,
		map<_Kty, _Ty, _Pr, _Alloc>&& _Right)
	{	// swap _Left and _Right maps
	typedef map<_Kty, _Ty, _Pr, _Alloc> _Myt;
	_Left.swap(_STD forward<_Myt>(_Right));
	}

template<class _Kty,
	class _Ty,
	class _Pr,
	class _Alloc> inline
	void swap(map<_Kty, _Ty, _Pr, _Alloc>&& _Left,
		map<_Kty, _Ty, _Pr, _Alloc>& _Right)
	{	// swap _Left and _Right maps
	typedef map<_Kty, _Ty, _Pr, _Alloc> _Myt;
	_Right.swap(_STD forward<_Myt>(_Left));
	}

		// TEMPLATE CLASS multimap
template<class _Kty,
	class _Ty,
	class _Pr = less<_Kty>,
	class _Alloc = allocator<pair<const _Kty, _Ty> > >
	class multimap
		: public _Tree<_Tmap_traits<_Kty, _Ty, _Pr, _Alloc, true> >
	{	// ordered red-black tree of {key, mapped} values, non-unique keys
public:
	typedef multimap<_Kty, _Ty, _Pr, _Alloc> _Myt;
	typedef _Tree<_Tmap_traits<_Kty, _Ty, _Pr, _Alloc, true> > _Mybase;
	typedef _Kty key_type;
	typedef _Ty mapped_type;
	typedef _Ty referent_type;	// retained
	typedef _Pr key_compare;
	typedef typename _Mybase::value_compare value_compare;
	typedef typename _Mybase::allocator_type allocator_type;
	typedef typename _Mybase::size_type size_type;
	typedef typename _Mybase::difference_type difference_type;
	typedef typename _Mybase::pointer pointer;
	typedef typename _Mybase::const_pointer const_pointer;
	typedef typename _Mybase::reference reference;
	typedef typename _Mybase::const_reference const_reference;
	typedef typename _Mybase::iterator iterator;
	typedef typename _Mybase::const_iterator const_iterator;
	typedef typename _Mybase::reverse_iterator reverse_iterator;
	typedef typename _Mybase::const_reverse_iterator
		const_reverse_iterator;
	typedef typename _Mybase::value_type value_type;

	multimap()
		: _Mybase(key_compare(), allocator_type())
		{	// construct empty map from defaults
		}

	multimap(const _Myt& _Right)
		: _Mybase(_Right)
		{	// construct map by copying _Right
		}

	explicit multimap(const key_compare& _Pred)
		: _Mybase(_Pred, allocator_type())
		{	// construct empty map from comparator
		}
	multimap(const key_compare& _Pred, const allocator_type& _Al)
		: _Mybase(_Pred, _Al)
		{	// construct empty map from comparator and allocator
		}

	template<class _Iter>
		multimap(_Iter _First, _Iter _Last)
		: _Mybase(key_compare(), allocator_type())
		{	// construct map from [_First, _Last), defaults
		this->insert(_First, _Last);
		}

	template<class _Iter>
		multimap(_Iter _First, _Iter _Last,
			const key_compare& _Pred)
		: _Mybase(_Pred, allocator_type())
		{	// construct map from [_First, _Last), comparator
		this->insert(_First, _Last);
		}

	template<class _Iter>
		multimap(_Iter _First, _Iter _Last,
			const key_compare& _Pred, const allocator_type& _Al)
		: _Mybase(_Pred, _Al)
		{	// construct map from [_First, _Last), comparator, and allocator
		this->insert(_First, _Last);
		}

	_Myt& operator=(const _Myt& _Right)
		{	// assign by copying _Right
		_Mybase::operator=(_Right);
		return (*this);
		}

	multimap(_Myt&& _Right)
		: _Mybase(_STD move(_Right))
		{	// construct map by moving _Right
		}

	_Myt& operator=(_Myt&& _Right)
		{	// assign by moving _Right
		_Mybase::operator=(_STD move(_Right));
		return (*this);
		}

	template<class _Valty>
		iterator insert(_Valty&& _Val)
		{	// insert a {key, mapped} value
		return (_Mybase::insert(_STD forward<_Valty>(_Val)).first);
		}

	template<class _Valty>
		typename _STD tr1::enable_if<!_STD tr1::is_same<const_iterator,
			typename _STD tr1::remove_reference<_Valty>::type>::value,
				iterator>::type
		insert(const_iterator _Where, _Valty&& _Val)
		{	// insert a {key, mapped} value, with hint
		return (_Mybase::insert(_Where, _STD forward<_Valty>(_Val)));
		}

	void swap(_Myt& _Right)
		{	// exchange contents with non-movable _Right
		_Mybase::swap(_Right);
		}

	void swap(_Myt&& _Right)
		{	// exchange contents with movable _Right
		_Mybase::swap(_STD move(_Right));
		}

 #if _HAS_CPP0X

 #else /* _HAS_CPP0X */

 #if _HAS_STRICT_CONFORMANCE
	void erase(const_iterator _Where)
		{	// erase element at _Where
		_Mybase::erase(_Where);
		}

	size_type erase(const key_type& _Keyval)
		{	// erase and count all that match _Keyval
		return (_Mybase::erase(_Keyval));
		}

	void erase(const_iterator _First, const_iterator _Last)
		{	// erase [_First, _Last)
		_Mybase::erase(_First, _Last);
		}
 #endif /* _HAS_STRICT_CONFORMANCE */

 #endif /* _HAS_CPP0X */

	iterator insert(const value_type& _Val)
		{	// insert a {key, mapped} value
		return (_Mybase::insert(_Val).first);
		}

	iterator insert(const_iterator _Where, const value_type& _Val)
		{	// insert a {key, mapped} value, with hint
		return (_Mybase::insert(_Where, _Val));
		}

	template<class _Iter>
		void insert(_Iter _First, _Iter _Last)
		{	// insert [_First, _Last), arbitrary iterators
		_DEBUG_RANGE(_First, _Last);
		for (; _First != _Last; ++_First)
			insert(*_First);
		}
	};

template<class _Kty,
	class _Ty,
	class _Pr,
	class _Alloc> inline
	void swap(multimap<_Kty, _Ty, _Pr, _Alloc>& _Left,
		multimap<_Kty, _Ty, _Pr, _Alloc>& _Right)
	{	// swap _Left and _Right multimaps
	_Left.swap(_Right);
	}

template<class _Kty,
	class _Ty,
	class _Pr,
	class _Alloc> inline
	void swap(multimap<_Kty, _Ty, _Pr, _Alloc>& _Left,
		multimap<_Kty, _Ty, _Pr, _Alloc>&& _Right)
	{	// swap _Left and _Right multimaps
	typedef multimap<_Kty, _Ty, _Pr, _Alloc> _Myt;
	_Left.swap(_STD forward<_Myt>(_Right));
	}

template<class _Kty,
	class _Ty,
	class _Pr,
	class _Alloc> inline
	void swap(multimap<_Kty, _Ty, _Pr, _Alloc>&& _Left,
		multimap<_Kty, _Ty, _Pr, _Alloc>& _Right)
	{	// swap _Left and _Right multimaps
	typedef multimap<_Kty, _Ty, _Pr, _Alloc> _Myt;
	_Right.swap(_STD forward<_Myt>(_Left));
	}
_STD_END
 #pragma warning(pop)
 #pragma pack(pop)

#endif /* RC_INVOKED */
#endif /* _MAP_ */

/*
 * Copyright (c) 1992-2009 by P.J. Plauger.  ALL RIGHTS RESERVED.
 * Consult your license regarding permissions and restrictions.
V5.20:0009 */
