Added boost header

test/external/boost/phoenix/stl/container/detail/container.hpp

@@ -0,0 +1,173 @@
+/*=============================================================================
+    Copyright (c) 2004 Angus Leeming
+    Copyright (c) 2004 Joel de Guzman
+
+    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)
+==============================================================================*/
+#ifndef BOOST_PHOENIX_CONTAINER_DETAIL_CONTAINER_HPP
+#define BOOST_PHOENIX_CONTAINER_DETAIL_CONTAINER_HPP
+
+#include <utility>
+#include <boost/mpl/eval_if.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/is_const.hpp>
+
+namespace boost { namespace phoenix { namespace stl
+{
+///////////////////////////////////////////////////////////////////////////////
+//
+//  Metafunctions "value_type_of", "key_type_of" etc.
+//
+//      These metafunctions define a typedef "type" that returns the nested
+//      type if it exists. If not then the typedef returns void.
+//
+//      For example, "value_type_of<std::vector<int> >::type" is "int" whilst
+//      "value_type_of<double>::type" is "void".
+//
+//      I use a macro to define structs "value_type_of" etc simply to cut
+//      down on the amount of code. The macro is #undef-ed immediately after
+//      its final use.
+//
+/////////////////////////////////////////////////////////////////c//////////////
+#define MEMBER_TYPE_OF(MEMBER_TYPE)                                             \
+    template <typename C>                                                       \
+    struct BOOST_PP_CAT(MEMBER_TYPE, _of)                                       \
+    {                                                                           \
+        typedef typename C::MEMBER_TYPE type;                                   \
+    }
+
+    MEMBER_TYPE_OF(allocator_type);
+    MEMBER_TYPE_OF(const_iterator);
+    MEMBER_TYPE_OF(const_reference);
+    MEMBER_TYPE_OF(const_reverse_iterator);
+    MEMBER_TYPE_OF(container_type);
+    MEMBER_TYPE_OF(data_type);
+    MEMBER_TYPE_OF(iterator);
+    MEMBER_TYPE_OF(key_compare);
+    MEMBER_TYPE_OF(key_type);
+    MEMBER_TYPE_OF(reference);
+    MEMBER_TYPE_OF(reverse_iterator);
+    MEMBER_TYPE_OF(size_type);
+    MEMBER_TYPE_OF(value_compare);
+    MEMBER_TYPE_OF(value_type);
+
+#undef MEMBER_TYPE_OF
+
+///////////////////////////////////////////////////////////////////////////////
+//
+//  Const-Qualified types.
+//
+//      Many of the stl member functions have const and non-const
+//      overloaded versions that return distinct types. For example:
+//
+//          iterator begin();
+//          const_iterator begin() const;
+//
+//      The three class templates defined below,
+//      const_qualified_reference_of, const_qualified_iterator_of
+//      and const_qualified_reverse_iterator_of provide a means to extract
+//      this return type automatically.
+//
+///////////////////////////////////////////////////////////////////////////////
+    template <typename C>
+    struct const_qualified_reference_of
+    {
+        typedef typename
+            boost::mpl::eval_if_c<
+                boost::is_const<C>::value
+              , const_reference_of<C>
+              , reference_of<C>
+            >::type
+        type;
+    };
+
+    template <typename C>
+    struct const_qualified_iterator_of
+    {
+        typedef typename
+            boost::mpl::eval_if_c<
+                boost::is_const<C>::value
+              , const_iterator_of<C>
+              , iterator_of<C>
+            >::type
+        type;
+    };
+
+    template <typename C>
+    struct const_qualified_reverse_iterator_of
+    {
+        typedef typename
+            boost::mpl::eval_if_c<
+                boost::is_const<C>::value
+              , const_reverse_iterator_of<C>
+              , reverse_iterator_of<C>
+            >::type
+        type;
+    };
+
+///////////////////////////////////////////////////////////////////////////////
+//
+//  has_mapped_type<C>
+//
+//      Given a container C, determine if it is a map or multimap
+//      by checking if it has a member type named "mapped_type".
+//
+///////////////////////////////////////////////////////////////////////////////
+    namespace stl_impl
+    {
+        struct one { char a[1]; };
+        struct two { char a[2]; };
+
+        template <typename C>
+        one has_mapped_type(typename C::mapped_type(*)());
+
+        template <typename C>
+        two has_mapped_type(...);
+    }
+
+    template <typename C>
+    struct has_mapped_type
+        : boost::mpl::bool_<
+            sizeof(stl_impl::has_mapped_type<C>(0)) == sizeof(stl_impl::one)
+        >
+    {};
+
+///////////////////////////////////////////////////////////////////////////////
+//
+//  map_insert_returns_pair<C>
+//
+//      Distinguish a map from a multimap by checking the return type
+//      of its "insert" member function. A map returns a pair while
+//      a multimap returns an iterator.
+//
+///////////////////////////////////////////////////////////////////////////////
+    namespace stl_impl
+    {
+        //  Cool implementation of map_insert_returns_pair by Daniel Wallin.
+        //  Thanks Daniel!!! I owe you a Pizza!
+
+        template<class A, class B>
+        one map_insert_returns_pair_check(std::pair<A,B> const&);
+
+        template <typename T>
+        two map_insert_returns_pair_check(T const&);
+
+        template <typename C>
+        struct map_insert_returns_pair
+        {
+            static typename C::value_type const& get;
+            BOOST_STATIC_CONSTANT(int,
+                value = sizeof(
+                    map_insert_returns_pair_check(((C*)0)->insert(get))));
+            typedef boost::mpl::bool_<value == sizeof(one)> type;
+        };
+    }
+
+    template <typename C>
+    struct map_insert_returns_pair
+        : stl_impl::map_insert_returns_pair<C>::type {};
+
+}}} // namespace boost::phoenix::stl
+
+#endif // BOOST_PHOENIX_STL_CONTAINER_TRAITS_HPP