STL

Many thanks to the people who devote themselft to the common libs.

STL four components

 

Global Constructor and Destructor

 

STL Allocator

 

STL Vector

 

STL List

 

STL Tree

asdfsdf

 

Introduction to the Standard Template Library.

1. The Standard Template Library ( abbreviated as STL ) is a C++ library consisting of three components which are container classes, algorithms, and iterators providing many of the basic algorithms and data structures and data accessing easily of computer science.
2. You should make sure that you understand how templates work with C++ before you use the STL. 
3. Templates = replacement = code expansion at compiling-time.
4. Like many class library, The STL includes container classes whose purpose is to contain other objects, including the classes:vector, list, deque, set, multiset, map, multimap, hash_set, hash_multiset, hash_map and hash_multimap.
5. The STL also includes a large collection of algorithms that manipulate the data stored in containers.
6. There are two important points to notice about this call to reverse(). First, it is a global function, not a member function. Second, it takes two arguments rather than one: it operates on a range of elements, rather than on a container. In this particular case the range happens to be the entire container.
7. reverse( objectOfcontainer.begin(), objectOfcontainer.end())
8. Iterators are the mechanism that makes it possible to decouple algorithms from containers: algorithms are templates, and are parameterized by the type of iterator, so they are not restricted to a single type of container. Traverse all element in container.
9. Proceed from the beginning to the end, and stops either when it finds an iterator that points to value or when it reaches the end of the range.
10. One very important question to ask about any template function, not just about STL algorithms is what the set of types is that may correctly be substituted for the formal template parameters.
11. Concepts are not a part of the C++ language; there is no way to declare a concept in a program, or to declare that particular type is a model of a concept. Nevertheless, concepts are an extremely important part of the STL. Using concepts makes it possible to write programs that cleanly separate interface from implementation.
12. Concept programming, Generic programming 

Classification of STL components

1. The STL components are divided into six broad categories on the basis of functionality: Containers, Iterator, Algorithms, Function Objects, Utilities, and Allocator.
2. The STL documentation contains two indices ( index). One of them, the Main Index, list all components in alphabetical order. The other, the Divided Index, contains a separate alphabetical listing for each category.
3. The format of a concept page. A page that documents a concept has the following sections: Summary; Refinement of; Associated types; Notation; Definitions; Valid Expressions; Expression Semantics; Complexity Guarantees; Invariants; Models; Notes; See Also;

4. //////////////////////////////////////////////////////////////////////////////
   //
   // (C) Copyright Pablo Halpern 2009. Distributed under the Boost
   // Software License, Version 1.0. (See accompanying file
   // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
   //
   //////////////////////////////////////////////////////////////////////////////
   //
   // (C) Copyright Ion Gaztanaga 2011-2012. Distributed under the Boost
   // Software License, Version 1.0. (See accompanying file
   // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
   //
   // See http://www.boost.org/libs/container for documentation.
   //
   //////////////////////////////////////////////////////////////////////////////
   
   #ifndef BOOST_CONTAINER_ALLOCATOR_ALLOCATOR_TRAITS_HPP
   #define BOOST_CONTAINER_ALLOCATOR_ALLOCATOR_TRAITS_HPP
   
   #if (defined _MSC_VER) && (_MSC_VER >= 1200)
   #  pragma once
   #endif
   #include <boost/container/detail/config_begin.hpp>
   #include <boost/container/detail/workaround.hpp>
   #include <boost/intrusive/pointer_traits.hpp>
   #include <boost/intrusive/detail/memory_util.hpp>
   #include <boost/container/detail/memory_util.hpp>
   #include <boost/type_traits/integral_constant.hpp>
   #include <boost/container/detail/mpl.hpp>
   #include <boost/move/utility.hpp>
   #include <limits> //numeric_limits<>::max()
   #include <new>    //placement new
   #include <memory> //std::allocator
   #if defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
   #include <boost/container/detail/preprocessor.hpp>
   #endif
   
   namespace boost {
   namespace container {
   namespace container_detail {
   
   template<class A>
   struct is_std_allocator
   {  static const bool value = false; };
   
   template<class T>
   struct is_std_allocator< std::allocator<T> >
   {  static const bool value = true; };
   
   }  //namespace container_detail {
   
   template <typename Alloc>
   struct allocator_traits
   {
      //allocator_type
      typedef Alloc allocator_type;
      //value_type
      typedef typename Alloc::value_type         value_type;
   
      #if defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
    
         typedef unspecified pointer;
         typedef see_documentation const_pointer;
         typedef see_documentation reference;
         typedef see_documentation const_reference;
         typedef see_documentation void_pointer;
         typedef see_documentation const_void_pointer;
         typedef see_documentation difference_type;
         typedef see_documentation size_type;
         typedef see_documentation propagate_on_container_copy_assignment;
         typedef see_documentation propagate_on_container_move_assignment;
         typedef see_documentation propagate_on_container_swap;
         template <class T> using rebind_alloc = see_documentation;
         template <class T> using rebind_traits = allocator_traits<rebind_alloc<T> >;
         template <class T>
         struct portable_rebind_alloc
         {  typedef see_documentation type;  };
      #else
         //pointer
         typedef BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_DEFAULT(boost::container::container_detail::, Alloc,
            pointer, value_type*)
               pointer;
         //const_pointer
         typedef BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_EVAL_DEFAULT(boost::container::container_detail::, Alloc,
            const_pointer, typename boost::intrusive::pointer_traits<pointer>::template
               rebind_pointer<const value_type>)
                  const_pointer;
         //reference
         typedef BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_DEFAULT(boost::container::container_detail::, Alloc,
            reference, typename container_detail::unvoid<value_type>::type&)
               reference;
         //const_reference
         typedef BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_DEFAULT(boost::container::container_detail::, Alloc,
            const_reference, const typename container_detail::unvoid<value_type>::type&)
                  const_reference;
         //void_pointer
         typedef BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_EVAL_DEFAULT(boost::container::container_detail::, Alloc,
            void_pointer, typename boost::intrusive::pointer_traits<pointer>::template
               rebind_pointer<void>)
                  void_pointer;
         //const_void_pointer
         typedef BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_EVAL_DEFAULT(boost::container::container_detail::, Alloc,
            const_void_pointer, typename boost::intrusive::pointer_traits<pointer>::template
               rebind_pointer<const void>)
                  const_void_pointer;
         //difference_type
         typedef BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_DEFAULT(boost::container::container_detail::, Alloc,
            difference_type, std::ptrdiff_t)
               difference_type;
         //size_type
         typedef BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_DEFAULT(boost::container::container_detail::, Alloc,
            size_type, std::size_t)
               size_type;
         //propagate_on_container_copy_assignment
         typedef BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_DEFAULT(boost::container::container_detail::, Alloc,
            propagate_on_container_copy_assignment, boost::false_type)
               propagate_on_container_copy_assignment;
         //propagate_on_container_move_assignment
         typedef BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_DEFAULT(boost::container::container_detail::, Alloc,
            propagate_on_container_move_assignment, boost::false_type)
               propagate_on_container_move_assignment;
         //propagate_on_container_swap
         typedef BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_DEFAULT(boost::container::container_detail::, Alloc,
            propagate_on_container_swap, boost::false_type)
               propagate_on_container_swap;
   
         #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
            //C++11
            template <typename T> using rebind_alloc  = typename boost::intrusive::detail::type_rebinder<Alloc, T>::type;
            template <typename T> using rebind_traits = allocator_traits< rebind_alloc<T> >;
         #else    // #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
            //Some workaround for C++03 or C++11 compilers with no template aliases
            template <typename T>
            struct rebind_alloc : boost::intrusive::detail::type_rebinder<Alloc,T>::type
            {
               typedef typename boost::intrusive::detail::type_rebinder<Alloc,T>::type Base;
               #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
               template <typename... Args>
               rebind_alloc(BOOST_FWD_REF(Args)... args)
                  : Base(boost::forward<Args>(args)...)
               {}
               #else    // #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
               #define BOOST_PP_LOCAL_MACRO(n)                                                        
               BOOST_PP_EXPR_IF(n, template<) BOOST_PP_ENUM_PARAMS(n, class P) BOOST_PP_EXPR_IF(n, >) 
               rebind_alloc(BOOST_PP_ENUM(n, BOOST_CONTAINER_PP_PARAM_LIST, _))                       
                  : Base(BOOST_PP_ENUM(n, BOOST_CONTAINER_PP_PARAM_FORWARD, _))                       
               {}                                                                                     
               //
               #define BOOST_PP_LOCAL_LIMITS (0, BOOST_CONTAINER_MAX_CONSTRUCTOR_PARAMETERS)
               #include BOOST_PP_LOCAL_ITERATE()
               #endif   // #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
            };
   
            template <typename T>
            struct rebind_traits
               : allocator_traits<typename boost::intrusive::detail::type_rebinder<Alloc, T>::type>
            {};
         #endif   // #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
         template <class T>
         struct portable_rebind_alloc
         {  typedef typename boost::intrusive::detail::type_rebinder<Alloc, T>::type type;  };
      #endif   //BOOST_CONTAINER_DOXYGEN_INVOKED
   
      static pointer allocate(Alloc &a, size_type n)
      {  return a.allocate(n);  }
   
      static void deallocate(Alloc &a, pointer p, size_type n)
      {  a.deallocate(p, n);  }
   
      //! <b>Effects</b>: calls `a.allocate(n, p)` if that call is well-formed;
      //! otherwise, invokes `a.allocate(n)`
      static pointer allocate(Alloc &a, size_type n, const_void_pointer p)
      {
         const bool value = boost::container::container_detail::
            has_member_function_callable_with_allocate
               <Alloc, const size_type, const const_void_pointer>::value;
         ::boost::integral_constant<bool, value> flag;
         return allocator_traits::priv_allocate(flag, a, n, p);
      }
   
      //! <b>Effects</b>: calls `a.destroy(p)` if that call is well-formed;
      //! otherwise, invokes `p->~T()`.
      template<class T>
      static void destroy(Alloc &a, T*p)
      {
         typedef T* destroy_pointer;
         const bool value = boost::container::container_detail::
            has_member_function_callable_with_destroy
               <Alloc, const destroy_pointer>::value;
         ::boost::integral_constant<bool, value> flag;
         allocator_traits::priv_destroy(flag, a, p);
      }
      static size_type max_size(const Alloc &a)
      {
         const bool value = boost::container::container_detail::
            has_member_function_callable_with_max_size
               <const Alloc>::value;
         ::boost::integral_constant<bool, value> flag;
         return allocator_traits::priv_max_size(flag, a);
      }
   
      static
      #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
      typename container_detail::if_c
         <  boost::container::container_detail::
                     has_member_function_callable_with_select_on_container_copy_construction
                        <const Alloc>::value
         , Alloc
         , const Alloc &
         >::type
      #else
      Alloc
      #endif
      select_on_container_copy_construction(const Alloc &a)
      {
         const bool value = boost::container::container_detail::
            has_member_function_callable_with_select_on_container_copy_construction
               <const Alloc>::value;
         ::boost::integral_constant<bool, value> flag;
         return allocator_traits::priv_select_on_container_copy_construction(flag, a);
      }
         template <class T, class ...Args>
         static void construct(Alloc & a, T* p, BOOST_FWD_REF(Args)... args)
         {
            ::boost::integral_constant<bool, container_detail::is_std_allocator<Alloc>::value> flag;
            allocator_traits::priv_construct(flag, a, p, ::boost::forward<Args>(args)...);
         }
      #endif
      ///@cond
      #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
         private:
         static pointer priv_allocate(boost::true_type, Alloc &a, size_type n, const_void_pointer p)
         {  return a.allocate(n, p);  }
   
         static pointer priv_allocate(boost::false_type, Alloc &a, size_type n, const_void_pointer)
         {  return allocator_traits::allocate(a, n);  }
   
         template<class T>
         static void priv_destroy(boost::true_type, Alloc &a, T* p)
         {  a.destroy(p);  }
   
         template<class T>
         static void priv_destroy(boost::false_type, Alloc &, T* p)
         {  p->~T(); (void)p;  }
   
         static size_type priv_max_size(boost::true_type, const Alloc &a)
         {  return a.max_size();  }
   
         static size_type priv_max_size(boost::false_type, const Alloc &)
         {  return (std::numeric_limits<size_type>::max)();  }
   
         static Alloc priv_select_on_container_copy_construction(boost::true_type, const Alloc &a)
         {  return a.select_on_container_copy_construction();  }
   
         static const Alloc &priv_select_on_container_copy_construction(boost::false_type, const Alloc &a)
         {  return a;  }
   
         #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
            template<class T, class ...Args>
            static void priv_construct(boost::false_type, Alloc &a, T *p, BOOST_FWD_REF(Args) ...args)                   
            {                                                                                                 
               const bool value = boost::container::container_detail::
                     has_member_function_callable_with_construct
                        < Alloc, T*, Args... >::value;
               ::boost::integral_constant<bool, value> flag;
               priv_construct_dispatch2(flag, a, p, ::boost::forward<Args>(args)...);
            }
   
            template<class T, class ...Args>
            static void priv_construct(boost::true_type, Alloc &a, T *p, BOOST_FWD_REF(Args) ...args)
            {
               priv_construct_dispatch2(boost::false_type(), a, p, ::boost::forward<Args>(args)...);
            }
   
            template<class T, class ...Args>
            static void priv_construct_dispatch2(boost::true_type, Alloc &a, T *p, BOOST_FWD_REF(Args) ...args)
            {  a.construct( p, ::boost::forward<Args>(args)...);  }
   
            template<class T, class ...Args>
            static void priv_construct_dispatch2(boost::false_type, Alloc &, T *p, BOOST_FWD_REF(Args) ...args)
            {  ::new((void*)p) T(::boost::forward<Args>(args)...); }
         #else // #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
            public:
            #define BOOST_PP_LOCAL_MACRO(n)                                                              
            template<class T BOOST_PP_ENUM_TRAILING_PARAMS(n, class P) >                                 
            static void construct(Alloc &a, T *p                                                         
                                 BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_PARAM_LIST, _))            
            {                                                                                            
               ::boost::integral_constant<bool, container_detail::is_std_allocator<Alloc>::value> flag;  
               allocator_traits::priv_construct(flag, a, p                                               
                  BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_PARAM_FORWARD, _));                       
            }                                                                                            
            //
            #define BOOST_PP_LOCAL_LIMITS (0, BOOST_CONTAINER_MAX_CONSTRUCTOR_PARAMETERS)
            #include BOOST_PP_LOCAL_ITERATE()
        
            private:
            #define BOOST_PP_LOCAL_MACRO(n)                                                                    
            template<class T  BOOST_PP_ENUM_TRAILING_PARAMS(n, class P) >                                      
            static void priv_construct(boost::false_type, Alloc &a, T *p                                       
                           BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_PARAM_LIST,_))                         
            {                                                                                                  
               const bool value =                                                                              
                  boost::container::container_detail::has_member_function_callable_with_construct              
                        < Alloc, T* BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_FWD_TYPE, _) >::value;        
               ::boost::integral_constant<bool, value> flag;                                                   
               priv_construct_dispatch2(flag, a, p                                                             
                  BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_PARAM_FORWARD, _) );                            
            }                                                                                                  
                                                                                                               
            template<class T  BOOST_PP_ENUM_TRAILING_PARAMS(n, class P) >                                      
            static void priv_construct(boost::true_type, Alloc &a, T *p                                        
                           BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_PARAM_LIST,_))                         
            {                                                                                                  
               priv_construct_dispatch2(boost::false_type(), a, p                                              
                  BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_PARAM_FORWARD, _) );                            
            }                                                                                                  
                                                                                                               
            template<class T  BOOST_PP_ENUM_TRAILING_PARAMS(n, class P) >                                      
            static void priv_construct_dispatch2(boost::true_type, Alloc &a, T *p                              
                           BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_PARAM_LIST,_))                         
            {  a.construct( p BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_PARAM_FORWARD, _) );  }             
                                                                                                               
            template<class T  BOOST_PP_ENUM_TRAILING_PARAMS(n, class P) >                                      
            static void priv_construct_dispatch2(boost::false_type, Alloc &, T *p                              
                           BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_PARAM_LIST, _) )                       
            {  ::new((void*)p) T(BOOST_PP_ENUM(n, BOOST_CONTAINER_PP_PARAM_FORWARD, _)); }                     
            //
            #define BOOST_PP_LOCAL_LIMITS (0, BOOST_CONTAINER_MAX_CONSTRUCTOR_PARAMETERS)
            #include BOOST_PP_LOCAL_ITERATE()
         #endif   // #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
      #endif   //#if defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
   
      ///@endcond
   };
   
   }  //namespace container {
   }  //namespace boost {
   
   #include <boost/container/detail/config_end.hpp>
   
   #endif // ! defined(BOOST_CONTAINER_ALLOCATOR_ALLOCATOR_TRAITS_HPP)

 Container-->Concepts-->General concepts-->Container

1. A container is an object that stores other objects (its elements), and that has methods for accessing its elements. In particular, every type that is a model of Container has an associated iterator type that can be used to iterate/traverse through the Container’s elements.
2. There is no guarantee that the elements of a Container are stored in any definite order; the order might, in fact, be different upon each iteration through the container. Nor is there a guarantee that more than one iterator into a Container may be active at any one time.
3. Associated Type (which are defined in Allocator):
   • Value type (X:: value_type);
   • Iterator type ( X::iterator);
   • Const iterator type (X::const_iterator);
   • Reference type (X:: reference);
   • Const reference type (X::const_reference);
   • Pointer type( X:: pointer);
   • Distance type( X::difference_type);
   • Size type(X::size_type); 
4.  Valid expression: Beginning of range ( a.begin(); End of range ( a.end() ); Size (a.size()); Maximum size ( a.max_size()); Empty container(a.empty()); Swap (a.swap(b));

Container-->Concepts-->General concepts-->Forward Container

1. A forward container is a Container whose elements are arranged in a definite order: the ordering will not change spontaneously/naturally/unaffectedly from iteration to iteration. The requirements of a definite ordering allows the definition of element-by-element equality (if the container’s element type is Equality Comparable) and of lexicographical (edited by vocabulary) ordering ( in the container’s element type is LessThan Comparable).
2. Complexity Guarantees: The equality and inequality operations are linear in the container’s size.
3. Invariants: Two different iterations through a forward container will access its elements in the same order, providing that there have been no intervening mutative operations.
4. Must support functions: EqualityComparable, LessThanComparable.

Container-->Concepts-->General concepts-->Reversible Container

1. A reversible container is a forward container whose iterators are bidirectional iterators. It allows backwards iteration through the container.
2. Two new types are introduced. In addition, the iterator and the const iterator type must satisfy a more stringent/severe/tight/strict requirement than for a Forward Container. The iterator and reverse iterator types must be Bidirectional iterators, not merely Forward Iterators.
3. X::reverse_iterator: A Reverse Iterator adaptor whose base iterator type is container’s iterator type. Incrementing an object of type reverse_iterator moved backwards through the container: the Reverse Iterator adaptor maps operator++ to operator--.
4.  X::const_reverse_iterator: A Reverse Iterator adaptor whose base iterator type is the container’s const iterator type.
5. a.rbegin() == X::reverse_iterator (a.end() ); a.rend() == X::reverse_iterator (a.begin() );

Container-->Concepts-->General concepts-->Random Access Container

1. A Random Access Container is a Reversible Container whose iterator type is a Random Access Iterator. It provides amortized constant time access to arbitrary elements.
2. No additional types beyond those defined in Reversible Container. However, the requirements for the iterator type are strengthened: it must be a Random Access Iterator.
3. The element returned by a[n] is the same as the one obtained by incrementing a.begin() n times and then dereferencing the resulting iterator.

Sequences->Sequence Container

1. A sequence is a variable-sized Container whose elements are arranged in a strict linear order. It supports insertion and removal of elements.
2. Forward Container; Default Constructible
3. The fill constructor, default constructor and range constructor are linear
4. Front is amortized constant time.
5. Fill insert, range insert, and range erase are linear.
6. The complexities of single-element insert and erase are sequence dependent.
7. Models: vector; deque; list; slist
8. Note that p being equal to a.begin() means to insert something at the beginning of a( that is, before any elements already in a), and p being equal to a.end() means to append something to the end of a.
9. There is no guarantee that a valid iterator on a is still valid after an insertion or an erasure/removal. In some cases iterators do remain valid, and in other cases they do not. The details are different for each sequence class.
10. a.insert(p, n, t) is guaranteed to be no slower than calling a.insert( p, t) n times, In some cases it is significantly faster.
11. Vector is usually preferable to deque and list . Deque is useful in the case of frequent insertions ato both the beginning an end of the sequence, and list and slist are useful in the case of frequent insertions in the middle of the sequence. In almost all other situations, vector is more efficient.

Sequences->Front Insertion Sequence

1. A Front Insertion Sequence is a Sequence where it is possible to insert an element at the beginning, or to access the first element, in amortized constant time. Front Insertion Sequence have special member functions as a short hand for those operations.
2. Front, push front, and pop front are amortized constant time.
3. Models: list; deque
4. Front is actually defined in Sequence, since it is always possible to implement it in amortized constant time. Its definition is repealed/abolished here, along with push front and pop front, in the interest of clarity.
5. This complexity guarantee is the only reason that front(), push_front(), and pop_front are defined : they provided no additional functionality. Not every sequence must define these operations, but it is guaranteed that they are efficient if they exist at all.

Sequences->Back Insertion Sequence

1. A Back Insertion Sequence is a Sequence where it is possible to append an element to the end, or to access the last element, in amortized constant time. Back Insertion Sequence have special member functions as a shorthand for those operations.
2. Back, push back, and pop back are amortized constant time.
3. Models: vector, list, deque
4. This complexity guarantee is the only reason that back(), push_back() and pop_back() are defined: they provide no additional functionality. Not every sequence must define these operations, but it is guaranteed that they are efficient if they exist at all.

Associative->Associative Container

1. An Associative Container is a variable-sized Container that supports efficient retrieval of elements /values based on keys. It supports insertion and removal / erasure, but differs from a Sequence in that it does not provide a mechanism for inserting an element at specific position.
2. As with all containers, the elements in an Associative Container are of type value_type. Additionally, each element in an Associative Container has a key, being of type key_type. 
3. In some Associative Containers, Simple Associative Containers, the value_type and key_type are the same: elements are their own keys. In others, the key is some specific part of the value. Since elements are stored according to their keys, it is essential that the key associated with each element is immutable.
4. In Simple Associative Containers this means that the elements themselves are immutable, while in other types of Associative Containers, such as Pair Associative Containers, the elements themselves are mutable but the part of an element that is its key cannot be modified. This means that an Associative Containers’ value type is not Assignable /Allocative.
5. The fact that the value type of an Associative Container is not Assignable has an important consequence: associative containers cannot have mutable iterators. This is simply because a mutable iterator (as defined in the Trivial Iterator requirements) must allow assignment. That is, if I is a mutable iterator and t is an object of I’s value type, then *I = t must be a valid expression.
6. In Simple Associative Containers, where the elements are the keys, the elements are completely mutable; the nested /types iterator and const_iterator are therefore the same. Other types of associative containers, however, do have mutable elements, and do provide iterators through which elements can be modified.
7. Pair Associative Containers, for example, have two different nested types iterator and const_iterator. Even in this case, iterator is not a mutable iterator: as explained above, it does not provide the expression *I = t. It is, however, possible to modify an element through such an iterator: if, for example, I is of type map<int, double>, then (*i).second = 3 is a valid expression.
8. In some associative containers, Unique Associative Containers, it is guaranteed that no two elements have the same key. In other associative containers. Multiple Associative Containers, multiple elements with the same key are permitted.
9. Models: set; multiset; hash_set; hash_multiset; map; multimap; hash_map; hash_multimap
10. Red-Black Tree:http://en.wikipedia.org/wiki/Red%E2%80%93black_tree

11. //////////////////////////////////////////////////////////////////////////////
    //
    // (C) Copyright Ion Gaztanaga 2005-2012. Distributed under the Boost
    // Software License, Version 1.0. (See accompanying file
    // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
    //
    // See http://www.boost.org/libs/container for documentation.
    //
    //////////////////////////////////////////////////////////////////////////////
    
    #ifndef BOOST_CONTAINER_TREE_HPP
    #define BOOST_CONTAINER_TREE_HPP
    
    #include "config_begin.hpp"
    #include <boost/container/detail/workaround.hpp>
    #include <boost/container/container_fwd.hpp>
    
    #include <boost/move/utility.hpp>
    #include <boost/intrusive/pointer_traits.hpp>
    #include <boost/type_traits/has_trivial_destructor.hpp>
    #include <boost/detail/no_exceptions_support.hpp>
    #include <boost/intrusive/rbtree.hpp>
    
    #include <boost/container/detail/utilities.hpp>
    #include <boost/container/detail/algorithms.hpp>
    #include <boost/container/detail/node_alloc_holder.hpp>
    #include <boost/container/detail/destroyers.hpp>
    #include <boost/container/detail/pair.hpp>
    #include <boost/container/detail/type_traits.hpp>
    #include <boost/container/allocator_traits.hpp>
    #include <boost/detail/no_exceptions_support.hpp>
    #ifndef BOOST_CONTAINER_PERFECT_FORWARDING
    #include <boost/container/detail/preprocessor.hpp>
    #endif
    
    #include <utility>   //std::pair
    #include <iterator>
    #include <algorithm>
    
    namespace boost {
    namespace container {
    namespace container_detail {
    
    template<class Key, class Value, class KeyCompare, class KeyOfValue>
    struct tree_value_compare:  public KeyCompare
    {
       typedef Value        value_type;
       typedef KeyCompare   key_compare;
       typedef KeyOfValue   key_of_value;
       typedef Key          key_type;
    
       tree_value_compare(const key_compare &kcomp)
          :  key_compare(kcomp)
       {}
    
       const key_compare &key_comp() const
       {  return static_cast<const key_compare &>(*this);  }
    
       key_compare &key_comp()
       {  return static_cast<key_compare &>(*this);  }
    
       template<class T>
       struct is_key
       {
          static const bool value = is_same<const T, const key_type>::value;
       };
    
       template<class T>
       typename enable_if_c<is_key<T>::value, const key_type &>::type key_forward(const T &key) const
       {  return key; }
    
       template<class T>
       typename enable_if_c<!is_key<T>::value, const key_type &>::type key_forward(const T &key) const
       {  return KeyOfValue()(key);  }
    
       template<class KeyType, class KeyType2>
       bool operator()(const KeyType &key1, const KeyType2 &key2) const
       {  return key_compare::operator()(this->key_forward(key1), this->key_forward(key2));  }
    };
    
    template<class VoidPointer>
    struct rbtree_hook
    {
       typedef typename container_detail::bi::make_set_base_hook
          < container_detail::bi::void_pointer<VoidPointer>
          , container_detail::bi::link_mode<container_detail::bi::normal_link>
          , container_detail::bi::optimize_size<true>
          >::type  type;
    };
    
    //This trait is used to type-pun std::pair because in C++03
    //compilers std::pair is useless for C++11 features
    template<class T>
    struct rbtree_internal_data_type
    {
       typedef T type;
    };
    
    template<class T1, class T2>
    struct rbtree_internal_data_type< std::pair<T1, T2> >
    {
       typedef pair<T1, T2> type;
    };
    //The node to be store in the tree
    template <class T, class VoidPointer>
    struct rbtree_node:  public rbtree_hook<VoidPointer>::type
    {
       private:
       //BOOST_COPYABLE_AND_MOVABLE(rbtree_node)
       rbtree_node();
       public:
       typedef typename rbtree_hook<VoidPointer>::type hook_type;
       typedef T value_type;
       typedef typename rbtree_internal_data_type<T>::type internal_type;
       typedef rbtree_node<T, VoidPointer> node_type;
       T &get_data()
       {
          T* ptr = reinterpret_cast<T*>(&this->m_data);
          return *ptr;
       }
       const T &get_data() const
       {
          const T* ptr = reinterpret_cast<const T*>(&this->m_data);
          return *ptr;
       }
       internal_type m_data;
       template<class A, class B>
       void do_assign(const std::pair<const A, B> &p)
       {
          const_cast<A&>(m_data.first) = p.first;
          m_data.second  = p.second;
       }
       template<class A, class B>
       void do_assign(const pair<const A, B> &p)
       {
          const_cast<A&>(m_data.first) = p.first;
          m_data.second  = p.second;
       }
       template<class V>
       void do_assign(const V &v)
       {  m_data = v; }
    
       template<class A, class B>
       void do_move_assign(std::pair<const A, B> &p)
       {
          const_cast<A&>(m_data.first) = ::boost::move(p.first);
          m_data.second = ::boost::move(p.second);
       }
       template<class A, class B>
       void do_move_assign(pair<const A, B> &p)
       {
          const_cast<A&>(m_data.first) = ::boost::move(p.first);
          m_data.second  = ::boost::move(p.second);
       }
       template<class V>
       void do_move_assign(V &v)
       {  m_data = ::boost::move(v); }
    };
    
    }//namespace container_detail {
    
    namespace container_detail {
    template<class A, class ValueCompare>
    struct intrusive_rbtree_type
    {
       typedef typename boost::container::
          allocator_traits<A>::value_type              value_type;
       typedef typename boost::container::
          allocator_traits<A>::void_pointer            void_pointer;
       typedef typename boost::container::
          allocator_traits<A>::size_type               size_type;
       typedef typename container_detail::rbtree_node
             <value_type, void_pointer>                node_type;
       typedef node_compare<ValueCompare, node_type>   node_compare_type;
       typedef typename container_detail::bi::make_rbtree
          <node_type
          ,container_detail::bi::compare<node_compare_type>
          ,container_detail::bi::base_hook<typename rbtree_hook<void_pointer>::type>
          ,container_detail::bi::constant_time_size<true>
          ,container_detail::bi::size_type<size_type>
          >::type                                      container_type;
       typedef container_type                          type ;
    };
    }  //namespace container_detail {
    
    namespace container_detail {
    template <class Key, class Value, class KeyOfValue,class KeyCompare, class A>
    class rbtree: protected container_detail::node_alloc_holder
          < A
          , typename container_detail::intrusive_rbtree_type
             <A, tree_value_compare<Key, Value, KeyCompare, KeyOfValue> 
             >::type
          , KeyCompare
          >
    {
       typedef typename container_detail::intrusive_rbtree_type
             < A, tree_value_compare
                <Key, Value, KeyCompare, KeyOfValue>
             >::type                                            Icont;
       typedef container_detail::node_alloc_holder<A, Icont, KeyCompare>   AllocHolder;
       typedef typename AllocHolder::NodePtr                    NodePtr;
       typedef rbtree < Key, Value, KeyOfValue, KeyCompare, A>  ThisType;
       typedef typename AllocHolder::NodeAlloc                  NodeAlloc;
       typedef typename AllocHolder::ValAlloc                   ValAlloc;
       typedef typename AllocHolder::Node                       Node;
       typedef typename Icont::iterator                         iiterator;
       typedef typename Icont::const_iterator                   iconst_iterator;
       typedef container_detail::allocator_destroyer<NodeAlloc> Destroyer;
       typedef typename AllocHolder::allocator_v1               allocator_v1;
       typedef typename AllocHolder::allocator_v2               allocator_v2;
       typedef typename AllocHolder::alloc_version              alloc_version;
    
       class RecyclingCloner;
       friend class RecyclingCloner;
    
       class RecyclingCloner
       {
          public:
          RecyclingCloner(AllocHolder &holder, Icont &irbtree)
             :  m_holder(holder), m_icont(irbtree)
          {}
    
          NodePtr operator()(const Node &other) const
          {
             if(NodePtr p = m_icont.unlink_leftmost_without_rebalance()){
                //First recycle a node (this can't throw)
                BOOST_TRY{
                   //This can throw
                   p->do_assign(other.m_data);
                   return p;
                }
                BOOST_CATCH(...){
                   //If there is an exception destroy the whole source
                   m_holder.destroy_node(p);
                   while((p = m_icont.unlink_leftmost_without_rebalance())){
                      m_holder.destroy_node(p);
                   }
                   BOOST_RETHROW
                }
                BOOST_CATCH_END
             }
             else{
                return m_holder.create_node(other.m_data);
             }
          }
    
          AllocHolder &m_holder;
          Icont &m_icont;
       };
       class RecyclingMoveCloner;
       friend class RecyclingMoveCloner;
       class RecyclingMoveCloner
       {
          public:
          RecyclingMoveCloner(AllocHolder &holder, Icont &irbtree):  m_holder(holder), m_icont(irbtree)
          {}
    
          NodePtr operator()(const Node &other) const
          {
             if(NodePtr p = m_icont.unlink_leftmost_without_rebalance()){
                //First recycle a node (this can't throw)
                BOOST_TRY{
                   //This can throw
                   p->do_move_assign(const_cast<Node &>(other).m_data);
                   return p;
                }
                BOOST_CATCH(...){
                   //If there is an exception destroy the whole source
                   m_holder.destroy_node(p);
                   while((p = m_icont.unlink_leftmost_without_rebalance())){
                      m_holder.destroy_node(p);
                   }
                   BOOST_RETHROW
                }
                BOOST_CATCH_END
             }
             else{
                return m_holder.create_node(other.m_data);
             }
          }
    
          AllocHolder &m_holder;
          Icont &m_icont;
       };
    
       BOOST_COPYABLE_AND_MOVABLE(rbtree)
    
       public:
       typedef Key                                        key_type;
       typedef Value                                      value_type;
       typedef A                                          allocator_type;
       typedef KeyCompare                                 key_compare;
       typedef tree_value_compare< Key, Value, KeyCompare, KeyOfValue>  value_compare;
       typedef typename boost::container::allocator_traits<A>::pointer     pointer;
       typedef typename boost::container::allocator_traits<A>::const_pointer   const_pointer;
       typedef typename boost::container::allocator_traits<A>::reference  reference;
       typedef typename boost::container::allocator_traits<A>::const_reference    const_reference;
       typedef typename boost::container::allocator_traits<A>::size_type           size_type;
       typedef typename boost::container::allocator_traits<A>::difference_type    difference_type;
       typedef difference_type                            rbtree_difference_type;
       typedef pointer                                    rbtree_pointer;
       typedef const_pointer                              rbtree_const_pointer;
       typedef reference                                  rbtree_reference;
       typedef const_reference                            rbtree_const_reference;
       typedef NodeAlloc                                  stored_allocator_type;
    
       private:
    
       template<class KeyValueCompare>
       struct key_node_compare:  private KeyValueCompare
       {
          key_node_compare(const KeyValueCompare &comp)
             :  KeyValueCompare(comp)
          {}
    
          template<class T>
          struct is_node
          {
             static const bool value = is_same<T, Node>::value;
          };
    
          template<class T>
          typename enable_if_c<is_node<T>::value, const value_type &>::type key_forward(const T &node) const
          {  return node.get_data();  }
    
          template<class T>
          typename enable_if_c<!is_node<T>::value, const T &>::type key_forward(const T &key) const
          {  return key; }
    
          template<class KeyType, class KeyType2>
          bool operator()(const KeyType &key1, const KeyType2 &key2) const
          {  return KeyValueCompare::operator()(this->key_forward(key1), this->key_forward(key2));  }
       };
    
       typedef key_node_compare<value_compare>  KeyNodeCompare;
    
       public:
       //rbtree const_iterator
       class const_iterator
          : public std::iterator
             < std::bidirectional_iterator_tag
             , value_type            , rbtree_difference_type
             , rbtree_const_pointer  , rbtree_const_reference>
       {
          protected:
          typedef typename Icont::iterator  iiterator;
          iiterator m_it;
          explicit const_iterator(iiterator it)  : m_it(it){}
          void prot_incr() { ++m_it; }
          void prot_decr() { --m_it; }
          private:
          iiterator get()
          {  return this->m_it;   }
    
          public:
          friend class rbtree <Key, Value, KeyOfValue, KeyCompare, A>;
          typedef rbtree_difference_type        difference_type;
    
          //Constructors
          const_iterator():  m_it()
          {}
    
          //Pointer like operators
          const_reference operator*()  const
          { return  m_it->get_data();  }
    
          const_pointer   operator->() const
          { return  const_pointer(&m_it->get_data()); }
    
          //Increment / Decrement
          const_iterator& operator++()      
          { prot_incr();  return *this; }
    
          const_iterator operator++(int)     
          { iiterator tmp = m_it; ++*this; return const_iterator(tmp);  }
    
          const_iterator& operator--()
          {   prot_decr(); return *this;   }
    
          const_iterator operator--(int)
          {  iiterator tmp = m_it; --*this; return const_iterator(tmp); }
    
          //Comparison operators
          bool operator==   (const const_iterator& r)  const
          {  return m_it == r.m_it;  }
    
          bool operator!=   (const const_iterator& r)  const
          {  return m_it != r.m_it;  }
       };
    
       //rbtree iterator
       class iterator : public const_iterator
       {
          private:
          explicit iterator(iiterator it)
             :  const_iterator(it)
          {}  
          iiterator get()
          {  return this->m_it;   }
          public:
          friend class rbtree <Key, Value, KeyOfValue, KeyCompare, A>;
          typedef rbtree_pointer       pointer;
          typedef rbtree_reference     reference;
          //Constructors
          iterator(){}
          //Pointer like operators
          reference operator*()  const  {  return this->m_it->get_data();  }
          pointer   operator->() const
             {  return boost::intrusive::pointer_traits<pointer>::pointer_to(this->m_it->get_data());  }
          //Increment / Decrement
          iterator& operator++(){ this->prot_incr(); return *this;  }
    
          iterator operator++(int){ iiterator tmp = this->m_it; ++*this; return iterator(tmp); }
         
          iterator& operator--(){  this->prot_decr(); return *this;  }
    
          iterator operator--(int){  iterator tmp = *this; --*this; return tmp; }
       };
    
       typedef std::reverse_iterator<iterator>        reverse_iterator;
       typedef std::reverse_iterator<const_iterator>  const_reverse_iterator;
    
       rbtree(): AllocHolder(key_compare())
       {}
    
       rbtree(const key_compare& comp, const allocator_type& a = allocator_type()): AllocHolder(a, comp)
       {}
    
       template <class InputIterator>
       rbtree(bool unique_insertion, InputIterator first, InputIterator last, const key_compare& comp,
              const allocator_type& a
          #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
          , typename container_detail::enable_if_c
             < container_detail::is_input_iterator<InputIterator>::value
                || container_detail::is_same<alloc_version, allocator_v1>::value
             >::type * = 0
          #endif
             )
          : AllocHolder(a, comp)
       {
          if(unique_insertion){
             this->insert_unique(first, last);
          }
          else{
             this->insert_equal(first, last);
          }
       }
       template <class InputIterator>
       rbtree(bool unique_insertion, InputIterator first, InputIterator last, const key_compare& comp,
              const allocator_type& a
          #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
          , typename container_detail::enable_if_c
             < !(container_detail::is_input_iterator<InputIterator>::value
                || container_detail::is_same<alloc_version, allocator_v1>::value)
             >::type * = 0
          #endif
             )
          : AllocHolder(a, comp)
       {
          if(unique_insertion){
             this->insert_unique(first, last);
          }
          else{
             //Optimized allocation and construction
             this->allocate_many_and_construct
                (first, std::distance(first, last), insert_equal_end_hint_functor(this->icont()));
          }
       }
    
       template <class InputIterator>
       rbtree( ordered_range_t, InputIterator first, InputIterator last
             , const key_compare& comp = key_compare(), const allocator_type& a = allocator_type()
             #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
             , typename container_detail::enable_if_c
                < container_detail::is_input_iterator<InputIterator>::value
                   || container_detail::is_same<alloc_version, allocator_v1>::value
                >::type * = 0
             #endif
             )
          : AllocHolder(a, comp)
       {
          this->insert_equal(first, last);
       }
    
       template <class InputIterator>
       rbtree( ordered_range_t, InputIterator first, InputIterator last
             , const key_compare& comp = key_compare(), const allocator_type& a = allocator_type()
             #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
             , typename container_detail::enable_if_c
                < !(container_detail::is_input_iterator<InputIterator>::value
                   || container_detail::is_same<alloc_version, allocator_v1>::value)
                >::type * = 0
             #endif
             )
          : AllocHolder(a, comp)
       {
          //Optimized allocation and construction
          this->allocate_many_and_construct(first, std::distance(first, last), push_back_functor(this->icont()));
       }
    
       rbtree(const rbtree& x):AllocHolder(x, x.key_comp())
       {
          this->icont().clone_from(x.icont(), typename AllocHolder::cloner(*this), Destroyer(this->node_alloc()));
       }
    
       rbtree(BOOST_RV_REF(rbtree) x):AllocHolder(::boost::move(static_cast<AllocHolder&>(x)), x.key_comp())
       {}
    
       rbtree(const rbtree& x, const allocator_type &a):  AllocHolder(a, x.key_comp())
       {
          this->icont().clone_from(x.icont(), typename AllocHolder::cloner(*this), Destroyer(this->node_alloc()));
       }
    
       rbtree(BOOST_RV_REF(rbtree) x, const allocator_type &a):  AllocHolder(a, x.key_comp())
       {
          if(this->node_alloc() == x.node_alloc()){
             this->icont().swap(x.icont());
          }
          else{
             this->icont().clone_from
                (x.icont(), typename AllocHolder::cloner(*this), Destroyer(this->node_alloc()));
          }
       }
    
       ~rbtree()
       {} //AllocHolder clears the tree
    
       rbtree& operator=(BOOST_COPY_ASSIGN_REF(rbtree) x)
       {
          if (&x != this){
             NodeAlloc &this_alloc     = this->get_stored_allocator();
             const NodeAlloc &x_alloc  = x.get_stored_allocator();
             container_detail::bool_<allocator_traits<NodeAlloc>::
                propagate_on_container_copy_assignment::value> flag;
             if(flag && this_alloc != x_alloc){
                this->clear();
             }
             this->AllocHolder::copy_assign_alloc(x);
             //Transfer all the nodes to a temporary tree
             //If anything goes wrong, all the nodes will be destroyed
             //automatically
             Icont other_tree(::boost::move(this->icont()));
    
             //Now recreate the source tree reusing nodes stored by other_tree
             this->icont().clone_from
                (x.icont()
                , RecyclingCloner(*this, other_tree)
                , Destroyer(this->node_alloc()));
    
             //If there are remaining nodes, destroy them
             NodePtr p;
             while((p = other_tree.unlink_leftmost_without_rebalance())){
                AllocHolder::destroy_node(p);
             }
          }
          return *this;
       }
    
       rbtree& operator=(BOOST_RV_REF(rbtree) x)
       {
          if (&x != this){
             NodeAlloc &this_alloc = this->node_alloc();
             NodeAlloc &x_alloc    = x.node_alloc();
             //If allocators are equal we can just swap pointers
             if(this_alloc == x_alloc){
                //Destroy and swap pointers
                this->clear();
                this->icont() = ::boost::move(x.icont());
                //Move allocator if needed
                this->AllocHolder::move_assign_alloc(x);
             }
             //If unequal allocators, then do a one by one move
             else{
                //Transfer all the nodes to a temporary tree
                //If anything goes wrong, all the nodes will be destroyed
                //automatically
                Icont other_tree(::boost::move(this->icont()));
    
                //Now recreate the source tree reusing nodes stored by other_tree
                this->icont().clone_from
                   (x.icont()
                   , RecyclingMoveCloner(*this, other_tree)
                   , Destroyer(this->node_alloc()));
    
                //If there are remaining nodes, destroy them
                NodePtr p;
                while((p = other_tree.unlink_leftmost_without_rebalance())){
                   AllocHolder::destroy_node(p);
                }
             }
          }
          return *this;
       }
    
       public:   
       // accessors:
       value_compare value_comp() const
       {  return this->icont().value_comp().value_comp(); }
       key_compare key_comp() const
       {  return this->icont().value_comp().value_comp().key_comp(); }
       allocator_type get_allocator() const
       {  return allocator_type(this->node_alloc()); }
       const stored_allocator_type &get_stored_allocator() const
       {  return this->node_alloc(); }
       stored_allocator_type &get_stored_allocator()
       {  return this->node_alloc(); }
       iterator begin()
       { return iterator(this->icont().begin()); }
       const_iterator begin() const
       {  return this->cbegin();  }
       iterator end()
       {  return iterator(this->icont().end());  }
       const_iterator end() const
       {  return this->cend();  }
       reverse_iterator rbegin()
       {  return reverse_iterator(end());  }
       const_reverse_iterator rbegin() const
       {  return this->crbegin();  }
       reverse_iterator rend()
       {  return reverse_iterator(begin());   }
       const_reverse_iterator rend() const
       {  return this->crend();   }
       const_iterator cbegin() const
       { return const_iterator(this->non_const_icont().begin()); }
       const_iterator cend() const
       { return const_iterator(this->non_const_icont().end()); }
       const_reverse_iterator crbegin() const
       { return const_reverse_iterator(cend()); }
       const_reverse_iterator crend() const
       { return const_reverse_iterator(cbegin()); }
       bool empty() const
       {  return !this->size();  }
       size_type size() const
       {  return this->icont().size();   }
       size_type max_size() const
       {  return AllocHolder::max_size();  }
       void swap(ThisType& x)
       {  AllocHolder::swap(x);   }
    
       public:
       typedef typename Icont::insert_commit_data insert_commit_data;
       // insert/erase
       std::pair<iterator,bool> insert_unique_check
          (const key_type& key, insert_commit_data &data)
       {
          std::pair<iiterator, bool> ret =
             this->icont().insert_unique_check(key, KeyNodeCompare(value_comp()), data);
          return std::pair<iterator, bool>(iterator(ret.first), ret.second);
       }
       std::pair<iterator,bool> insert_unique_check
          (const_iterator hint, const key_type& key, insert_commit_data &data)
       {
          std::pair<iiterator, bool> ret =
             this->icont().insert_unique_check(hint.get(), key, KeyNodeCompare(value_comp()), data);
          return std::pair<iterator, bool>(iterator(ret.first), ret.second);
       }
       iterator insert_unique_commit(const value_type& v, insert_commit_data &data)
       {
          NodePtr tmp = AllocHolder::create_node(v);
          iiterator it(this->icont().insert_unique_commit(*tmp, data));
          return iterator(it);
       }
       template<class MovableConvertible>
       iterator insert_unique_commit
          (BOOST_FWD_REF(MovableConvertible) mv, insert_commit_data &data)
       {
          NodePtr tmp = AllocHolder::create_node(boost::forward<MovableConvertible>(mv));
          iiterator it(this->icont().insert_unique_commit(*tmp, data));
          return iterator(it);
       }
       std::pair<iterator,bool> insert_unique(const value_type& v)
       {
          insert_commit_data data;
          std::pair<iterator,bool> ret =
             this->insert_unique_check(KeyOfValue()(v), data);
          if(!ret.second)
             return ret;
          return std::pair<iterator,bool>
             (this->insert_unique_commit(v, data), true);
       }
       template<class MovableConvertible>
       std::pair<iterator,bool> insert_unique(BOOST_FWD_REF(MovableConvertible) mv)
       {
          insert_commit_data data;
          std::pair<iterator,bool> ret =
             this->insert_unique_check(KeyOfValue()(mv), data);
          if(!ret.second)
             return ret;
          return std::pair<iterator,bool>
             (this->insert_unique_commit(boost::forward<MovableConvertible>(mv), data), true);
       }
       private:
       std::pair<iterator, bool> emplace_unique_impl(NodePtr p)
       {
          value_type &v = p->get_data();
          insert_commit_data data;
          scoped_destroy_deallocator<NodeAlloc> destroy_deallocator(p, this->node_alloc());
          std::pair<iterator,bool> ret =
             this->insert_unique_check(KeyOfValue()(v), data);
          if(!ret.second){
             return ret;
          }
          //No throw insertion part, release rollback
          destroy_deallocator.release();
          return std::pair<iterator,bool>
             ( iterator(iiterator(this->icont().insert_unique_commit(*p, data)))
             , true );
       }
       iterator emplace_unique_hint_impl(const_iterator hint, NodePtr p)
       {
          value_type &v = p->get_data();
          insert_commit_data data;
          std::pair<iterator,bool> ret =
             this->insert_unique_check(hint, KeyOfValue()(v), data);
          if(!ret.second){
             Destroyer(this->node_alloc())(p);
             return ret.first;
          }
          return iterator(iiterator(this->icont().insert_unique_commit(*p, data)));
       }
       public:
       #ifdef BOOST_CONTAINER_PERFECT_FORWARDING
       template <class... Args>
       std::pair<iterator, bool> emplace_unique(Args&&... args)
       {  return this->emplace_unique_impl(AllocHolder::create_node(boost::forward<Args>(args)...));   }
    
       template <class... Args>
       iterator emplace_hint_unique(const_iterator hint, Args&&... args)
       {  return this->emplace_unique_hint_impl(hint, AllocHolder::create_node(boost::forward<Args>(args)...));   }
    
       template <class... Args>
       iterator emplace_equal(Args&&... args)
       {
          NodePtr p(AllocHolder::create_node(boost::forward<Args>(args)...));
          return iterator(this->icont().insert_equal(this->icont().end(), *p));
       }
    
       template <class... Args>
       iterator emplace_hint_equal(const_iterator hint, Args&&... args)
       {
          NodePtr p(AllocHolder::create_node(boost::forward<Args>(args)...));
          return iterator(this->icont().insert_equal(hint.get(), *p));
       }
    
       #else //#ifdef BOOST_CONTAINER_PERFECT_FORWARDING
    
       #define BOOST_PP_LOCAL_MACRO(n)                                                                          
       BOOST_PP_EXPR_IF(n, template<) BOOST_PP_ENUM_PARAMS(n, class P) BOOST_PP_EXPR_IF(n, >)                   
       std::pair<iterator, bool> emplace_unique(BOOST_PP_ENUM(n, BOOST_CONTAINER_PP_PARAM_LIST, _))             
       {                                                                                                        
          return this->emplace_unique_impl                                                                      
             (AllocHolder::create_node(BOOST_PP_ENUM(n, BOOST_CONTAINER_PP_PARAM_FORWARD, _)));                 
       }                                                                                                        
                                                                                                                
       BOOST_PP_EXPR_IF(n, template<) BOOST_PP_ENUM_PARAMS(n, class P) BOOST_PP_EXPR_IF(n, >)                   
       iterator emplace_hint_unique(const_iterator hint                                                         
                           BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_PARAM_LIST, _))                         
       {                                                                                                        
          return this->emplace_unique_hint_impl                                                                 
             (hint, AllocHolder::create_node(BOOST_PP_ENUM(n, BOOST_CONTAINER_PP_PARAM_FORWARD, _)));           
       }                                                                                                        
                                                                                                                
       BOOST_PP_EXPR_IF(n, template<) BOOST_PP_ENUM_PARAMS(n, class P) BOOST_PP_EXPR_IF(n, >)                   
       iterator emplace_equal(BOOST_PP_ENUM(n, BOOST_CONTAINER_PP_PARAM_LIST, _))                               
       {                                                                                                        
          NodePtr p(AllocHolder::create_node(BOOST_PP_ENUM(n, BOOST_CONTAINER_PP_PARAM_FORWARD, _)));           
          return iterator(this->icont().insert_equal(this->icont().end(), *p));                                 
       }                                                                                                        
                                                                                                                
       BOOST_PP_EXPR_IF(n, template<) BOOST_PP_ENUM_PARAMS(n, class P) BOOST_PP_EXPR_IF(n, >)                   
       iterator emplace_hint_equal(const_iterator hint                                                          
                           BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_PARAM_LIST, _))                         
       {                                                                                                        
          NodePtr p(AllocHolder::create_node(BOOST_PP_ENUM(n, BOOST_CONTAINER_PP_PARAM_FORWARD, _)));           
          return iterator(this->icont().insert_equal(hint.get(), *p));                                          
       }                                                                                                        
       //!
       #define BOOST_PP_LOCAL_LIMITS (0, BOOST_CONTAINER_MAX_CONSTRUCTOR_PARAMETERS)
       #include BOOST_PP_LOCAL_ITERATE()
    
       #endif   //#ifdef BOOST_CONTAINER_PERFECT_FORWARDING
    
       iterator insert_unique(const_iterator hint, const value_type& v)
       {
          insert_commit_data data;
          std::pair<iterator,bool> ret = this->insert_unique_check(hint, KeyOfValue()(v), data);
          if(!ret.second)
             return ret.first;
          return this->insert_unique_commit(v, data);
       }
    
       template<class MovableConvertible>
       iterator insert_unique(const_iterator hint, BOOST_FWD_REF(MovableConvertible) mv)
       {
          insert_commit_data data;
          std::pair<iterator,bool> ret =
             this->insert_unique_check(hint, KeyOfValue()(mv), data);
          if(!ret.second)
             return ret.first;
          return this->insert_unique_commit(boost::forward<MovableConvertible>(mv), data);
       }
    
       template <class InputIterator>
       void insert_unique(InputIterator first, InputIterator last)
       {
          if(this->empty()){
             //Insert with end hint, to achieve linear
             //complexity if [first, last) is ordered
             const_iterator hint(this->cend());
             for( ; first != last; ++first)
                hint = this->insert_unique(hint, *first);
          }
          else{
             for( ; first != last; ++first)
                this->insert_unique(*first);
          }
       }
    
       iterator insert_equal(const value_type& v)
       {
          NodePtr p(AllocHolder::create_node(v));
          return iterator(this->icont().insert_equal(this->icont().end(), *p));
       }
    
       template<class MovableConvertible>
       iterator insert_equal(BOOST_FWD_REF(MovableConvertible) mv)
       {
          NodePtr p(AllocHolder::create_node(boost::forward<MovableConvertible>(mv)));
          return iterator(this->icont().insert_equal(this->icont().end(), *p));
       }
    
       iterator insert_equal(const_iterator hint, const value_type& v)
       {
          NodePtr p(AllocHolder::create_node(v));
          return iterator(this->icont().insert_equal(hint.get(), *p));
       }
    
       template<class MovableConvertible>
       iterator insert_equal(const_iterator hint, BOOST_FWD_REF(MovableConvertible) mv)
       {
          NodePtr p(AllocHolder::create_node(boost::forward<MovableConvertible>(mv)));
          return iterator(this->icont().insert_equal(hint.get(), *p));
       }
    
       template <class InputIterator>
       void insert_equal(InputIterator first, InputIterator last)
       {
          //Insert with end hint, to achieve linear
          //complexity if [first, last) is ordered
          const_iterator hint(this->cend());
          for( ; first != last; ++first)
             hint = this->insert_equal(hint, *first);
       }
    
       iterator erase(const_iterator position)
       {  return iterator(this->icont().erase_and_dispose(position.get(), Destroyer(this->node_alloc()))); }
    
       size_type erase(const key_type& k)
       {  return AllocHolder::erase_key(k, KeyNodeCompare(value_comp()), alloc_version()); }
    
       iterator erase(const_iterator first, const_iterator last)
       {  return iterator(AllocHolder::erase_range(first.get(), last.get(), alloc_version())); }
    
       void clear()
       {  AllocHolder::clear(alloc_version());  }
    
       // set operations:
       iterator find(const key_type& k)
       {  return iterator(this->icont().find(k, KeyNodeCompare(value_comp())));  }
    
       const_iterator find(const key_type& k) const
       {  return const_iterator(this->non_const_icont().find(k, KeyNodeCompare(value_comp())));  }
    
       size_type count(const key_type& k) const
       {  return size_type(this->icont().count(k, KeyNodeCompare(value_comp()))); }
    
       iterator lower_bound(const key_type& k)
       {  return iterator(this->icont().lower_bound(k, KeyNodeCompare(value_comp())));  }
    
       const_iterator lower_bound(const key_type& k) const
       {  return const_iterator(this->non_const_icont().lower_bound(k, KeyNodeCompare(value_comp())));  }
    
       iterator upper_bound(const key_type& k)
       {  return iterator(this->icont().upper_bound(k, KeyNodeCompare(value_comp())));   }
    
       const_iterator upper_bound(const key_type& k) const
       {  return const_iterator(this->non_const_icont().upper_bound(k, KeyNodeCompare(value_comp())));  }
    
       std::pair<iterator,iterator> equal_range(const key_type& k)
       {
          std::pair<iiterator, iiterator> ret =
             this->icont().equal_range(k, KeyNodeCompare(value_comp()));
          return std::pair<iterator,iterator>(iterator(ret.first), iterator(ret.second));
       }
    
       std::pair<const_iterator, const_iterator> equal_range(const key_type& k) const
       {
          std::pair<iiterator, iiterator> ret =
             this->non_const_icont().equal_range(k, KeyNodeCompare(value_comp()));
          return std::pair<const_iterator,const_iterator>
             (const_iterator(ret.first), const_iterator(ret.second));
       }
    
       private:
       class insert_equal_end_hint_functor;
       friend class insert_equal_end_hint_functor;
       class insert_equal_end_hint_functor
       {
          Icont &icont_;
          const iconst_iterator cend_;
    
          public:
          insert_equal_end_hint_functor(Icont &icont)
             :  icont_(icont), cend_(this->icont_.cend())
          {}
    
          void operator()(Node &n)
          {  this->icont_.insert_equal(cend_, n); }
       };
    
       class push_back_functor;
       friend class push_back_functor;
    
       class push_back_functor
       {
          Icont &icont_;
    
          public:
          push_back_functor(Icont &icont)
             :  icont_(icont)
          {}
    
          void operator()(Node &n)
          {  this->icont_.push_back(n); }
       };
    };
    
    template <class Key, class Value, class KeyOfValue,
              class KeyCompare, class A>
    inline bool operator==(const rbtree<Key,Value,KeyOfValue,KeyCompare,A>& x,
               const rbtree<Key,Value,KeyOfValue,KeyCompare,A>& y)
    {
      return x.size() == y.size() && std::equal(x.begin(), x.end(), y.begin());
    }
    
    template <class Key, class Value, class KeyOfValue,
              class KeyCompare, class A>
    inline bool operator<(const rbtree<Key,Value,KeyOfValue,KeyCompare,A>& x,
              const rbtree<Key,Value,KeyOfValue,KeyCompare,A>& y)
    {
      return std::lexicographical_compare(x.begin(), x.end(),
                                          y.begin(), y.end());
    }
    
    template <class Key, class Value, class KeyOfValue,
              class KeyCompare, class A>
    inline bool operator!=(const rbtree<Key,Value,KeyOfValue,KeyCompare,A>& x,
               const rbtree<Key,Value,KeyOfValue,KeyCompare,A>& y)
    {
      return !(x == y);
    }
    
    template <class Key, class Value, class KeyOfValue,
              class KeyCompare, class A>
    inline bool operator>(const rbtree<Key,Value,KeyOfValue,KeyCompare,A>& x,
              const rbtree<Key,Value,KeyOfValue,KeyCompare,A>& y) 
    {
      return y < x;
    }
    
    template <class Key, class Value, class KeyOfValue,
              class KeyCompare, class A>
    inline bool operator<=(const rbtree<Key,Value,KeyOfValue,KeyCompare,A>& x,
               const rbtree<Key,Value,KeyOfValue,KeyCompare,A>& y) 
    {
      return !(y < x);
    }
    
    template <class Key, class Value, class KeyOfValue,
              class KeyCompare, class A>
    inline bool operator>=(const rbtree<Key,Value,KeyOfValue,KeyCompare,A>& x,
               const rbtree<Key,Value,KeyOfValue,KeyCompare,A>& y) 
    {
      return !(x < y);
    }
    
    
    template <class Key, class Value, class KeyOfValue,
              class KeyCompare, class A>
    inline void swap(rbtree<Key,Value,KeyOfValue,KeyCompare,A>& x,
         rbtree<Key,Value,KeyOfValue,KeyCompare,A>& y)
    {
      x.swap(y);
    }
    
    } //namespace container_detail {
    } //namespace container {
    /*
    //!has_trivial_destructor_after_move<> == true_type
    //!specialization for optimizations
    template <class K, class V, class KOV,
    class C, class A>
    struct has_trivial_destructor_after_move
       <boost::container::container_detail::rbtree<K, V, KOV, C, A> >
    {
       static const bool value = has_trivial_destructor_after_move<A>::value && has_trivial_destructor_after_move<C>::value;
    };
    */
    } //namespace boost  {
    
    #include <boost/container/detail/config_end.hpp>
    
    #endif //BOOST_CONTAINER_TREE_HPP

    二叉树的意思是：任何节点最多只能有两个子节点的树。二叉搜索树可提供log(N)的元素插入和访问，它的节点旋转规则是：任何节点的键值一定大于其左子节点树中的每个节点的键值，并小于其右子树中的每个节点的键值。因此，从树节点一直往左走到底，即得最小元素；从根节点一直往右走到底，却得最大元素。但是，由于插入值无规律，二叉搜索树可能失去平衡，造成搜索效率低落的情况。解决办法就是尽量使树形左右“平衡”，对于何为“平衡”，没有一个绝对的定义，大致的意思就是“没有一个节点过深”。常见的平衡二叉树有AVL-tree, RB-tree, AA-tree，它们都比上面说的一般二叉树复杂，插入节点和删除节点时要做一些额外操作来维护树形平衡，但是它们可以避免极难应付的极不平衡的情况，而且由于它们总是保持某种程度的平衡，所以元素访问时间平均而言就比较少。

SGI STL实现的搜索树是RB-tree，它在一般二叉树的基础上增加了以下必须满足的条件：

• 每个节点不是红色就是黑色；
• 根节点为黑色；
• 如果节点为红，其子节点必须为黑，如果节点为黑，则随意；
• 任一节点到树尾端的任何路径（比如从根节点到任意一个叶节点），所含的黑节点数量必须相同。

根据规则４，新增节点必须为红色；根据规则３，新增节点的父节点必须为黑。当新节点根据一般二叉树搜索规则到达其插入点，却未能符合上述条件时，就必须调整节点颜色和旋转树形。注意经过调整后，叶节点可能为黑色。

Associative Container->Simple Associative Container

1. A simple Associative Container is an Associative Container where elements are their own keys. A key in a Simple Associative Container is not associated with any additional value.
2. Immutability of element: Every element of a Simple Associative Container is immutable. Objects may be inserted and erased, but not modified.
3. Models: set; multiset; hash_set; hash_multiset;
4. This is a consequence of the Immutability of Keys invariant of Associative Container. Keys may never be modified; values in a Simple Associative Container are themselves keys, so it immediately follows that values in a Simple Associative Container may not be modified.
5. template <class _Key, class _Value, class _KeyOfValue, class _Compare, class _Alloc = _BP_STL_DEFAULT_ALLOCATOR(_Value) >76. class _Rb_tree : protected _Rb_tree_base<_Value, _Alloc> 
6. With concept of composition, template class _Rb_tree is regarded as a type of a member within template class set or hash_set and so on.

7. //! A set is a kind of associative container that supports unique keys (contains at
   //! most one of each key value) and provides for fast retrieval of the keys themselves.
   //! Class set supports bidirectional iterators.
   //! A set satisfies all of the requirements of a container and of a reversible container,and of an associative container. A set also provides most operations described in
   //! for unique keys.
   #ifdef BOOST_CONTAINER_DOXYGEN_INVOKED
   template <class Key, class Compare = std::less<Key>, class Allocator = std::allocator<Key> >
   #else
   template <class Key, class Compare, class Allocator>
   #endif
   class set
   {
      private:
      BOOST_COPYABLE_AND_MOVABLE(set)
      typedef container_detail::rbtree<Key, Key,
                        container_detail::identity<Key>, Compare, Allocator> tree_t;
      tree_t m_tree;  // red-black tree representing set
      public:
      typedef Key                                                                         key_type;
      typedef Key                                                                         value_type;
      typedef Compare                                                                     key_compare;
      typedef Compare                                                                     value_compare;
      typedef typename ::boost::container::allocator_traits<Allocator>::pointer           pointer;
      typedef typename ::boost::container::allocator_traits<Allocator>::const_pointer     const_pointer;
      typedef typename ::boost::container::allocator_traits<Allocator>::reference         reference;
      typedef typename ::boost::container::allocator_traits<Allocator>::const_reference   const_reference;
      typedef typename ::boost::container::allocator_traits<Allocator>::size_type         size_type;
      typedef typename ::boost::container::allocator_traits<Allocator>::difference_type   difference_type;
      typedef Allocator                                                                   allocator_type;
      typedef typename BOOST_CONTAINER_IMPDEF(tree_t::stored_allocator_type)              stored_allocator_type;
      typedef typename BOOST_CONTAINER_IMPDEF(tree_t::iterator)                           iterator;
      typedef typename BOOST_CONTAINER_IMPDEF(tree_t::const_iterator)                     const_iterator;
      typedef typename BOOST_CONTAINER_IMPDEF(tree_t::reverse_iterator)                   reverse_iterator;
      typedef typename BOOST_CONTAINER_IMPDEF(tree_t::const_reverse_iterator)             const_reverse_iterator;
      set(): m_tree(){}
      explicit set(const Compare& comp,const allocator_type& a = allocator_type()): m_tree(comp, a){}
   
      template <class InputIterator>
      set(InputIterator first, InputIterator last, const Compare& comp = Compare(),
          const allocator_type& a = allocator_type()): m_tree(true, first, last, comp, a)
      {}
      template <class InputIterator>
      set( ordered_unique_range_t, InputIterator first, InputIterator last
         , const Compare& comp = Compare(), const allocator_type& a = allocator_type())
         : m_tree(ordered_range, first, last, comp, a)
      {}
      set(const set& x): m_tree(x.m_tree)
      {}
      set(BOOST_RV_REF(set) x): m_tree(boost::move(x.m_tree))
      {}  
      set(const set& x, const allocator_type &a): m_tree(x.m_tree, a)
      {}
      set(BOOST_RV_REF(set) x, const allocator_type &a): m_tree(boost::move(x.m_tree), a)
      {}
      set& operator=(BOOST_COPY_ASSIGN_REF(set) x)
      {  
         m_tree = x.m_tree;   return *this;  
      }
      set& operator=(BOOST_RV_REF(set) x)
      {  
         m_tree = boost::move(x.m_tree);   return *this;  
      }
      allocator_type get_allocator() const
      { 
         return m_tree.get_allocator(); 
      }
      const stored_allocator_type &get_stored_allocator() const
      { 
         return m_tree.get_stored_allocator(); 
      }
      stored_allocator_type &get_stored_allocator()
      { return m_tree.get_stored_allocator(); }
   
      iterator begin()
      { return m_tree.begin(); }
   
      const_iterator begin() const
      { return m_tree.begin(); }
   
      iterator end()
      { return m_tree.end(); }
   
      const_iterator end() const
      { return m_tree.end(); }
   
      reverse_iterator rbegin()
      { return m_tree.rbegin(); }
   
      const_reverse_iterator rbegin() const
      { return m_tree.rbegin(); }
   
      reverse_iterator rend()
      { return m_tree.rend(); }
   
      const_reverse_iterator rend() const
      { return m_tree.rend(); }
   
      const_iterator cbegin() const
      { return m_tree.cbegin(); }
   
      const_iterator cend() const
      { return m_tree.cend(); }
   
      const_reverse_iterator crbegin() const
      { return m_tree.crbegin(); }
   
      const_reverse_iterator crend() const
      { return m_tree.crend(); }
   
      bool empty() const
      { return m_tree.empty(); }
   
      size_type size() const
      { return m_tree.size(); }
   
      size_type max_size() const
      { return m_tree.max_size(); }
   
      #if defined(BOOST_CONTAINER_PERFECT_FORWARDING) || defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
   
      template <class... Args>
      std::pair<iterator,bool> emplace(Args&&... args)
      {  return m_tree.emplace_unique(boost::forward<Args>(args)...); }
   
      template <class... Args>
      iterator emplace_hint(const_iterator hint, Args&&... args)
      {  return m_tree.emplace_hint_unique(hint, boost::forward<Args>(args)...); }
   
      #else //#ifdef BOOST_CONTAINER_PERFECT_FORWARDING
   
      #define BOOST_PP_LOCAL_MACRO(n)                                                                 
      BOOST_PP_EXPR_IF(n, template<) BOOST_PP_ENUM_PARAMS(n, class P) BOOST_PP_EXPR_IF(n, >)          
      std::pair<iterator,bool> emplace(BOOST_PP_ENUM(n, BOOST_CONTAINER_PP_PARAM_LIST, _))            
      {  return m_tree.emplace_unique(BOOST_PP_ENUM(n, BOOST_CONTAINER_PP_PARAM_FORWARD, _)); }       
                                                                                                      
      BOOST_PP_EXPR_IF(n, template<) BOOST_PP_ENUM_PARAMS(n, class P) BOOST_PP_EXPR_IF(n, >)          
      iterator emplace_hint(const_iterator hint                                                       
                            BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_PARAM_LIST, _))              
      {  return m_tree.emplace_hint_unique(hint                                                       
                                  BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_PARAM_FORWARD, _));}   
      //!
      #define BOOST_PP_LOCAL_LIMITS (0, BOOST_CONTAINER_MAX_CONSTRUCTOR_PARAMETERS)
      #include BOOST_PP_LOCAL_ITERATE()
      #endif   //#ifdef BOOST_CONTAINER_PERFECT_FORWARDING
      #if defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
    
      std::pair<iterator, bool> insert(const value_type &x);
   
      std::pair<iterator, bool> insert(value_type &&x);
      #else
      private:
      typedef std::pair<iterator, bool> insert_return_pair;
      public:
      BOOST_MOVE_CONVERSION_AWARE_CATCH(insert, value_type, insert_return_pair, this->priv_insert)
      #endif
   
      #if defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
      iterator insert(const_iterator p, const value_type &x);
      iterator insert(const_iterator position, value_type &&x);
      #else
      BOOST_MOVE_CONVERSION_AWARE_CATCH_1ARG(insert, value_type, iterator, this->priv_insert, const_iterator)
      #endif
   
      template <class InputIterator>
      void insert(InputIterator first, InputIterator last)
      {  m_tree.insert_unique(first, last);  }
   
      iterator erase(const_iterator p)
      {  return m_tree.erase(p); }
   
      size_type erase(const key_type& x)
      {  return m_tree.erase(x); }
   
      iterator erase(const_iterator first, const_iterator last)
      {  return m_tree.erase(first, last);  }
   
      void swap(set& x)
      { m_tree.swap(x.m_tree); }
   
      void clear()
      { m_tree.clear(); }
   
      key_compare key_comp() const
      { return m_tree.key_comp(); }
   
      value_compare value_comp() const
      { return m_tree.key_comp(); }
   
      iterator find(const key_type& x)
      { return m_tree.find(x); }
   
      const_iterator find(const key_type& x) const
      { return m_tree.find(x); }
   
      size_type count(const key_type& x) const
      {  return m_tree.find(x) == m_tree.end() ? 0 : 1;  }
   
      iterator lower_bound(const key_type& x)
      {  return m_tree.lower_bound(x); }
   
      const_iterator lower_bound(const key_type& x) const
      {  return m_tree.lower_bound(x); }
    
      iterator upper_bound(const key_type& x)
      {  return m_tree.upper_bound(x);    }
   
      const_iterator upper_bound(const key_type& x) const
      {  return m_tree.upper_bound(x);    }
   
      std::pair<iterator,iterator> equal_range(const key_type& x)
      {  return m_tree.equal_range(x); }
   
      std::pair<const_iterator, const_iterator> equal_range(const key_type& x) const
      {  return m_tree.equal_range(x); }
   
      /// @cond
      template <class K1, class C1, class A1>
      friend bool operator== (const set<K1,C1,A1>&, const set<K1,C1,A1>&);
   
      template <class K1, class C1, class A1>
      friend bool operator< (const set<K1,C1,A1>&, const set<K1,C1,A1>&);
   
      private:
      template <class KeyType>
      std::pair<iterator, bool> priv_insert(BOOST_FWD_REF(KeyType) x)
      {  return m_tree.insert_unique(::boost::forward<KeyType>(x));  }
   
      template <class KeyType>
      iterator priv_insert(const_iterator p, BOOST_FWD_REF(KeyType) x)
      {  return m_tree.insert_unique(p, ::boost::forward<KeyType>(x)); }
      /// @endcond
   };
   template <class Key, class Compare, class Allocator>
   inline bool operator==(const set<Key,Compare,Allocator>& x,const set<Key,Compare,Allocator>& y)
   {  return x.m_tree == y.m_tree;  }
   template <class Key, class Compare, class Allocator>
   inline bool operator<(const set<Key,Compare,Allocator>& x,const set<Key,Compare,Allocator>& y)
   {  return x.m_tree < y.m_tree;   }
   template <class Key, class Compare, class Allocator>
   inline bool operator!=(const set<Key,Compare,Allocator>& x,const set<Key,Compare,Allocator>& y)
   {  return !(x == y);   }
   template <class Key, class Compare, class Allocator>
   inline bool operator>(const set<Key,Compare,Allocator>& x,const set<Key,Compare,Allocator>& y)
   {  return y < x; }
   template <class Key, class Compare, class Allocator>
   inline bool operator<=(const set<Key,Compare,Allocator>& x,const set<Key,Compare,Allocator>& y)
   {  return !(y < x); }
   template <class Key, class Compare, class Allocator>
   inline bool operator>=(const set<Key,Compare,Allocator>& x,const set<Key,Compare,Allocator>& y)
   {  return !(x < y);  }
   template <class Key, class Compare, class Allocator>
   inline void swap(set<Key,Compare,Allocator>& x, set<Key,Compare,Allocator>& y)
   {  x.swap(y);  }
   /// @cond
   
   } 
   template <class Key, class C, class Allocator>
   struct has_trivial_destructor_after_move<boost::container::set<Key, C, Allocator> >
   {
      static const bool value = has_trivial_destructor_after_move<Allocator>::value && has_trivial_destructor_after_move<C>::value;
   };

   //! A multiset is a kind of associative container that supports equivalent keys
   //! (possibly contains multiple copies of the same key value) and provides for
   //! fast retrieval of the keys themselves. Class multiset supports bidirectional iterators.
   //!
   //! A multiset satisfies all of the requirements of a container and of a reversible
   //! container, and of an associative container). multiset also provides most operations
   //! described for duplicate keys.
   #ifdef BOOST_CONTAINER_DOXYGEN_INVOKED
   template <class Key, class Compare = std::less<Key>, class Allocator = std::allocator<Key> >
   #else
   template <class Key, class Compare, class Allocator>
   #endif
   class multiset
   {
      private:
      BOOST_COPYABLE_AND_MOVABLE(multiset)
      typedef container_detail::rbtree<Key, Key,
                        container_detail::identity<Key>, Compare, Allocator> tree_t;
      tree_t m_tree;  // red-black tree representing multiset
   
      public:
   
      typedef Key                                                                         key_type;
      typedef Key                                                                         value_type;
      typedef Compare                                                                     key_compare;
      typedef Compare                                                                     value_compare;
      typedef typename ::boost::container::allocator_traits<Allocator>::pointer           pointer;
      typedef typename ::boost::container::allocator_traits<Allocator>::const_pointer     const_pointer;
      typedef typename ::boost::container::allocator_traits<Allocator>::reference         reference;
      typedef typename ::boost::container::allocator_traits<Allocator>::const_reference   const_reference;
      typedef typename ::boost::container::allocator_traits<Allocator>::size_type         size_type;
      typedef typename ::boost::container::allocator_traits<Allocator>::difference_type   difference_type;
      typedef Allocator                                                                   allocator_type;
      typedef typename BOOST_CONTAINER_IMPDEF(tree_t::stored_allocator_type)              stored_allocator_type;
      typedef typename BOOST_CONTAINER_IMPDEF(tree_t::iterator)                           iterator;
      typedef typename BOOST_CONTAINER_IMPDEF(tree_t::const_iterator)                     const_iterator;
      typedef typename BOOST_CONTAINER_IMPDEF(tree_t::reverse_iterator)                   reverse_iterator;
      typedef typename BOOST_CONTAINER_IMPDEF(tree_t::const_reverse_iterator)             const_reverse_iterator;
   
   
      multiset(): m_tree()
      {}
    
      explicit multiset(const Compare& comp,
                        const allocator_type& a = allocator_type())
         : m_tree(comp, a)
      {}
   
      template <class InputIterator>
      multiset(InputIterator first, InputIterator last,
               const Compare& comp = Compare(),
               const allocator_type& a = allocator_type())
         : m_tree(false, first, last, comp, a)
      {}
   
      template <class InputIterator>
      multiset( ordered_range_t, InputIterator first, InputIterator last
              , const Compare& comp = Compare()
              , const allocator_type& a = allocator_type())
         : m_tree(ordered_range, first, last, comp, a)
      {}
   
      multiset(const multiset& x)
         : m_tree(x.m_tree)
      {}
   
      multiset(BOOST_RV_REF(multiset) x)
         : m_tree(boost::move(x.m_tree))
      {}
   
      multiset(const multiset& x, const allocator_type &a)
         : m_tree(x.m_tree, a)
      {}
   
      multiset(BOOST_RV_REF(multiset) x, const allocator_type &a)
         : m_tree(boost::move(x.m_tree), a)
      {}
   
    
      multiset& operator=(BOOST_COPY_ASSIGN_REF(multiset) x)
      {  m_tree = x.m_tree;   return *this;  }
   
      multiset& operator=(BOOST_RV_REF(multiset) x)
      {  m_tree = boost::move(x.m_tree);   return *this;  }
   
      allocator_type get_allocator() const
      { return m_tree.get_allocator(); }
   
       stored_allocator_type &get_stored_allocator()
      { return m_tree.get_stored_allocator(); }
   
      const stored_allocator_type &get_stored_allocator() const
      { return m_tree.get_stored_allocator(); }
   
      iterator begin()
      { return m_tree.begin(); }
   
      const_iterator begin() const
      { return m_tree.begin(); }
   
      iterator end()
      { return m_tree.end(); }
   
      const_iterator end() const
      { return m_tree.end(); }
   
      reverse_iterator rbegin()
      { return m_tree.rbegin(); }
   
      const_reverse_iterator rbegin() const
      { return m_tree.rbegin(); }
   
      reverse_iterator rend()
      { return m_tree.rend(); }
   
      const_reverse_iterator rend() const
      { return m_tree.rend(); }
   
      const_iterator cbegin() const
      { return m_tree.cbegin(); }
   
      const_iterator cend() const
      { return m_tree.cend(); }
   
      const_reverse_iterator crbegin() const
      { return m_tree.crbegin(); }
   
      const_reverse_iterator crend() const
      { return m_tree.crend(); }
   
      bool empty() const
      { return m_tree.empty(); }
   
      size_type size() const
      { return m_tree.size(); }
   
      size_type max_size() const
      { return m_tree.max_size(); }
   
      #if defined(BOOST_CONTAINER_PERFECT_FORWARDING) || defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
   
      template <class... Args>
      iterator emplace(Args&&... args)
      {  return m_tree.emplace_equal(boost::forward<Args>(args)...); }
   
      template <class... Args>
      iterator emplace_hint(const_iterator hint, Args&&... args)
      {  return m_tree.emplace_hint_equal(hint, boost::forward<Args>(args)...); }
   
      #else //#ifdef BOOST_CONTAINER_PERFECT_FORWARDING
   
      #define BOOST_PP_LOCAL_MACRO(n)                                                                 
      BOOST_PP_EXPR_IF(n, template<) BOOST_PP_ENUM_PARAMS(n, class P) BOOST_PP_EXPR_IF(n, >)          
      iterator emplace(BOOST_PP_ENUM(n, BOOST_CONTAINER_PP_PARAM_LIST, _))                            
      {  return m_tree.emplace_equal(BOOST_PP_ENUM(n, BOOST_CONTAINER_PP_PARAM_FORWARD, _)); }        
                                                                                                      
      BOOST_PP_EXPR_IF(n, template<) BOOST_PP_ENUM_PARAMS(n, class P) BOOST_PP_EXPR_IF(n, >)          
      iterator emplace_hint(const_iterator hint                                                       
                            BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_PARAM_LIST, _))              
      {  return m_tree.emplace_hint_equal(hint                                                        
                                  BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_PARAM_FORWARD, _));}   
      //!
      #define BOOST_PP_LOCAL_LIMITS (0, BOOST_CONTAINER_MAX_CONSTRUCTOR_PARAMETERS)
      #include BOOST_PP_LOCAL_ITERATE()
   
      #endif   //#ifdef BOOST_CONTAINER_PERFECT_FORWARDING
   
      #if defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
   
      iterator insert(const value_type &x);
      iterator insert(value_type &&x);
      #else
      BOOST_MOVE_CONVERSION_AWARE_CATCH(insert, value_type, iterator, this->priv_insert)
      #endif
   
      #if defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
   
      iterator insert(const_iterator p, const value_type &x);
   
      iterator insert(const_iterator position, value_type &&x);
      #else
      BOOST_MOVE_CONVERSION_AWARE_CATCH_1ARG(insert, value_type, iterator, this->priv_insert, const_iterator)
      #endif
   
      template <class InputIterator>
      void insert(InputIterator first, InputIterator last)
      {  m_tree.insert_equal(first, last);  }
   
      iterator erase(const_iterator p)
      {  return m_tree.erase(p); }
   
      size_type erase(const key_type& x)
      {  return m_tree.erase(x); }
   
      iterator erase(const_iterator first, const_iterator last)
      {  return m_tree.erase(first, last); }
   
      void swap(multiset& x)
      { m_tree.swap(x.m_tree); }
   
      void clear()
      { m_tree.clear(); }
    
      key_compare key_comp() const
      { return m_tree.key_comp(); }
   
      value_compare value_comp() const
      { return m_tree.key_comp(); }
   
      iterator find(const key_type& x)
      { return m_tree.find(x); }
   
      const_iterator find(const key_type& x) const
      { return m_tree.find(x); }
   
      size_type count(const key_type& x) const
      {  return m_tree.count(x);  }
   
      iterator lower_bound(const key_type& x)
      {  return m_tree.lower_bound(x); }
   
      const_iterator lower_bound(const key_type& x) const
      {  return m_tree.lower_bound(x); }
   
      iterator upper_bound(const key_type& x)
      {  return m_tree.upper_bound(x);    }
   
      const_iterator upper_bound(const key_type& x) const
      {  return m_tree.upper_bound(x);    }
   
      std::pair<iterator,iterator> equal_range(const key_type& x)
      {  return m_tree.equal_range(x); }
   
      std::pair<const_iterator, const_iterator> equal_range(const key_type& x) const
      {  return m_tree.equal_range(x); }
   
      /// @cond
      template <class K1, class C1, class A1>
      friend bool operator== (const multiset<K1,C1,A1>&,
                              const multiset<K1,C1,A1>&);
      template <class K1, class C1, class A1>
      friend bool operator< (const multiset<K1,C1,A1>&,
                             const multiset<K1,C1,A1>&);
      private:
      template <class KeyType>
      iterator priv_insert(BOOST_FWD_REF(KeyType) x)
      {  return m_tree.insert_equal(::boost::forward<KeyType>(x));  }
   
      template <class KeyType>
      iterator priv_insert(const_iterator p, BOOST_FWD_REF(KeyType) x)
      {  return m_tree.insert_equal(p, ::boost::forward<KeyType>(x)); }
   
      /// @endcond
   };
   
   template <class Key, class Compare, class Allocator>
   inline bool operator==(const multiset<Key,Compare,Allocator>& x,
                          const multiset<Key,Compare,Allocator>& y)
   {  return x.m_tree == y.m_tree;  }
   
   template <class Key, class Compare, class Allocator>
   inline bool operator<(const multiset<Key,Compare,Allocator>& x,
                         const multiset<Key,Compare,Allocator>& y)
   {  return x.m_tree < y.m_tree;   }
   
   template <class Key, class Compare, class Allocator>
   inline bool operator!=(const multiset<Key,Compare,Allocator>& x,
                          const multiset<Key,Compare,Allocator>& y)
   {  return !(x == y);  }
   
   template <class Key, class Compare, class Allocator>
   inline bool operator>(const multiset<Key,Compare,Allocator>& x,
                         const multiset<Key,Compare,Allocator>& y)
   {  return y < x;  }
   
   template <class Key, class Compare, class Allocator>
   inline bool operator<=(const multiset<Key,Compare,Allocator>& x,
                          const multiset<Key,Compare,Allocator>& y)
   {  return !(y < x);  }
   
   template <class Key, class Compare, class Allocator>
   inline bool operator>=(const multiset<Key,Compare,Allocator>& x,const multiset<Key,Compare,Allocator>& y)
   {  return !(x < y);  }
   
   template <class Key, class Compare, class Allocator>
   inline void swap(multiset<Key,Compare,Allocator>& x, multiset<Key,Compare,Allocator>& y)
   {  x.swap(y);  }
   
   /// @cond
   
   } 

Associative Container->Pair Associative Container

//////////////////////////////////////////////////////////////////////////////
//
// (C) Copyright Ion Gaztanaga 2005-2012.
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// See http://www.boost.org/libs/container for documentation.
//
//////////////////////////////////////////////////////////////////////////////
#ifndef BOOST_CONTAINER_CONTAINER_DETAIL_PAIR_HPP
#define BOOST_CONTAINER_CONTAINER_DETAIL_PAIR_HPP
#if (defined _MSC_VER) && (_MSC_VER >= 1200)
#  pragma once
#endif
#include "config_begin.hpp"
#include <boost/container/detail/workaround.hpp>
#include <boost/container/detail/mpl.hpp>
#include <boost/container/detail/type_traits.hpp>
#include <boost/container/detail/mpl.hpp>
#include <boost/container/detail/type_traits.hpp>
#include <utility>   //std::pair
#include <algorithm> //std::swap
#include <boost/move/utility.hpp>
#include <boost/type_traits/is_class.hpp>
#ifndef BOOST_CONTAINER_PERFECT_FORWARDING
#include <boost/container/detail/preprocessor.hpp>
#endif

namespace boost {
namespace container {
namespace container_detail {

template <class T1, class T2>
struct pair;
template <class T>
struct is_pair
{
   static const bool value = false;
};

template <class T1, class T2>
struct is_pair< pair<T1, T2> >
{
   static const bool value = true;
};

template <class T1, class T2>
struct is_pair< std::pair<T1, T2> >
{
   static const bool value = true;
};

struct pair_nat;
struct piecewise_construct_t { };
static const piecewise_construct_t piecewise_construct = piecewise_construct_t();

template <class T1, class T2>
struct pair
{
   private:
   BOOST_COPYABLE_AND_MOVABLE(pair)

   public:
   typedef T1 first_type;
   typedef T2 second_type;

   T1 first;
   T2 second;

   //Default constructor
   pair(): first(), second()
   {}

   //pair copy assignment
   pair(const pair& x): first(x.first), second(x.second)
   {}

   //pair move constructor
   pair(BOOST_RV_REF(pair) p): first(::boost::move(p.first)), second(::boost::move(p.second))
   {}

   template <class D, class S>
   pair(const pair<D, S> &p): first(p.first), second(p.second)
   {}

   template <class D, class S>
   pair(BOOST_RV_REF_BEG pair<D, S> BOOST_RV_REF_END p): first(::boost::move(p.first)), second(::boost::move(p.second))
   {}

   //pair from two values
   pair(const T1 &t1, const T2 &t2): first(t1), second(t2)
   {}

   template<class U, class V>
   pair(BOOST_FWD_REF(U) u, BOOST_FWD_REF(V) v): first(::boost::forward<U>(u)), second(::boost::forward<V>(v))
   {}

   //And now compatibility with std::pair
   pair(const std::pair<T1, T2>& x): first(x.first), second(x.second)
   {}

   template <class D, class S>
   pair(const std::pair<D, S>& p): first(p.first), second(p.second)
   {}

   pair(BOOST_RV_REF_BEG std::pair<T1, T2> BOOST_RV_REF_END p): first(::boost::move(p.first)), second(::boost::move(p.second))
   {}

   template <class D, class S>
   pair(BOOST_RV_REF_BEG std::pair<D, S> BOOST_RV_REF_END p): first(::boost::move(p.first)), second(::boost::move(p.second))
   {}

   //piecewise_construct missing
   //template <class U, class V> pair(pair<U, V>&& p);
   //template <class... Args1, class... Args2>
   //   pair(piecewise_construct_t, tuple<Args1...> first_args,
   //        tuple<Args2...> second_args);

   //pair copy assignment
   pair& operator=(BOOST_COPY_ASSIGN_REF(pair) p)
   {
      first  = p.first;
      second = p.second;
      return *this;
   }

   //pair move assignment
   pair& operator=(BOOST_RV_REF(pair) p)
   {
      first  = ::boost::move(p.first);
      second = ::boost::move(p.second);
      return *this;
   }

   template <class D, class S>
   typename ::boost::container::container_detail::enable_if_c
      < !(::boost::container::container_detail::is_same<T1, D>::value &&
          ::boost::container::container_detail::is_same<T2, S>::value)
      , pair &>::type  operator=(const pair<D, S>&p)
   {
      first  = p.first;
      second = p.second;
      return *this;
   }
   template <class D, class S>
   typename ::boost::container::container_detail::enable_if_c
      < !(::boost::container::container_detail::is_same<T1, D>::value &&
          ::boost::container::container_detail::is_same<T2, S>::value)
      , pair &>::type  operator=(BOOST_RV_REF_BEG pair<D, S> BOOST_RV_REF_END p)
   {
      first  = ::boost::move(p.first);
      second = ::boost::move(p.second);
      return *this;
   }
   //std::pair copy assignment
   pair& operator=(const std::pair<T1, T2> &p)
   {
      first  = p.first;
      second = p.second;
      return *this;
   }
   template <class D, class S>
   pair& operator=(const std::pair<D, S> &p)
   {
      first  = ::boost::move(p.first);
      second = ::boost::move(p.second);
      return *this;
   }
   //std::pair move assignment
   pair& operator=(BOOST_RV_REF_BEG std::pair<T1, T2> BOOST_RV_REF_END p)
   {
      first  = ::boost::move(p.first);
      second = ::boost::move(p.second);
      return *this;
   }
   template <class D, class S>
   pair& operator=(BOOST_RV_REF_BEG std::pair<D, S> BOOST_RV_REF_END p)
   {
      first  = ::boost::move(p.first);
      second = ::boost::move(p.second);
      return *this;
   }
   //swap
   void swap(pair& p)
   {
      using std::swap;
      swap(this->first, p.first);
      swap(this->second, p.second);
   }
};

template <class T1, class T2>
inline bool operator==(const pair<T1,T2>& x, const pair<T1,T2>& y)
{  return static_cast<bool>(x.first == y.first && x.second == y.second);  }

template <class T1, class T2>
inline bool operator< (const pair<T1,T2>& x, const pair<T1,T2>& y)
{  return static_cast<bool>(x.first < y.first || (!(y.first < x.first) && x.second < y.second)); }

template <class T1, class T2>
inline bool operator!=(const pair<T1,T2>& x, const pair<T1,T2>& y)
{  return static_cast<bool>(!(x == y));  }

template <class T1, class T2>
inline bool operator> (const pair<T1,T2>& x, const pair<T1,T2>& y)
{  return y < x;  }

template <class T1, class T2>
inline bool operator>=(const pair<T1,T2>& x, const pair<T1,T2>& y)
{  return static_cast<bool>(!(x < y)); }

template <class T1, class T2>
inline bool operator<=(const pair<T1,T2>& x, const pair<T1,T2>& y)
{  return static_cast<bool>(!(y < x)); }

template <class T1, class T2>
inline pair<T1, T2> make_pair(T1 x, T2 y)
{  return pair<T1, T2>(x, y); }

template <class T1, class T2>
inline void swap(pair<T1, T2>& x, pair<T1, T2>& y)
{
   swap(x.first, y.first);
   swap(x.second, y.second);
}
}  //namespace container_detail {
}  //namespace container {

//Without this specialization recursive flat_(multi)map instantiation fails
//because is_enum needs to instantiate the recursive pair, leading to a compilation error).
//This breaks the cycle clearly stating that pair is not an enum avoiding any instantiation.
template<class T>
struct is_enum;
template<class T, class U>
struct is_enum< ::boost::container::container_detail::pair<T, U> >
{
   static const bool value = false;
};
//This specialization is needed to avoid instantiation of pair in
//is_class, and allow recursive maps.
template <class T1, class T2>
struct is_class< ::boost::container::container_detail::pair<T1, T2> >: public ::boost::true_type
{};

#ifdef BOOST_NO_CXX11_RVALUE_REFERENCES

template<class T1, class T2>
struct has_move_emulation_enabled< ::boost::container::container_detail::pair<T1, T2> >
   : ::boost::true_type
{};

#endif


}  //namespace boost {

#include <boost/container/detail/config_end.hpp>

#endif   //#ifndef BOOST_CONTAINER_DETAIL_PAIR_HPP

 

//////////////////////////////////////////////////////////////////////////////
//
// (C) Copyright Ion Gaztanaga 2005-2012. Distributed under the Boost
// Software License, Version 1.0. (See accompanying file
// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//
// See http://www.boost.org/libs/container for documentation.
//
//////////////////////////////////////////////////////////////////////////////

#ifndef BOOST_CONTAINER_MAP_HPP
#define BOOST_CONTAINER_MAP_HPP

#if (defined _MSC_VER) && (_MSC_VER >= 1200)
#  pragma once
#endif

#include <boost/container/detail/config_begin.hpp>
#include <boost/container/detail/workaround.hpp>
#include <boost/container/container_fwd.hpp>
#include <utility>
#include <functional>
#include <memory>
#include <boost/container/detail/tree.hpp>
#include <boost/container/detail/value_init.hpp>
#include <boost/type_traits/has_trivial_destructor.hpp>
#include <boost/container/detail/mpl.hpp>
#include <boost/container/detail/utilities.hpp>
#include <boost/container/detail/pair.hpp>
#include <boost/container/detail/type_traits.hpp>
#include <boost/container/throw_exception.hpp>
#include <boost/move/utility.hpp>
#include <boost/move/detail/move_helpers.hpp>
#include <boost/static_assert.hpp>
#include <boost/container/detail/value_init.hpp>
#include <boost/detail/no_exceptions_support.hpp>

namespace boost {
namespace container {

/// @cond
// Forward declarations of operators == and <, needed for friend declarations.
template <class Key, class T, class Compare, class Allocator>
inline bool operator==(const map<Key,T,Compare,Allocator>& x,
                       const map<Key,T,Compare,Allocator>& y);

template <class Key, class T, class Compare, class Allocator>
inline bool operator<(const map<Key,T,Compare,Allocator>& x,
                      const map<Key,T,Compare,Allocator>& y);

//! A map is a kind of associative container that supports unique keys (contains at
//! most one of each key value) and provides for fast retrieval of values of another
//! type T based on the keys. The map class supports bidirectional iterators.
//! A map satisfies all of the requirements of a container and of a reversible
//! container and of an associative container. For a
//! map<Key,T> the key_type is Key and the value_type is std::pair<const Key,T>.
//! Compare is the ordering function for Keys (e.g. <i>std::less<Key></i>).
//! Allocator is the allocator to allocate the value_types
//! (e.g. <i>allocator< std::pair<const Key, T> > </i>).
#ifdef BOOST_CONTAINER_DOXYGEN_INVOKED
template <class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator< std::pair< const Key, T> > >
#else
template <class Key, class T, class Compare, class Allocator>
#endif
class map
{
   /// @cond
   private:
   BOOST_COPYABLE_AND_MOVABLE(map)

   typedef std::pair<const Key, T>  value_type_impl;
   typedef container_detail::rbtree
      <Key, value_type_impl, container_detail::select1st<value_type_impl>, Compare, Allocator> tree_t;
   typedef container_detail::pair <Key, T> movable_value_type_impl;
   typedef container_detail::tree_value_compare
      < Key, value_type_impl, Compare, container_detail::select1st<value_type_impl>
      >  value_compare_impl;
   tree_t m_tree;  // red-black tree representing map
   /// @endcond

   public:
   typedef Key                                                                      key_type;
   typedef T                                                                        mapped_type;
   typedef std::pair<const Key, T>                                                  value_type;
   typedef typename boost::container::allocator_traits<Allocator>::pointer          pointer;
   typedef typename boost::container::allocator_traits<Allocator>::const_pointer    const_pointer;
   typedef typename boost::container::allocator_traits<Allocator>::reference        reference;
   typedef typename boost::container::allocator_traits<Allocator>::const_reference  const_reference;
   typedef typename boost::container::allocator_traits<Allocator>::size_type        size_type;
   typedef typename boost::container::allocator_traits<Allocator>::difference_type  difference_type;
   typedef Allocator                                                                allocator_type;
   typedef typename BOOST_CONTAINER_IMPDEF(tree_t::stored_allocator_type)           stored_allocator_type;
   typedef BOOST_CONTAINER_IMPDEF(value_compare_impl)                               value_compare;
   typedef Compare                                                                  key_compare;
   typedef typename BOOST_CONTAINER_IMPDEF(tree_t::iterator)                        iterator;
   typedef typename BOOST_CONTAINER_IMPDEF(tree_t::const_iterator)                  const_iterator;
   typedef typename BOOST_CONTAINER_IMPDEF(tree_t::reverse_iterator)                reverse_iterator;
   typedef typename BOOST_CONTAINER_IMPDEF(tree_t::const_reverse_iterator)          const_reverse_iterator;
   typedef std::pair<key_type, mapped_type>                                         nonconst_value_type;
   typedef BOOST_CONTAINER_IMPDEF(movable_value_type_impl)                          movable_value_type;

   map(): m_tree()
   {
      //Allocator type must be std::pair<CONST Key, T>
      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename Allocator::value_type>::value));
   }
   
   explicit map(const Compare& comp,const allocator_type& a = allocator_type()): m_tree(comp, a)
   {
      //Allocator type must be std::pair<CONST Key, T>
      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename Allocator::value_type>::value));
   }

   template <class InputIterator>
   map(InputIterator first, InputIterator last, const Compare& comp = Compare(),const allocator_type& a = allocator_type())
      : m_tree(true, first, last, comp, a)
   {
      //Allocator type must be std::pair<CONST Key, T>
      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename Allocator::value_type>::value));
   }

   template <class InputIterator>
   map( ordered_unique_range_t, InputIterator first, InputIterator last
      , const Compare& comp = Compare(), const allocator_type& a = allocator_type())
      : m_tree(ordered_range, first, last, comp, a)
   {
      //Allocator type must be std::pair<CONST Key, T>
      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename Allocator::value_type>::value));
   }
   map(const map& x): m_tree(x.m_tree)
   {
      //Allocator type must be std::pair<CONST Key, T>
      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename Allocator::value_type>::value));
   }

   map(BOOST_RV_REF(map) x): m_tree(boost::move(x.m_tree))
   {
      //Allocator type must be std::pair<CONST Key, T>
      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename Allocator::value_type>::value));
   }

   map(const map& x, const allocator_type &a): m_tree(x.m_tree, a)
   {
      //Allocator type must be std::pair<CONST Key, T>
      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename Allocator::value_type>::value));
   }

   map(BOOST_RV_REF(map) x, const allocator_type &a): m_tree(boost::move(x.m_tree), a)
   {
      //Allocator type must be std::pair<CONST Key, T>
      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename Allocator::value_type>::value));
   }
   map& operator=(BOOST_COPY_ASSIGN_REF(map) x)
   {  m_tree = x.m_tree;   return *this;  }

   map& operator=(BOOST_RV_REF(map) x)
   {  m_tree = boost::move(x.m_tree);   return *this;  }

   allocator_type get_allocator() const BOOST_CONTAINER_NOEXCEPT
   { return m_tree.get_allocator(); }


   stored_allocator_type &get_stored_allocator() BOOST_CONTAINER_NOEXCEPT
   { return m_tree.get_stored_allocator(); }

   const stored_allocator_type &get_stored_allocator() const BOOST_CONTAINER_NOEXCEPT
   { return m_tree.get_stored_allocator(); }

   iterator begin() BOOST_CONTAINER_NOEXCEPT
   { return m_tree.begin(); }

   const_iterator begin() const BOOST_CONTAINER_NOEXCEPT
   { return this->cbegin(); }

   iterator end() BOOST_CONTAINER_NOEXCEPT
   { return m_tree.end(); }

   const_iterator end() const BOOST_CONTAINER_NOEXCEPT
   { return this->cend(); }

   reverse_iterator rbegin() BOOST_CONTAINER_NOEXCEPT
   { return m_tree.rbegin(); }

   const_reverse_iterator rbegin() const BOOST_CONTAINER_NOEXCEPT
   { return this->crbegin(); }

   reverse_iterator rend() BOOST_CONTAINER_NOEXCEPT
   { return m_tree.rend(); }

   const_reverse_iterator rend() const BOOST_CONTAINER_NOEXCEPT
   { return this->crend(); }

   const_iterator cbegin() const BOOST_CONTAINER_NOEXCEPT
   { return m_tree.begin(); }

   const_iterator cend() const BOOST_CONTAINER_NOEXCEPT
   { return m_tree.end(); }

   const_reverse_iterator crbegin() const BOOST_CONTAINER_NOEXCEPT
   { return m_tree.rbegin(); }

   const_reverse_iterator crend() const BOOST_CONTAINER_NOEXCEPT
   { return m_tree.rend(); }

   bool empty() const BOOST_CONTAINER_NOEXCEPT
   { return m_tree.empty(); }

   size_type size() const BOOST_CONTAINER_NOEXCEPT
   { return m_tree.size(); }

   size_type max_size() const BOOST_CONTAINER_NOEXCEPT
   { return m_tree.max_size(); }

   #if defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
  
   mapped_type& operator[](const key_type &k);

   mapped_type& operator[](key_type &&k);
   #else
   BOOST_MOVE_CONVERSION_AWARE_CATCH( operator[] , key_type, mapped_type&, this->priv_subscript)
   #endif

   T& at(const key_type& k)
   {
      iterator i = this->find(k);
      if(i == this->end()){
         throw_out_of_range("map::at key not found");
      }
      return i->second;
   }

   const T& at(const key_type& k) const
   {
      const_iterator i = this->find(k);
      if(i == this->end()){
         throw_out_of_range("map::at key not found");
      }
      return i->second;
   }

   std::pair<iterator,bool> insert(const value_type& x)
   { return m_tree.insert_unique(x); }

   std::pair<iterator,bool> insert(const nonconst_value_type& x)
   { return m_tree.insert_unique(x); }

   std::pair<iterator,bool> insert(BOOST_RV_REF(nonconst_value_type) x)
   { return m_tree.insert_unique(boost::move(x)); }

   std::pair<iterator,bool> insert(BOOST_RV_REF(movable_value_type) x)
   { return m_tree.insert_unique(boost::move(x)); }

   std::pair<iterator,bool> insert(BOOST_RV_REF(value_type) x)
   { return m_tree.insert_unique(boost::move(x)); }

   iterator insert(const_iterator position, const value_type& x)
   { return m_tree.insert_unique(position, x); }

   iterator insert(const_iterator position, BOOST_RV_REF(nonconst_value_type) x)
   { return m_tree.insert_unique(position, boost::move(x)); }

   iterator insert(const_iterator position, BOOST_RV_REF(movable_value_type) x)
   { return m_tree.insert_unique(position, boost::move(x)); }

   iterator insert(const_iterator position, const nonconst_value_type& x)
   { return m_tree.insert_unique(position, x); }

   iterator insert(const_iterator position, BOOST_RV_REF(value_type) x)
   { return m_tree.insert_unique(position, boost::move(x)); }

   template <class InputIterator>
   void insert(InputIterator first, InputIterator last)
   {  m_tree.insert_unique(first, last);  }

   #if defined(BOOST_CONTAINER_PERFECT_FORWARDING) || defined(BOOST_CONTAINER_DOXYGEN_INVOKED)

   template <class... Args>
   std::pair<iterator,bool> emplace(Args&&... args)
   {  return m_tree.emplace_unique(boost::forward<Args>(args)...); }

   template <class... Args>
   iterator emplace_hint(const_iterator hint, Args&&... args)
   {  return m_tree.emplace_hint_unique(hint, boost::forward<Args>(args)...); }

   #else //#ifdef BOOST_CONTAINER_PERFECT_FORWARDING

   #define BOOST_PP_LOCAL_MACRO(n)                                                                 
   BOOST_PP_EXPR_IF(n, template<) BOOST_PP_ENUM_PARAMS(n, class P) BOOST_PP_EXPR_IF(n, >)          
   std::pair<iterator,bool> emplace(BOOST_PP_ENUM(n, BOOST_CONTAINER_PP_PARAM_LIST, _))            
   {  return m_tree.emplace_unique(BOOST_PP_ENUM(n, BOOST_CONTAINER_PP_PARAM_FORWARD, _)); }       
                                                                                                   
   BOOST_PP_EXPR_IF(n, template<) BOOST_PP_ENUM_PARAMS(n, class P) BOOST_PP_EXPR_IF(n, >)          
   iterator emplace_hint(const_iterator hint                                                       
                         BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_PARAM_LIST, _))              
   {  return m_tree.emplace_hint_unique(hint                                                       
                               BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_PARAM_FORWARD, _));}   
   //!
   #define BOOST_PP_LOCAL_LIMITS (0, BOOST_CONTAINER_MAX_CONSTRUCTOR_PARAMETERS)
   #include BOOST_PP_LOCAL_ITERATE()

   #endif   //#ifdef BOOST_CONTAINER_PERFECT_FORWARDING

   iterator erase(const_iterator position) BOOST_CONTAINER_NOEXCEPT
   { return m_tree.erase(position); }

   size_type erase(const key_type& x) BOOST_CONTAINER_NOEXCEPT
   { return m_tree.erase(x); }

   iterator erase(const_iterator first, const_iterator last) BOOST_CONTAINER_NOEXCEPT
   { return m_tree.erase(first, last); }

   void swap(map& x)
   { m_tree.swap(x.m_tree); }

   void clear() BOOST_CONTAINER_NOEXCEPT
   { m_tree.clear(); }

   key_compare key_comp() const
   { return m_tree.key_comp(); }

   value_compare value_comp() const
   { return value_compare(m_tree.key_comp()); }

   iterator find(const key_type& x)
   { return m_tree.find(x); }

   const_iterator find(const key_type& x) const
   { return m_tree.find(x); }

   size_type count(const key_type& x) const
   {  return m_tree.find(x) == m_tree.end() ? 0 : 1;  }

   iterator lower_bound(const key_type& x)
   {  return m_tree.lower_bound(x); }

   const_iterator lower_bound(const key_type& x) const
   {  return m_tree.lower_bound(x); }

   iterator upper_bound(const key_type& x)
   {  return m_tree.upper_bound(x); }

   const_iterator upper_bound(const key_type& x) const
   {  return m_tree.upper_bound(x); }

   std::pair<iterator,iterator> equal_range(const key_type& x)
   {  return m_tree.equal_range(x); }

   std::pair<const_iterator,const_iterator> equal_range(const key_type& x) const
   {  return m_tree.equal_range(x); }

   template <class K1, class T1, class C1, class A1>
   friend bool operator== (const map<K1, T1, C1, A1>&,
                           const map<K1, T1, C1, A1>&);
   template <class K1, class T1, class C1, class A1>
   friend bool operator< (const map<K1, T1, C1, A1>&,
                          const map<K1, T1, C1, A1>&);
   private:
   mapped_type& priv_subscript(const key_type &k)
   {
      //we can optimize this
      iterator i = lower_bound(k);
      // i->first is greater than or equivalent to k.
      if (i == end() || key_comp()(k, (*i).first)){
         container_detail::value_init<mapped_type> m;
         movable_value_type val(k, boost::move(m.m_t));
         i = insert(i, boost::move(val));
      }
      return (*i).second;
   }

   mapped_type& priv_subscript(BOOST_RV_REF(key_type) mk)
   {
      key_type &k = mk;
      //we can optimize this
      iterator i = lower_bound(k);
      // i->first is greater than or equivalent to k.
      if (i == end() || key_comp()(k, (*i).first)){
         container_detail::value_init<mapped_type> m;
         movable_value_type val(boost::move(k), boost::move(m.m_t));
         i = insert(i, boost::move(val));
      }
      return (*i).second;
   }

   /// @endcond
};

template <class Key, class T, class Compare, class Allocator>
inline bool operator==(const map<Key,T,Compare,Allocator>& x,
                       const map<Key,T,Compare,Allocator>& y)
   {  return x.m_tree == y.m_tree;  }
template <class Key, class T, class Compare, class Allocator>
inline bool operator<(const map<Key,T,Compare,Allocator>& x,
                      const map<Key,T,Compare,Allocator>& y)
   {  return x.m_tree < y.m_tree;   }
template <class Key, class T, class Compare, class Allocator>
inline bool operator!=(const map<Key,T,Compare,Allocator>& x,
                       const map<Key,T,Compare,Allocator>& y)
   {  return !(x == y); }
template <class Key, class T, class Compare, class Allocator>
inline bool operator>(const map<Key,T,Compare,Allocator>& x,
                      const map<Key,T,Compare,Allocator>& y)
   {  return y < x;  }
template <class Key, class T, class Compare, class Allocator>
inline bool operator<=(const map<Key,T,Compare,Allocator>& x,
                       const map<Key,T,Compare,Allocator>& y)
   {  return !(y < x);  }
template <class Key, class T, class Compare, class Allocator>
inline bool operator>=(const map<Key,T,Compare,Allocator>& x,
                       const map<Key,T,Compare,Allocator>& y)
   {  return !(x < y);  }
template <class Key, class T, class Compare, class Allocator>
inline void swap(map<Key,T,Compare,Allocator>& x, map<Key,T,Compare,Allocator>& y)
   {  x.swap(y);  }
/// @cond

// Forward declaration of operators < and ==, needed for friend declaration.

template <class Key, class T, class Compare, class Allocator>
inline bool operator==(const multimap<Key,T,Compare,Allocator>& x,
                       const multimap<Key,T,Compare,Allocator>& y);

template <class Key, class T, class Compare, class Allocator>
inline bool operator<(const multimap<Key,T,Compare,Allocator>& x,
                      const multimap<Key,T,Compare,Allocator>& y);

}  //namespace container {

template <class K, class T, class C, class Allocator>
struct has_trivial_destructor_after_move<boost::container::map<K, T, C, Allocator> >
{
   static const bool value = has_trivial_destructor_after_move<Allocator>::value && has_trivial_destructor_after_move<C>::value;
};

namespace container {


//! A multimap is a kind of associative container that supports equivalent keys
//! (possibly containing multiple copies of the same key value) and provides for
//! fast retrieval of values of another type T based on the keys. The multimap class
//! supports bidirectional iterators.
//!
//! A multimap satisfies all of the requirements of a container and of a reversible
//! container and of an associative container. For a
//! map<Key,T> the key_type is Key and the value_type is std::pair<const Key,T>.
//!
//! Compare is the ordering function for Keys (e.g. <i>std::less<Key></i>).
//!
//! Allocator is the allocator to allocate the value_types
//!(e.g. <i>allocator< std::pair<<b>const</b> Key, T> ></i>).
#ifdef BOOST_CONTAINER_DOXYGEN_INVOKED
template <class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator< std::pair< const Key, T> > >
#else
template <class Key, class T, class Compare, class Allocator>
#endif
class multimap
{
   /// @cond
   private:
   BOOST_COPYABLE_AND_MOVABLE(multimap)

   typedef std::pair<const Key, T>  value_type_impl;
   typedef container_detail::rbtree
      <Key, value_type_impl, container_detail::select1st<value_type_impl>, Compare, Allocator> tree_t;
   typedef container_detail::pair <Key, T> movable_value_type_impl;
   typedef container_detail::tree_value_compare
      < Key, value_type_impl, Compare, container_detail::select1st<value_type_impl>
      >  value_compare_impl;
   tree_t m_tree;  // red-black tree representing map
   /// @endcond

   public:
   typedef Key                                                                      key_type;
   typedef T                                                                        mapped_type;
   typedef std::pair<const Key, T>                                                  value_type;
   typedef typename boost::container::allocator_traits<Allocator>::pointer          pointer;
   typedef typename boost::container::allocator_traits<Allocator>::const_pointer    const_pointer;
   typedef typename boost::container::allocator_traits<Allocator>::reference        reference;
   typedef typename boost::container::allocator_traits<Allocator>::const_reference  const_reference;
   typedef typename boost::container::allocator_traits<Allocator>::size_type        size_type;
   typedef typename boost::container::allocator_traits<Allocator>::difference_type  difference_type;
   typedef Allocator                                                                allocator_type;
   typedef typename BOOST_CONTAINER_IMPDEF(tree_t::stored_allocator_type)           stored_allocator_type;
   typedef BOOST_CONTAINER_IMPDEF(value_compare_impl)                               value_compare;
   typedef Compare                                                                  key_compare;
   typedef typename BOOST_CONTAINER_IMPDEF(tree_t::iterator)                        iterator;
   typedef typename BOOST_CONTAINER_IMPDEF(tree_t::const_iterator)                  const_iterator;
   typedef typename BOOST_CONTAINER_IMPDEF(tree_t::reverse_iterator)                reverse_iterator;
   typedef typename BOOST_CONTAINER_IMPDEF(tree_t::const_reverse_iterator)          const_reverse_iterator;
   typedef std::pair<key_type, mapped_type>                                         nonconst_value_type;
   typedef BOOST_CONTAINER_IMPDEF(movable_value_type_impl)                          movable_value_type;

   multimap(): m_tree()
   {
      //Allocator type must be std::pair<CONST Key, T>
      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename Allocator::value_type>::value));
   }

   explicit multimap(const Compare& comp, const allocator_type& a = allocator_type()): m_tree(comp, a)
   {
      //Allocator type must be std::pair<CONST Key, T>
      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename Allocator::value_type>::value));
   }
   
   template <class InputIterator>
   multimap(InputIterator first, InputIterator last,
            const Compare& comp = Compare(),
            const allocator_type& a = allocator_type())
      : m_tree(false, first, last, comp, a)
   {
      //Allocator type must be std::pair<CONST Key, T>
      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename Allocator::value_type>::value));
   }

   template <class InputIterator>
   multimap(ordered_range_t, InputIterator first, InputIterator last, const Compare& comp = Compare(),
         const allocator_type& a = allocator_type())
      : m_tree(ordered_range, first, last, comp, a)
   {}

   multimap(const multimap& x): m_tree(x.m_tree)
   {
      //Allocator type must be std::pair<CONST Key, T>
      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename Allocator::value_type>::value));
   }

   multimap(BOOST_RV_REF(multimap) x): m_tree(boost::move(x.m_tree))
   {
      //Allocator type must be std::pair<CONST Key, T>
      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename Allocator::value_type>::value));
   }

   multimap(const multimap& x, const allocator_type &a): m_tree(x.m_tree, a)
   {
      //Allocator type must be std::pair<CONST Key, T>
      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename Allocator::value_type>::value));
   }
   multimap(BOOST_RV_REF(multimap) x, const allocator_type &a): m_tree(boost::move(x.m_tree), a)
   {
      //Allocator type must be std::pair<CONST Key, T>
      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename Allocator::value_type>::value));
   }

   multimap& operator=(BOOST_COPY_ASSIGN_REF(multimap) x)
   {  m_tree = x.m_tree;   return *this;  }

   multimap& operator=(BOOST_RV_REF(multimap) x)
   {  m_tree = boost::move(x.m_tree);   return *this;  }

   allocator_type get_allocator() const BOOST_CONTAINER_NOEXCEPT
   { return m_tree.get_allocator(); }

   stored_allocator_type &get_stored_allocator() BOOST_CONTAINER_NOEXCEPT
   { return m_tree.get_stored_allocator(); }

   const stored_allocator_type &get_stored_allocator() const BOOST_CONTAINER_NOEXCEPT
   { return m_tree.get_stored_allocator(); }

   iterator begin() BOOST_CONTAINER_NOEXCEPT
   { return m_tree.begin(); }

   const_iterator begin() const BOOST_CONTAINER_NOEXCEPT
   { return this->cbegin(); }

   iterator end() BOOST_CONTAINER_NOEXCEPT
   { return m_tree.end(); }

   const_iterator end() const BOOST_CONTAINER_NOEXCEPT
   { return this->cend(); }

   reverse_iterator rbegin() BOOST_CONTAINER_NOEXCEPT
   { return m_tree.rbegin(); }

   const_reverse_iterator rbegin() const BOOST_CONTAINER_NOEXCEPT
   { return this->crbegin(); }

   reverse_iterator rend() BOOST_CONTAINER_NOEXCEPT
   { return m_tree.rend(); }

   const_reverse_iterator rend() const BOOST_CONTAINER_NOEXCEPT
   { return this->crend(); }

   const_iterator cbegin() const BOOST_CONTAINER_NOEXCEPT
   { return m_tree.begin(); }

   const_iterator cend() const BOOST_CONTAINER_NOEXCEPT
   { return m_tree.end(); }

   const_reverse_iterator crbegin() const BOOST_CONTAINER_NOEXCEPT
   { return m_tree.rbegin(); }

   const_reverse_iterator crend() const BOOST_CONTAINER_NOEXCEPT
   { return m_tree.rend(); }

   bool empty() const BOOST_CONTAINER_NOEXCEPT
   { return m_tree.empty(); }

   size_type size() const BOOST_CONTAINER_NOEXCEPT
   { return m_tree.size(); }

   size_type max_size() const BOOST_CONTAINER_NOEXCEPT
   { return m_tree.max_size(); }  

   #if defined(BOOST_CONTAINER_PERFECT_FORWARDING) || defined(BOOST_CONTAINER_DOXYGEN_INVOKED)

   template <class... Args>
   iterator emplace(Args&&... args)
   {  return m_tree.emplace_equal(boost::forward<Args>(args)...); }

   template <class... Args>
   iterator emplace_hint(const_iterator hint, Args&&... args)
   {  return m_tree.emplace_hint_equal(hint, boost::forward<Args>(args)...); }

   #else //#ifdef BOOST_CONTAINER_PERFECT_FORWARDING

   #define BOOST_PP_LOCAL_MACRO(n)                                                                 
   BOOST_PP_EXPR_IF(n, template<) BOOST_PP_ENUM_PARAMS(n, class P) BOOST_PP_EXPR_IF(n, >)          
   iterator emplace(BOOST_PP_ENUM(n, BOOST_CONTAINER_PP_PARAM_LIST, _))                            
   {  return m_tree.emplace_equal(BOOST_PP_ENUM(n, BOOST_CONTAINER_PP_PARAM_FORWARD, _)); }        
                                                                                                   
   BOOST_PP_EXPR_IF(n, template<) BOOST_PP_ENUM_PARAMS(n, class P) BOOST_PP_EXPR_IF(n, >)          
   iterator emplace_hint(const_iterator hint                                                       
                         BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_PARAM_LIST, _))              
   {  return m_tree.emplace_hint_equal(hint                                                        
                               BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_PARAM_FORWARD, _));}   
   //!
   #define BOOST_PP_LOCAL_LIMITS (0, BOOST_CONTAINER_MAX_CONSTRUCTOR_PARAMETERS)
   #include BOOST_PP_LOCAL_ITERATE()

   #endif   //#ifdef BOOST_CONTAINER_PERFECT_FORWARDING

   iterator insert(const value_type& x)
   { return m_tree.insert_equal(x); }

   iterator insert(const nonconst_value_type& x)
   { return m_tree.insert_equal(x); }

   iterator insert(BOOST_RV_REF(nonconst_value_type) x)
   { return m_tree.insert_equal(boost::move(x)); }

   iterator insert(BOOST_RV_REF(movable_value_type) x)
   { return m_tree.insert_equal(boost::move(x)); }

   iterator insert(const_iterator position, const value_type& x)
   { return m_tree.insert_equal(position, x); }

   iterator insert(const_iterator position, const nonconst_value_type& x)
   { return m_tree.insert_equal(position, x); }

   iterator insert(const_iterator position, BOOST_RV_REF(nonconst_value_type) x)
   { return m_tree.insert_equal(position, boost::move(x)); }

    iterator insert(const_iterator position, BOOST_RV_REF(movable_value_type) x)
   { return m_tree.insert_equal(position, boost::move(x)); }

   template <class InputIterator>
   void insert(InputIterator first, InputIterator last)
   {  m_tree.insert_equal(first, last); }

   iterator erase(const_iterator position) BOOST_CONTAINER_NOEXCEPT
   { return m_tree.erase(position); }

   size_type erase(const key_type& x) BOOST_CONTAINER_NOEXCEPT
   { return m_tree.erase(x); }

   iterator erase(const_iterator first, const_iterator last) BOOST_CONTAINER_NOEXCEPT
   { return m_tree.erase(first, last); }

   void swap(multimap& x)
   { m_tree.swap(x.m_tree); }

   void clear() BOOST_CONTAINER_NOEXCEPT
   { m_tree.clear(); }

   key_compare key_comp() const
   { return m_tree.key_comp(); }

   value_compare value_comp() const
   { return value_compare(m_tree.key_comp()); }

   iterator find(const key_type& x)
   { return m_tree.find(x); }

   const_iterator find(const key_type& x) const
   { return m_tree.find(x); }

   size_type count(const key_type& x) const
   { return m_tree.count(x); }

   iterator lower_bound(const key_type& x)
   {return m_tree.lower_bound(x); }

   const_iterator lower_bound(const key_type& x) const
   {  return m_tree.lower_bound(x);  }

   iterator upper_bound(const key_type& x)
   {  return m_tree.upper_bound(x); }

   const_iterator upper_bound(const key_type& x) const
   {  return m_tree.upper_bound(x); }

   std::pair<iterator,iterator> equal_range(const key_type& x)
   {  return m_tree.equal_range(x);   }

   std::pair<const_iterator,const_iterator> equal_range(const key_type& x) const
   {  return m_tree.equal_range(x);   }

   /// @cond
   template <class K1, class T1, class C1, class A1>
   friend bool operator== (const multimap<K1, T1, C1, A1>& x,
                           const multimap<K1, T1, C1, A1>& y);

   template <class K1, class T1, class C1, class A1>
   friend bool operator< (const multimap<K1, T1, C1, A1>& x,
                          const multimap<K1, T1, C1, A1>& y);
   /// @endcond
};

template <class Key, class T, class Compare, class Allocator>
inline bool operator==(const multimap<Key,T,Compare,Allocator>& x,
                       const multimap<Key,T,Compare,Allocator>& y)
{  return x.m_tree == y.m_tree;  }

template <class Key, class T, class Compare, class Allocator>
inline bool operator<(const multimap<Key,T,Compare,Allocator>& x,
                      const multimap<Key,T,Compare,Allocator>& y)
{  return x.m_tree < y.m_tree;   }

template <class Key, class T, class Compare, class Allocator>
inline bool operator!=(const multimap<Key,T,Compare,Allocator>& x,
                       const multimap<Key,T,Compare,Allocator>& y)
{  return !(x == y);  }

template <class Key, class T, class Compare, class Allocator>
inline bool operator>(const multimap<Key,T,Compare,Allocator>& x,
                      const multimap<Key,T,Compare,Allocator>& y)
{  return y < x;  }

template <class Key, class T, class Compare, class Allocator>
inline bool operator<=(const multimap<Key,T,Compare,Allocator>& x,
                       const multimap<Key,T,Compare,Allocator>& y)
{  return !(y < x);  }

template <class Key, class T, class Compare, class Allocator>
inline bool operator>=(const multimap<Key,T,Compare,Allocator>& x,
                       const multimap<Key,T,Compare,Allocator>& y)
{  return !(x < y);  }

template <class Key, class T, class Compare, class Allocator>
inline void swap(multimap<Key,T,Compare,Allocator>& x, multimap<Key,T,Compare,Allocator>& y)
{  x.swap(y);  }

/// @cond

}  //namespace container {

//!has_trivial_destructor_after_move<> == true_type
//!specialization for optimizations
template <class K, class T, class C, class Allocator>
struct has_trivial_destructor_after_move<boost::container::multimap<K, T, C, Allocator> >
{
   static const bool value = has_trivial_destructor_after_move<Allocator>::value && has_trivial_destructor_after_move<C>::value;
};

namespace container {

/// @endcond

}}
#include <boost/container/detail/config_end.hpp>
#endif /* BOOST_CONTAINER_MAP_HPP */

 

1. A pair Associative Container is an Associative Container that associates a key with some other object. The value type of a Pair Associative Container is pair<const key_type, data_type>.
2. Models: map; multimap; hash_map; hash_multimap
3. The value type must be pair<const key_type, data_type>, rather than pair<key_type, data_type>, because of the Associative Container invariant of key immutability. The data_type part of an object in a Pair Associative Container may be modified, but the key_type part may not be. Note the implication of this fact: a Pair Associative Container can not provide mutable iterators (as defined in the Trivial Iterator requirements), because the value type of a mutable iterator must be Assignable, and pair<const key_type,data_type> is not Assignable. However, a Pair Associative Container can provide iteratoers that are not completely constant: iterators such that the expression (*i).second = d is valid.
4. Key type: X::key_type The type of the key associated with X::value_type.
5. Data type: X::data_type The type of the data associated with X::value_type. A Pair Associative Container can be thought of as a mapping from key_type to data_type.
6. Value type: X::value_type The type of object stored in the container. The value type is required to be pair<const key_type, data_type>.

Associative Container->Sorted Associative Container

1. A Sorted Associative Container is a type of Associative Container. Sorted Associative Containers use an ordering relation on their keys; two keys are considered to be equivalent if neither one is less than the other. (If the ordering relation is case-insensitive string comparison, for example, then the keys “abcde” and “aBCde” are equivalent.)
2. Sorted Associative Containers guarantee that the complexity for most operations is never worse than logarithmic(对数), and they also guarantee that their elements are always sorted in ascending order by key. (descending order)
3. Two new types are introduced, in addition to the types defined in the Associative Container and Reversible Container requirements.
4.  X::key_compare The type of a Strict Weak Ordering used to compare keys. Its argument type must be X::key_type.
5.  X::value_compare The type of a Strict Weak Ordering used to compare values. Its argument type must be X::value_type, and it compares two objects of value_type by passing the keys associated with those objects to a function object of type key_compare.
6. Complexity guarantees: key_comp() and value_comp() are constant time. Erase element is constant time. Erase key is O (log(size()) + count (k) ). Erase range is O (log (size() ) + N ), where N is the length of the range. Find is logarithmic. Count is O (log (size() ) + count (k). Lower bound, upper bound, and equal range are logarithmic.
7. Definition of value_comp: If t1 and t2 are objects of type X:: value_type and k1 and k2 are the keys associated with those objects, then a,value_comp() returns a function object such that a.value_com() (t1, t2) is equivalent to a.key_comp(k1,k2).
8. Ascending order: The elements in a Sorted Associative Container are always arranged in ascending order by key. That is, if a is a Sorted Associative Container, then is_sorted( a.begin(), a.end() ), a.value_comp() ) is always true.
9. Models: set; multiset; map; multimap
10. This is a much stronger guarantee than the one provided by Associative Container. The guarantees in Associative Container only apply to average complexity; worst case complexity is allowed to be greater. Sorted Associative Container, however, provides an upper limit on worst case complexity.
11. This definition is consistent with the semantics described in Associative Container. It is stronger condition, though: if a contains no elements with the key k, then a.equal_range (k) returns an empty range that indicates the position where those elements would be if they did exist. The Associative Container requirements, however, merely state that the return value is an arbitrary( 1. determined by changce, whim or impulse, and not by necessity ,reason, or principle; 2. Based on or subject to individual judgment or preference) empty range.

Associative Container->Hashed Associative Container

1. A Hashed Associative Container is an Associative Container whose implementation is a hash table. The elements of a Hashed Associative Container are not guaranteed to be in any meaningful order, in particular, they are not sorted. The worst case complexity of most operations on Hashed Associative is linear in the size of the container, but the average case complexity is constant time; this means that for applications where values are simply stored and retrieved, and where ordering is unimportant, Hashed Associative Containers are usually much faster than Sorted Associative Containers.
2. Hash function X::hasher A type that is a model of Hash Function X::hasher’s argument type must be X::key_type.
3. Key equal X::key_equal A Binary_Predicate whose argument type is X::key_type. An object of type key_equal returns true if its arguments are the same key, and false otherwise, X::key_equal must be an equivalence relation.
4. A hash function for a Hased Associative Container X is a Unary Function with argument X::key_type and whose return type is size_t. A hash function must be deterministic ( that is, it must always return the same value whenever it is called with the same argument), but return values of the hash function should be as uniform as possible: ideally, no two keys will hash to the same value.
5. Elements in a Hashed Associative Container are organized into buckets. A Hashed Associative Container uses the value of the hash function to determine which bucket an element is assigned to.
6. The number of elements in a Hashed Associative Container divided by the number of buckets is called the load factor. A Hashed Associative Container with a small load factor is faster than one with a large load factor.
7. The default constructor, constructor with bucket count, constructor with hash function, and constructor with key equal, are all amortized constant time.
8. Hash Function and Key Equal are amortized constant time.
9. Average complexity for Erase key is O(count(k). Worst case is linear in the size of the container.
10. Erase Element is amortized constant time. Average complexity for Erase Range is O(N), where N is the length of the range being erased. Worse case is linear in the size of the container.
11. Average complexity for Find is constant time. Worst case is linear in the size of the container. Resize is linear in the size of the container.
12. Models: hash_set; hash_map; hash_multiset; hash_multimap.
13. There is an extensive literature dealing with hash tables. If the hash function is poor( that is, if many different keys hash to the same value) then this will hurt performance. The worst case is where every key hashes to the same value, in this case, run-time complexity of most Hashed Associative Container operations will be liner in the size of the container.
14. Resizing does not invalidate iterators; however, it does not necessarily preserve the ordering relation between iterators. That is, if I and j are iterators that point into a Hashed Associative Container such that I comes immediately before j, then there is no guarantee that I will still come immediately before j after the container is resized. The only guarantee about the ordering of elements is the contiguous storage invariant: elements with the same key are always adjacent to each other.

Sequences->Vector

1. A vector is a Sequence that supports random access to elements, constant time insertion and removal of elements at the end, and linear time insertion and removal of elements at the beginning or in the middle. The number of elements in a vector may vary dynamically; memory management is automatic. Vector is the simplest of the STL container classes, and in many cases the most efficient.
2. This member function relies on member template functions, which at present are not supported by all compilers. If your compiler supports member templates, you can call this function with any type of input_iterator. If your compiler does not yet supports member templates, though, then the arguments must be of type const value_type*
3. Memory will be reallocated automatically if more than capacity() – size() elements are inserted into the vector. Reallocation does not change size(), nor does it change the values of any elements of the vector. It does, however, increase capacity(), and it invalidates any iterators that point into the vector.
4. When it is necessary to increase capacity(), vector usually increases it by a factor of two. It is crucial that the amount of growth is proportional to the current capacity(), rather than a fixed constant: in the former case inserting a series of elements into a vector is a linear time operation, and in the latter case it is quadratic (of, relating to or containing quantities of the second degree).
5. Reserve() causes a reallocation manually. The main reason for using reserve() is efficiency. If you know the capacity to which your vector must eventually grow, then it is usually more efficient to allocate that memory all at once rather than relying on the automatic reallocation scheme. The other reason for using reserve() is so that you can control the invalidation of iterator.
6. A vector’s iterators are invalidated when its memory is reallocated. Additionally, inserting or deleting an element in the middle of a vector invalidates all iterators that point to elements following the insertion or deletion point. It follows that you can prevent a vector’s iterators from being invalidates if you use reserve() to preallocate as much memory as vector will ever use, and if all insertions and deletions are at the vector’s end.

Sequences->deque

1. A deque is very much like a vector, it is a sequence that supports random access to elements, constant time insertion and removal of elements at the end of the sequence, and linear time insertion and removal of elements in the middle.
2. The main way in which differs from vector is that deque also supports constant time insertion and removal of element at the beginning of the sequence. Additionally, deque does not have any member functions analogous/similar to vector’s capacity() and reserve(), and does not provide any of the guarantees on iterator validity that are associated with those member functions.
3. The name deque is pronounced “deck”, and stands for “double-ended queue.”
4. Inserting an element at the beginning or end of a deque takes amortized constant time. Inserting an element in the middle is linear in n, where n is the smaller of the number of elements from the insertion point to the beginning and the number of elements from the insertion point to the end.
5. The semantics of iterator invalidation for deque is as follows. Insert(including push_front and push_back) invalidates all iterators that refer to a deque. Erase in the middle /midst of a deque invalidates all iterators that refer to the deque. Erase at the beginning or end of a deque (including pop_front and pop_back() )invalidates an iterator only if it points to the erased element.
6. This member function relies on member template functions, which at present are not supported by all compilers. If your compiler supports member templates, you can call this function with any type of input_iterator. If your compiler does not yet support member templates, though, then the arguments must either be of type const value_type * or of type deque::const_iterator.

Sequences->list<T, Alloc>

1. A list is a doubly linked list. That is, That is to say, Namely, it is a Sequence that supports both forward and backward traversal, and constant time insertion and removal of elements at the beginning or the end, or in the middle. Lists have the important property that insertion and splicing do not invalidate interators to list elements, and that even removal invalidates only the iterators that point to the elements that are removed.
2. The ordering of iterators may be changed (that is, list<T>::iterator might have a different predecessor or successor after a list operation than it did before), but the iterators themselves will not be invalidated or made to point to different elements unless that invalidation or mutation is explicit.
3. Note that singly linked lists, which only support forward traversal, are also sometimes useful. If you do not need backward traversal, then slist may be more efficient than list.
4. A comparison with vector is instructive. Suppose that I is a valid vector<T>::iterator. If an element is inserted or removed in a position that precedes I, then this operation will either result in I pointing to a different element than it did before, or else it will invalidate I entirely. 
5. A vector<T>::iterator will be invalidated if an insertion requires a reallocation. 
6. However, suppose that I and j are both iterators into a vector, and there exists some integer n such that I == j + n. In that case, even if elements are inserted into to vector and I and j point to different elements, the relation between iterators will still hold.
7. A list is exactly the opposite: iterators predecessor/successor relationship is not invariant.
8. A similar property holds for all version of insert() and erase(). List <T, Alloc>:: insert never invalidates any iterator, and erase() only invalidates iterators pointing to the elements that are actually being erased.
9. If L is a list, note that L.reverse() and reverse(L.begin(), L.end() ) are both correct ways of reversing the list. They differ in that L.reverse() will preserve the values that each iterator into L points to but will not preserve the iterators’ predecessor/successor relationships, while reverse (L.begin(), L.end() ) will not preserve the value that each iterator points to but will preserve the iterators’ predecessor /successor relationships. Note also that algorithm reverse (L.begin(), L.end() ) will use T’s assignment operator, while the member function L.reverse() will not.
10. The sort algorithm works only for random access iterators. In principle, however, it would be possible to write a sort algorithm that also accepted bidirectional iterators. Even if there were such a version of sort. It would still be useful for list to have a sort member function. That is, sort is provided as a member function not only for the sake of efficiency, but also because of the property that it preserves the values that list iterators point to.

Associative Container->set<Key, Compare, Alloc>

1. Set is a Sorted Associative Container that stores objects of type Key. Set is a Simple Associative Container, meaning that its value type, as well as its key type, is Key. It is also a Unique Associative Container, meaning that no two elements are the same.
2. Set and multiset are particular well suited to the set algorithm includes, set_union, set_intersection, set_difference, and set_symetric_difference. The reason for this is twofold/diplex/diploid/double/dual/duple. First, the set algorithms require their arguments to be sorted ranges, and, since set and multiset are Sorted Associative Containers, their elements are always sorted in ascending order. Second, the output range of these algorithms is always sorted, and inserting a sorted range into a set or multiset is a fast operation: the Unique Sorted Associative Container and Multiple Sorted Associative Container requirements guarantee that inserting a range takes only linear time if the range is already sorted.
3. Set has the important property that inserting a new element into a set does not invalidate iterators that point to existing element. Erasing an element from a set also does not invalidate any iterators, except, of course, for iterators that actually point to the element that is being removed /deleted /cut off /eliminated/got rod of.
4. Key: The set’s key type and value type. This is also defined as set::key_type and set::value_type.
5. Compare: The Key comparison function, a Strict Weak Ordering whose argument type is key_type; it returns ture if its first argument is less than its second argument, and false otherwise. This is also defined as set::key_compare and set::value_compare.
6. Alloc: The set’s allocator, used for all internal memory management.

Associative Container-->map<Key,Data, Compare, Alloc>

1. Map is a Sorted Associative Container that associates objects of type Key with objects of type Data. Map is a Pair Associative Container, meaning that its value type is pair<const Key, Data>. It is also a Unique Associative Container, meaning that no two elements have the same key.
2. Map has the important property that inserting a new element into a map does not invalidate iterators that point to existing element. Erasing an element from a set also does not invalidate any interators, except, of course, for iterators that actually point to the element that is being erased.
3. Compare has the default implementation which is less<key>; less is a template function, just like template <class _Tp>struct less : public binary_function<_Tp,_Tp,tBool> { tBool operator()(const _Tp& __x, const _Tp& __y) const { return __x < __y? TRUE:FALSE; }};
4. Type requirements: Data is Assignable; Compare is a Strict Weak Ordering whose argument type is key to be as template less argument type. Alloc is an Allocator.
5. New members: data_type & operator[ ] (const key_type &k) Returns a reference to the object that is associated with a particular key. If the map does not already contain such an object, operator[ ] inserts the default object data_type().
6. Map::iterator is not a mutable iterator, because map::value_type is not Assignable. That is, if I is of type map::iterator and p is of type map::value_type, then *I = p is not valid expression. However, map::iterator is not a constant iterator either, because it can be used to modify the object that it points to. Using the same notation as above, (*i) . second = p is a valid expression. The same point applies to map::reverse_iterator.
7. Since operator[ ] might insert a new element into the map, it can’t possibly be a const member function. Note that the definition of operator [ ] is extremely simple: m[k] is equivalent to (* (( m.insert (value_type (k, data_type() ) ) ).first )) . second. Strictly speaking, this member function is unnecessary, it exists only for convenience.

 AutoPtr 

//Forward declaretion, TEMPLATE CLASS auto_ptr
template<class _Ty>
class auto_ptr;

template<class _Ty>
struct auto_ptr_ref
{    // proxy reference for auto_ptr copying
   explicit auto_ptr_ref(_Ty *_Right): _Ref(_Right)
   {    // construct from generic pointer to auto_ptr ptr
   }
  _Ty *_Ref;    // generic pointer to auto_ptr ptr
};

template<class _Ty>
class auto_ptr
{    // wrap an object pointer to ensure destruction
public:
    typedef auto_ptr<_Ty> _Myt;
    typedef _Ty element_type;
    explicit auto_ptr(_Ty *_Ptr = 0) _THROW0(): _Myptr(_Ptr)
    {    // construct from object pointer
    }
    auto_ptr(_Myt& _Right) _THROW0(): _Myptr(_Right.release())
    {    // construct by assuming pointer from _Right auto_ptr
    }
    auto_ptr(auto_ptr_ref<_Ty> _Right) _THROW0()
    {    // construct by assuming pointer from _Right auto_ptr_ref
        _Ty *_Ptr = _Right._Ref;
        _Right._Ref = 0;    // release old
        _Myptr = _Ptr;    // reset this
    }

    template<class _Other>
    operator auto_ptr<_Other>() _THROW0()
    {    // convert to compatible auto_ptr
         return (auto_ptr<_Other>(*this));
    }

    template<class _Other>
        operator auto_ptr_ref<_Other>() _THROW0()
        {    // convert to compatible auto_ptr_ref
        _Other *_Cvtptr = _Myptr;    // test implicit conversion
        auto_ptr_ref<_Other> _Ans(_Cvtptr);
        _Myptr = 0;    // pass ownership to auto_ptr_ref
        return (_Ans);
        }

    template<class _Other>
        _Myt& operator=(auto_ptr<_Other>& _Right) _THROW0()
        {    // assign compatible _Right (assume pointer)
        reset(_Right.release());
        return (*this);
        }

    template<class _Other>
        auto_ptr(auto_ptr<_Other>& _Right) _THROW0()
        : _Myptr(_Right.release())
        {    // construct by assuming pointer from _Right
        }

    _Myt& operator=(_Myt& _Right) _THROW0()
        {    // assign compatible _Right (assume pointer)
        reset(_Right.release());
        return (*this);
        }

    _Myt& operator=(auto_ptr_ref<_Ty> _Right) _THROW0()
        {    // assign compatible _Right._Ref (assume pointer)
        _Ty *_Ptr = _Right._Ref;
        _Right._Ref = 0;    // release old
        reset(_Ptr);    // set new
        return (*this);
        }

    ~auto_ptr()
    {    // destroy the object
        delete _Myptr;
    }

    _Ty& operator*() const _THROW0()
    {    // return designated value
 #if _ITERATOR_DEBUG_LEVEL == 2
        if (_Myptr == 0)
            _DEBUG_ERROR("auto_ptr not dereferencable");
 #endif /* _ITERATOR_DEBUG_LEVEL == 2 */

        return (*get());
    }

    _Ty *operator->() const _THROW0()
    {    // return pointer to class object
 #if _ITERATOR_DEBUG_LEVEL == 2
        if (_Myptr == 0)
            _DEBUG_ERROR("auto_ptr not dereferencable");
 #endif /* _ITERATOR_DEBUG_LEVEL == 2 */

        return (get());
    }

    _Ty *get() const _THROW0()
    {    // return wrapped pointer
        return (_Myptr);
    }
    _Ty *release() _THROW0()
    {    // return wrapped pointer and give up ownership
        _Ty *_Tmp = _Myptr;
        _Myptr = 0;
        return (_Tmp);
    }

    void reset(_Ty *_Ptr = 0)
    {    // destroy designated object and store new pointer
        if (_Ptr != _Myptr)
            delete _Myptr;
        _Myptr = _Ptr;
    }
private:
    _Ty *_Myptr;    // the wrapped object pointer
    };
_STD_END

Allocator 

// xmemory internal header (from <memory>)
#pragma once
#ifndef _XMEMORY_
#define _XMEMORY_
#ifndef RC_INVOKED
#include <cstdlib>
#include <new>
#include <xutility>

#pragma pack(push,_CRT_PACKING)
#pragma warning(push,3)


#pragma push_macro("new")
#undef new

#pragma warning(disable: 4100)

#ifndef _FARQ    /* specify standard memory model */
#define _FARQ
#define _PDFT    ptrdiff_t
#define _SIZT    size_t
#endif /* _FARQ */

_STD_BEGIN
// TEMPLATE FUNCTION _Allocate
template<class _Ty> inline    _Ty _FARQ *_Allocate(_SIZT _Count, _Ty _FARQ *)
{    // allocate storage for _Count elements of type _Ty
    void *_Ptr = 0;
    if (_Count <= 0)
        _Count = 0;
    else if (((_SIZT)(-1) / sizeof (_Ty) < _Count)
        || (_Ptr = ::operator new(_Count * sizeof (_Ty))) == 0)
        _THROW_NCEE(bad_alloc, 0);
    return ((_Ty _FARQ *)_Ptr);
}

// TEMPLATE FUNCTION _Construct
template<class _Ty1,
class _Ty2> inline
void _Construct(_Ty1 _FARQ *_Ptr, _Ty2&& _Val)
{    // construct object at _Ptr with value _Val
    void _FARQ *_Vptr = _Ptr;
    ::new (_Vptr) _Ty1(_STD forward<_Ty2>(_Val));
}

template<class _Ty1> inline
void _Construct(_Ty1 _FARQ *_Ptr)
{    // construct object at _Ptr with default value
    void _FARQ *_Vptr = _Ptr;
    ::new (_Vptr) _Ty1();
}

// TEMPLATE FUNCTION _Destroy
template<class _Ty> inline
void _Destroy(_Ty _FARQ *_Ptr)
{    // destroy object at _Ptr
    _Ptr->~_Ty();
}

template<> inline
void _Destroy(char _FARQ *)
{    // destroy a char (do nothing)
}

template<> inline
void _Destroy(wchar_t _FARQ *)
{    // destroy a wchar_t (do nothing)
}

#ifdef _NATIVE_WCHAR_T_DEFINED
template<> inline
void _Destroy(unsigned short _FARQ *)
{    // destroy a unsigned short (do nothing)
}
#endif /* _NATIVE_WCHAR_T_DEFINED */

    // TEMPLATE FUNCTION _Destroy_range
template<class _Alloc> inline
void _Destroy_range(typename _Alloc::pointer _First,typename _Alloc::pointer _Last, _Alloc& _Al)
{    // destroy [_First, _Last)
    _Destroy_range(_First, _Last, _Al, _Ptr_cat(_First, _Last));
}

template<class _Alloc> inline
void _Destroy_range(typename _Alloc::pointer _First,typename _Alloc::pointer _Last, _Alloc& _Al,
    _Nonscalar_ptr_iterator_tag)
{    // destroy [_First, _Last), arbitrary type
    for (; _First != _Last; ++_First)
        _Dest_val(_Al, _First);
}

template<class _Alloc> inline
void _Destroy_range(typename _Alloc::pointer _First,typename _Alloc::pointer _Last, _Alloc& _Al,
    _Scalar_ptr_iterator_tag)
{    // destroy [_First, _Last), scalar type (do nothing)
}

    // TEMPLATE FUNCTION addressof
template<class _Ty> inline
_Ty * addressof(_Ty& _Val)
{    // return address of _Val
     ((_Ty *) &(char&)_Val);
}

    // TEMPLATE CLASS _Allocator_base
template<class _Ty>
struct _Allocator_base
{    // base class for generic allocators
   typedef _Ty value_type;
};

    // TEMPLATE CLASS _Allocator_base<const _Ty>
template<class _Ty>
struct _Allocator_base<const _Ty>
{    // base class for generic allocators for const _Ty
   typedef _Ty value_type;
};

    // TEMPLATE CLASS allocator
template<class _Ty>
class allocator: public _Allocator_base<_Ty>
{    // generic allocator for objects of class _Ty
    public:
    typedef _Allocator_base<_Ty> _Mybase;
    typedef typename _Mybase::value_type value_type;

    typedef value_type _FARQ *pointer;
    typedef value_type _FARQ& reference;
    typedef const value_type _FARQ *const_pointer;
    typedef const value_type _FARQ& const_reference;

    typedef _SIZT size_type;
    typedef _PDFT difference_type;

    template<class _Other>
    struct rebind
    {    // convert this type to allocator<_Other>
       typedef allocator<_Other> other;
    };

    pointer address(reference _Val) const
    {    // return address of mutable _Val
       return ((pointer) &(char&)_Val);
    }
    const_pointer address(const_reference _Val) const
    {    // return address of nonmutable _Val
       return ((const_pointer) &(char&)_Val);
    }
    allocator() _THROW0()
    {    // construct default allocator (do nothing)
    }

   allocator(const allocator<_Ty>&) _THROW0()
    {    // construct by copying (do nothing)
    }

    template<class _Other>
    allocator(const allocator<_Other>&) _THROW0()
    {    // construct from a related allocator (do nothing)
    }

    template<class _Other>
    allocator<_Ty>& operator=(const allocator<_Other>&)
    {    // assign from a related allocator (do nothing)
       return (*this);
    }

    void deallocate(pointer _Ptr, size_type)
    {    // deallocate object at _Ptr, ignore size
       ::operator delete(_Ptr);
    }
    pointer allocate(size_type _Count)
    {    // allocate array of _Count elements
       return (_Allocate(_Count, (pointer)0));
    }
    pointer allocate(size_type _Count, const void _FARQ *)
    {    // allocate array of _Count elements, ignore hint
       return (allocate(_Count));
    }
    void construct(pointer _Ptr, const _Ty& _Val)
    {    // construct object at _Ptr with value _Val
       _Construct(_Ptr, _Val);
    }
    void construct(pointer _Ptr, _Ty&& _Val)
    {    // construct object at _Ptr with value _Val
       ::new ((void _FARQ *)_Ptr) _Ty(_STD forward<_Ty>(_Val));
    }

    template<class _Other>
    void construct(pointer _Ptr, _Other&& _Val)
    {    // construct object at _Ptr with value _Val
       ::new ((void _FARQ *)_Ptr) _Ty(_STD forward<_Other>(_Val));
    }

    void destroy(pointer _Ptr)
    {    // destroy object at _Ptr
        _Destroy(_Ptr);
    }

    _SIZT max_size() const _THROW0()
    {    // estimate maximum array size
        _SIZT _Count = (_SIZT)(-1) / sizeof (_Ty);
        return (0 < _Count ? _Count : 1);
    }
};

    // CLASS allocator<void>
template<> class allocator<void>
{    // generic allocator for type void
    public:
    typedef void _Ty;
    typedef _Ty _FARQ *pointer;
    typedef const _Ty _FARQ *const_pointer;
    typedef _Ty value_type;

    template<class _Other>
    struct rebind
    {    // convert this type to an allocator<_Other>
        typedef allocator<_Other> other;
    };

    allocator() _THROW0()
    {    // construct default allocator (do nothing)
    }

    allocator(const allocator<_Ty>&) _THROW0()
    {    // construct by copying (do nothing)
    }

    template<class _Other>
    allocator(const allocator<_Other>&) _THROW0()
    {    // construct from related allocator (do nothing)
    }

    template<class _Other>
    allocator<_Ty>& operator=(const allocator<_Other>&)
    {    // assign from a related allocator (do nothing)
        return (*this);
    }
};

template<class _Ty,class _Other> inline
bool operator==(const allocator<_Ty>&,const allocator<_Other>&) _THROW0()
{    // test for allocator equality
    return (true);
}
template<class _Ty,class _Other> 
inline bool operator!=(const allocator<_Ty>& _Left,const allocator<_Other>& _Right) _THROW0()
{    // test for allocator inequality
    return (!(_Left == _Right));
}

    // TEMPLATE FUNCTIONS _Cons_val AND _Dest_val
template<class _Alloc,class _Ty1,class _Ty2>
void _Cons_val(_Alloc& _Alval, _Ty1 *_Pdest, _Ty2&& _Src)
{    // construct using allocator
    _Alval.construct(_Pdest, _STD forward<_Ty2>(_Src));
}

template<class _Alloc,class _Ty1>
void _Dest_val(_Alloc& _Alval, _Ty1 *_Pdest)
{    // destroy using allocator
    _Alval.destroy(_Pdest);
}
_STD_END

#pragma pop_macro("new")

#pragma warning(pop)
#pragma pack(pop)

#endif /* RC_INVOKED */
#endif /* _XMEMORY_ */

 PtrBase      

// TEMPLATE CLASS _Ptr_base
template<class _Ty> class _Ptr_base
{    // base class for shared_ptr and weak_ptr
    public:
    typedef _Ptr_base<_Ty> _Myt;
    typedef _Ty _Elem;
    typedef _Elem element_type;

    _Ptr_base(): _Ptr(0), _Rep(0)
    {    // construct
    }

    _Ptr_base(_Myt&& _Right): _Ptr(0), _Rep(0)
    {    // construct _Ptr_base object that takes resource from _Right
    _Assign_rv(_STD forward<_Myt>(_Right));
    }

    template<class _Ty2> _Ptr_base(_Ptr_base<_Ty2>&& _Right): _Ptr(_Right._Ptr), _Rep(_Right._Rep)
    {    // construct _Ptr_base object that takes resource from _Right
    _Right._Ptr = 0;
    _Right._Rep = 0;
    }

    _Myt& operator=(_Myt&& _Right)
    {    // construct _Ptr_base object that takes resource from _Right
    _Assign_rv(_STD forward<_Myt>(_Right));
    return (*this);
    }

    void _Assign_rv(_Myt&& _Right)
    {    // assign by moving _Right
    if (this != &_Right)
        _Swap(_Right);
    }

    long use_count() const
    {    // return use count
    return (_Rep ? _Rep->_Use_count() : 0);
    }

    void _Swap(_Ptr_base& _Right)
    {    // swap pointers
    _STD swap(_Rep, _Right._Rep);
    _STD swap(_Ptr, _Right._Ptr);
    }

    template<class _Ty2>
    bool owner_before(const _Ptr_base<_Ty2>& _Right) const
    {    // compare addresses of manager objects
    return (_Rep < _Right._Rep);
    }

    void *_Get_deleter(const _XSTD2 type_info& _Type) const
    {    // return pointer to deleter object if its type is _Type
    return (_Rep ? _Rep->_Get_deleter(_Type) : 0);
    }

    _Ty *_Get() const
    {    // return pointer to resource
    return (_Ptr);
    }

    bool _Expired() const
    {    // test if expired
    return (!_Rep || _Rep->_Expired());
    }

    void _Decref()
    {    // decrement reference count
    if (_Rep != 0)
        _Rep->_Decref();
    }

    void _Reset()
    {    // release resource
    _Reset(0, 0);
    }

    template<class _Ty2>
    void _Reset(const _Ptr_base<_Ty2>& _Other)
    {    // release resource and take ownership of _Other._Ptr
    _Reset(_Other._Ptr, _Other._Rep, false);
    }

    template<class _Ty2>
    void _Reset(const _Ptr_base<_Ty2>& _Other, bool _Throw)
    {    // release resource and take ownership from weak_ptr _Other._Ptr
    _Reset(_Other._Ptr, _Other._Rep, _Throw);
    }

    template<class _Ty2>
    void _Reset(const _Ptr_base<_Ty2>& _Other, const _Static_tag&)
    {    // release resource and take ownership of _Other._Ptr
    _Reset(static_cast<_Elem *>(_Other._Ptr), _Other._Rep);
    }

    template<class _Ty2>
    void _Reset(const _Ptr_base<_Ty2>& _Other, const _Const_tag&)
    {    // release resource and take ownership of _Other._Ptr
        _Reset(const_cast<_Elem *>(_Other._Ptr), _Other._Rep);
    }

    template<class _Ty2>
    void _Reset(const _Ptr_base<_Ty2>& _Other, const _Dynamic_tag&)
    {    // release resource and take ownership of _Other._Ptr
        _Elem *_Ptr = dynamic_cast<_Elem *>(_Other._Ptr);
        if (_Ptr)
            _Reset(_Ptr, _Other._Rep);
        else
            _Reset();
    }
    template<class _Ty2>
    void _Reset(auto_ptr<_Ty2>& _Other)
    {    // release resource and take _Other.get()
        _Ty2 *_Px = _Other.get();
        _Reset0(_Px, new _Ref_count<_Elem>(_Px));
        _Other.release();
        _Enable_shared(_Px, _Rep);
    }
    void _Reset(_Ty *_Other_ptr, _Ref_count_base *_Other_rep)
    {    // release resource and take _Other_ptr through _Other_rep
        if (_Other_rep)
            _Other_rep->_Incref();
        _Reset0(_Other_ptr, _Other_rep);
    }
    void _Reset(_Ty *_Other_ptr, _Ref_count_base *_Other_rep, bool _Throw)
    {    // take _Other_ptr through _Other_rep from weak_ptr if not expired
            // otherwise, leave in default state if !_Throw,
            // otherwise throw exception
        if (_Other_rep && _Other_rep->_Incref_nz())
            _Reset0(_Other_ptr, _Other_rep);
        else if (_Throw)
            _THROW_NCEE(bad_weak_ptr, 0);
    }
    void _Reset0(_Ty *_Other_ptr, _Ref_count_base *_Other_rep)
    {    // release resource and take new resource
        if (_Rep != 0)
            _Rep->_Decref();
        _Rep = _Other_rep;
        _Ptr = _Other_ptr;
    }
    void _Decwref()
    {    // decrement weak reference count
        if (_Rep != 0)
            _Rep->_Decwref();
    }
    void _Resetw()
    {    // release weak reference to resource
        _Resetw((_Elem *)0, 0);
    }
    template<class _Ty2>
    void _Resetw(const _Ptr_base<_Ty2>& _Other)
    {    // release weak reference to resource and take _Other._Ptr
        _Resetw(_Other._Ptr, _Other._Rep);
    }
    template<class _Ty2>
    void _Resetw(const _Ty2 *_Other_ptr, _Ref_count_base *_Other_rep)
    {    // point to _Other_ptr through _Other_rep
        _Resetw(const_cast<_Ty2*>(_Other_ptr), _Other_rep);
    }
    template<class _Ty2>
    void _Resetw(_Ty2 *_Other_ptr, _Ref_count_base *_Other_rep)
    {    // point to _Other_ptr through _Other_rep
        if (_Other_rep)
            _Other_rep->_Incwref();
        if (_Rep != 0)
            _Rep->_Decwref();
        _Rep = _Other_rep;
        _Ptr = _Other_ptr;
    }
    private:
        _Ty *_Ptr;
        _Ref_count_base *_Rep;
        template<class _Ty0> friend class _Ptr_base;
};

SharedPtr     

// TEMPLATE CLASS shared_ptr
template<class _Ty> class shared_ptr: public _Ptr_base<_Ty>
{    // class for reference counted resource management
    public:
    typedef shared_ptr<_Ty> _Myt;
    typedef _Ptr_base<_Ty> _Mybase;

    shared_ptr()
    {    // construct empty shared_ptr object
    }
    template<class _Ux>
    explicit shared_ptr(_Ux *_Px)
    {    // construct shared_ptr object that owns _Px
        _Resetp(_Px);
    }
    template<class _Ux,class _Dx>
    shared_ptr(_Ux *_Px, _Dx _Dt)
    {    // construct with _Px, deleter
        _Resetp(_Px, _Dt);
    }
    shared_ptr(_STD nullptr_t)
    {    // construct with nullptr
        _Resetp((_Ty *)0);
    }
    template<class _Dx>
    shared_ptr(_STD nullptr_t, _Dx _Dt)
    {    // construct with nullptr, deleter
        _Resetp((_Ty *)0, _Dt);
    }
    template<class _Dx,class _Alloc>
    shared_ptr(_STD nullptr_t, _Dx _Dt, _Alloc _Ax)
    {    // construct with nullptr, deleter, allocator
        _Resetp((_Ty *)0, _Dt, _Ax);
    }
    template<class _Ux,class _Dx,class _Alloc>
    shared_ptr(_Ux *_Px, _Dx _Dt, _Alloc _Ax)
    {    // construct with _Px, deleter, allocator
        _Resetp(_Px, _Dt, _Ax);
    }
    shared_ptr(const _Myt& _Other)
    {    // construct shared_ptr object that owns same resource as _Other
        this->_Reset(_Other);
    }
    template<class _Ty2>
    shared_ptr(const shared_ptr<_Ty2>& _Other,typename enable_if<is_convertible<_Ty2 *, _Ty *>::value,
               void *>::type * = 0)
    {    // construct shared_ptr object that owns same resource as _Other
        this->_Reset(_Other);
    }
    template<class _Ty2>
    explicit shared_ptr(const weak_ptr<_Ty2>& _Other,bool _Throw = true)
    {    // construct shared_ptr object that owns resource *_Other
        this->_Reset(_Other, _Throw);
    }
    template<class _Ty2>
    shared_ptr(auto_ptr<_Ty2>& _Other)
    {    // construct shared_ptr object that owns *_Other.get()
        this->_Reset(_Other);
    }
    template<class _Ty2>
    shared_ptr(const shared_ptr<_Ty2>& _Other, const _Static_tag& _Tag)
    {    // construct shared_ptr object for static_pointer_cast
        this->_Reset(_Other, _Tag);
    }
    template<class _Ty2>
    shared_ptr(const shared_ptr<_Ty2>& _Other, const _Const_tag& _Tag)
    {    // construct shared_ptr object for const_pointer_cast
        this->_Reset(_Other, _Tag);
    }
    template<class _Ty2>
    shared_ptr(const shared_ptr<_Ty2>& _Other, const _Dynamic_tag& _Tag)
    {    // construct shared_ptr object for dynamic_pointer_cast
        this->_Reset(_Other, _Tag);
    }
    shared_ptr(_Myt&& _Right): _Mybase(_STD forward<_Myt>(_Right))
    {    // construct shared_ptr object that takes resource from _Right
    }
    template<class _Ty2>
    shared_ptr(shared_ptr<_Ty2>&& _Right,typename enable_if<is_convertible<_Ty2 *, _Ty *>::value,
              void *>::type * = 0): _Mybase(_STD forward<shared_ptr<_Ty2> >(_Right))
    {    // construct shared_ptr object that takes resource from _Right
    }
    _Myt& operator=(_Myt&& _Right)
    {    // construct shared_ptr object that takes resource from _Right
        shared_ptr(_STD move(_Right)).swap(*this);
        return (*this);
    }
    template<class _Ty2>
    _Myt& operator=(shared_ptr<_Ty2>&& _Right)
    {    // construct shared_ptr object that takes resource from _Right
        shared_ptr(_STD move(_Right)).swap(*this);
        return (*this);
    }
    void swap(_Myt&& _Right)
    {    // exchange contents with movable _Right
        _Mybase::swap(_STD move(_Right));
    }
    ~shared_ptr()
    {    // release resource
        this->_Decref();
    }
    _Myt& operator=(const _Myt& _Right)
    {    // assign shared ownership of resource owned by _Right
        shared_ptr(_Right).swap(*this);
        return (*this);
    }
    template<class _Ty2>
    _Myt& operator=(const shared_ptr<_Ty2>& _Right)
    {    // assign shared ownership of resource owned by _Right
        shared_ptr(_Right).swap(*this);
        return (*this);
    }
    template<class _Ty2>
    _Myt& operator=(auto_ptr<_Ty2>& _Right)
    {    // assign ownership of resource pointed to by _Right
        shared_ptr(_Right).swap(*this);
        return (*this);
    }
    void reset()
    {    // release resource and convert to empty shared_ptr object
        shared_ptr().swap(*this);
    }
    template<class _Ux>
    void reset(_Ux *_Px)
    {    // release, take ownership of _Px
        shared_ptr(_Px).swap(*this);
    }
    template<class _Ux,class _Dx>
    void reset(_Ux *_Px, _Dx _Dt)
    {    // release, take ownership of _Px, with deleter _Dt
        shared_ptr(_Px, _Dt).swap(*this);
    }
    //#if _HAS_CPP0X
    template<class _Ux,    class _Dx,    class _Alloc>
    void reset(_Ux *_Px, _Dx _Dt, _Alloc _Ax)
    {    // release, take ownership of _Px, with deleter _Dt, allocator _Ax
        shared_ptr(_Px, _Dt, _Ax).swap(*this);
    }
    //#endif /* _HAS_CPP0X */
    void swap(_Myt& _Other)
    {    // swap pointers
        this->_Swap(_Other);
    }
    _Ty *get() const
    {    // return pointer to resource
        return (this->_Get());
    }
    typename tr1::add_reference<_Ty>::type operator*() const
    {    // return reference to resource
        return (*this->_Get());
    }
    _Ty *operator->() const
    {    // return pointer to resource
        return (this->_Get());
    }
    bool unique() const
    {    // return true if no other shared_ptr object owns this resource
        return (this->use_count() == 1);
    }    
    _OPERATOR_BOOL() const
    {    // test if shared_ptr object owns no resource
        return (this->_Get() != 0 ? _CONVERTIBLE_TO_TRUE : 0);
    }
private:
    template<class _Ux>
    void _Resetp(_Ux *_Px)
    {    // release, take ownership of _Px
        _TRY_BEGIN    // allocate control block and reset
        _Resetp0(_Px, new _Ref_count<_Ux>(_Px));
        _CATCH_ALL    // allocation failed, delete resource
        delete _Px;
        _RERAISE;
        _CATCH_END
    }
    template<class _Ux,class _Dx>
    void _Resetp(_Ux *_Px, _Dx _Dt)
    {    // release, take ownership of _Px, deleter _Dt
        _TRY_BEGIN    // allocate control block and reset
        _Resetp0(_Px, new _Ref_count_del<_Ux, _Dx>(_Px, _Dt));
        _CATCH_ALL    // allocation failed, delete resource
        _Dt(_Px);
        _RERAISE;
        _CATCH_END
    }
    //#if _HAS_CPP0X
    template<class _Ux,class _Dx,class _Alloc>
    void _Resetp(_Ux *_Px, _Dx _Dt, _Alloc _Ax)
    {    // release, take ownership of _Px, deleter _Dt, allocator _Ax
        typedef _Ref_count_del_alloc<_Ux, _Dx, _Alloc> _Refd;
        typename _Alloc::template rebind<_Refd>::other _Al = _Ax;

        _TRY_BEGIN    // allocate control block and reset
        _Refd *_Ptr = _Al.allocate(1);
        new (_Ptr) _Refd(_Px, _Dt, _Al);
        _Resetp0(_Px, _Ptr);
        _CATCH_ALL    // allocation failed, delete resource
        _Dt(_Px);
        _RERAISE;
        _CATCH_END
    }
    //#endif /* _HAS_CPP0X */
    public:
    template<class _Ux>
    void _Resetp0(_Ux *_Px, _Ref_count_base *_Rx)
    {    // release resource and take ownership of _Px
        this->_Reset0(_Px, _Rx);
        _Enable_shared(_Px, _Rx);
    }
};
template<class _Ty1,class _Ty2>
bool operator==(const shared_ptr<_Ty1>& _S1,const shared_ptr<_Ty2>& _S2)
{    // test if shared_ptr == shared_ptr
    return (_S1.get() == _S2.get());
}
template<class _Ty1,class _Ty2>
bool operator!=(const shared_ptr<_Ty1>& _S1,const shared_ptr<_Ty2>& _S2)
{    // test if shared_ptr != shared_ptr
    return (!(_S1 == _S2));
}
template<class _Ty1,class _Ty2>
bool operator<(const shared_ptr<_Ty1>& _S1,const shared_ptr<_Ty2>& _S2)
{    // test if shared_ptr < shared_ptr
    return (_S1.get() < _S2.get());
}
template<class _Ty1,class _Ty2>
bool operator>=(const shared_ptr<_Ty1>& _S1,const shared_ptr<_Ty2>& _S2)
{    // shared_ptr >= shared_ptr
    return (!(_S1 < _S2));
}
template<class _Ty1,class _Ty2>
bool operator>(const shared_ptr<_Ty1>& _S1,const shared_ptr<_Ty2>& _S2)
{    // test if shared_ptr > shared_ptr
    return (_S2 < _S1);
}
template<class _Ty1,class _Ty2>
bool operator<=(const shared_ptr<_Ty1>& _S1,const shared_ptr<_Ty2>& _S2)
{    // test if shared_ptr <= shared_ptr
    return (!(_S2 < _S1));
}
template<class _Elem,class _Traits,class _Ty>
basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Out,const shared_ptr<_Ty>& _Px)
{    // write contained pointer to stream
    return (_Out << _Px.get());
}
template<class _Ty>
void swap(shared_ptr<_Ty>& _Left,shared_ptr<_Ty>& _Right)
{    // swap _Left and _Right shared_ptrs
    _Left.swap(_Right);
}
template<class _Ty>
void swap(shared_ptr<_Ty>& _Left,shared_ptr<_Ty>&& _Right)
{    // swap _Left and _Right shared_ptrs
    _Left.swap(_Right);
}
template<class _Ty>
void swap(shared_ptr<_Ty>&& _Left,shared_ptr<_Ty>& _Right)
{    // swap _Left and _Right shared_ptrs
    _Right.swap(_Left);
}
template<class _Ty1,class _Ty2>
shared_ptr<_Ty1> static_pointer_cast(const shared_ptr<_Ty2>& _Other)
{    // return shared_ptr object holding static_cast<_Ty1 *>(_Other.get())
    return (shared_ptr<_Ty1>(_Other, _Static_tag()));
}
template<class _Ty1,class _Ty2>
shared_ptr<_Ty1> const_pointer_cast(const shared_ptr<_Ty2>& _Other)
{    // return shared_ptr object holding const_cast<_Ty1 *>(_Other.get())
    return (shared_ptr<_Ty1>(_Other, _Const_tag()));
}
template<class _Ty1,class _Ty2>
shared_ptr<_Ty1> dynamic_pointer_cast(const shared_ptr<_Ty2>& _Other)
{    // return shared_ptr object holding dynamic_cast<_Ty1 *>(_Other.get())
    return (shared_ptr<_Ty1>(_Other, _Dynamic_tag()));
}
template<class _Dx,class _Ty>
_Dx *get_deleter(const shared_ptr<_Ty>& _Sx)
{    // return pointer to shared_ptr's deleter object if its type is _Ty
    return ((_Dx *)_Sx._Get_deleter(typeid(_Dx)));
}

#if _HAS_CPP0X

// TEMPLATE CLASS _Ref_count_obj
template<class _Ty>
class _Ref_count_obj: public _Ref_count_base
{    // handle reference counting for object in control block, no allocator
    public:
    #define _REF_COUNT_OBJ_CTOR
    #define _INCL_FILE_xxshared
    #include <xfwrap>
    #undef _REF_COUNT_OBJ_CTOR
    _Ty *_Getptr() const
    {    // get pointer
        return ((_Ty *)&_Storage);
    }
    private:
    virtual void _Destroy()
    {    // destroy managed resource
        _Getptr()->~_Ty();
    }
    virtual void _Delete_this()
    {    // destroy self
        delete this;
    }
    typename aligned_storage<sizeof(_Ty),alignment_of<_Ty>::value>::type _Storage;
};
// TEMPLATE CLASS _Ref_count_obj_alloc
template<class _Ty,class _Alloc>
class _Ref_count_obj_alloc: public _Ref_count_base
{    // handle reference counting for object in control block, allocator
    public:
    typedef _Ref_count_obj_alloc<_Ty, _Alloc> _Myty;
    typedef typename _Alloc::template rebind<_Myty>::other _Myalty;

    #define _REF_COUNT_OBJ_ALLOC_CTOR
    #define _INCL_FILE_xxshared
    #include <xfwrap>
    #undef _REF_COUNT_OBJ_ALLOC_CTOR

    _Ty *_Getptr() const
    {    // get pointer
        return ((_Ty *)&_Storage);
    }

private:
    virtual void _Destroy()
    {    // destroy managed resource
        _Getptr()->~_Ty();
    }
    virtual void _Delete_this()
    {    // destroy self
        _Myalty _Al = _Myal;
        _Dest_val(_Al, this);
        _Al.deallocate(this, 1);
    }
    typename aligned_storage<sizeof (_Ty),alignment_of<_Ty>::value>::type _Storage;
    _Myalty _Myal;    // the stored allocator for this
};