Added boost header

test/external/boost/bimap/support/data_type_by.hpp

@@ -0,0 +1,73 @@
+// Boost.Bimap
+//
+// Copyright (c) 2006-2007 Matias Capeletto
+//
+// 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)
+
+/// \file support/data_type_by.hpp
+/// \brief Metafunction to access the data types of a bimap
+
+#ifndef BOOST_BIMAP_SUPPORT_DATA_TYPE_BY_HPP
+#define BOOST_BIMAP_SUPPORT_DATA_TYPE_BY_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER>=1200)
+#pragma once
+#endif
+
+#include <boost/config.hpp>
+
+#include <boost/bimap/relation/detail/metadata_access_builder.hpp>
+
+/** \struct boost::bimaps::support::data_type_by
+
+\brief Metafunction to obtain the data type of one of the sides in a bimap
+
+The tag parameter can be either a user defined tag or \c member_at::{side}.
+This is the actual data type stored in the bimap.
+\code
+
+template< class Tag, class Bimap >
+struct data_type_by
+{
+    typedef typename Bimap::{side}_data_type type;
+};
+
+\endcode
+
+The following holds:
+
+\code
+
+BOOST_STATIC_ASSERT
+(
+    is_same< data_type_by< member_at::left, bimap<A,B> >::type, A >::value
+)
+
+\endcode
+
+See also member_at.
+\ingroup bimap_group
+                                                                    **/
+
+namespace boost {
+namespace bimaps {
+namespace support {
+
+// Implementation of data type of metafunction
+
+BOOST_BIMAP_SYMMETRIC_METADATA_ACCESS_BUILDER
+(
+    data_type_by,
+    left_data_type,
+    right_data_type
+)
+
+} // namespace support
+} // namespace bimaps
+} // namespace boost
+
+
+#endif // BOOST_BIMAP_SUPPORT_DATA_TYPE_BY_HPP
+

test/external/boost/bimap/support/iterator_type_by.hpp

@@ -0,0 +1,228 @@
+// Boost.Bimap
+//
+// Copyright (c) 2006-2007 Matias Capeletto
+//
+// 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)
+
+/// \file support/iterator_type_by.hpp
+/// \brief Metafunctions to access the iterator types of a bimap
+
+#ifndef BOOST_BIMAP_SUPPORT_ITERATOR_TYPE_BY_HPP
+#define BOOST_BIMAP_SUPPORT_ITERATOR_TYPE_BY_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER>=1200)
+#pragma once
+#endif
+
+#include <boost/config.hpp>
+
+#include <boost/bimap/relation/detail/metadata_access_builder.hpp>
+#include <boost/bimap/relation/detail/static_access_builder.hpp>
+
+#include <boost/bimap/relation/support/pair_type_by.hpp>
+
+#include <boost/bimap/detail/map_view_iterator.hpp>
+
+/** \struct boost::bimaps::support::iterator_type_by
+
+\brief Metafunction to obtain the iterator type of the map view by one of the sides.
+
+\code
+
+template< class Tag, class Bimap >
+struct iterator_type_by
+{
+    typedef -unspecified- type;
+};
+
+template< class Tag, class Bimap >
+struct const_iterator_type_by
+{
+    typedef -unspecified- type;
+};
+
+template< class Tag, class Bimap >
+struct reverse_iterator_type_by
+{
+    typedef -unspecified- type;
+};
+
+template< class Tag, class Bimap >
+struct const_reverse_iterator_type_by
+{
+    typedef -unspecified- type;
+};
+
+template< class Tag, class Bimap >
+struct local_iterator_type_by
+{
+    typedef -unspecified- type;
+};
+
+template< class Tag, class Bimap >
+struct const_local_iterator_type_by
+{
+    typedef -unspecified- type;
+};
+
+\endcode
+
+See also member_at.
+\ingroup bimap_group
+                                                                    **/
+
+#ifndef BOOST_BIMAP_DOXYGEN_WILL_NOT_PROCESS_THE_FOLLOWING_LINES
+
+namespace boost {
+namespace bimaps {
+namespace support {
+
+
+// Implementation of iterator type by metafunction
+
+BOOST_BIMAP_SYMMETRIC_METADATA_ACCESS_BUILDER
+(
+    iterator_type_by,
+    left_iterator,
+    right_iterator
+)
+
+// Implementation of const iterator type by metafunction
+
+BOOST_BIMAP_SYMMETRIC_METADATA_ACCESS_BUILDER
+(
+    const_iterator_type_by,
+    left_const_iterator,
+    right_const_iterator
+)
+
+
+// Implementation of reverse iterator type by metafunction
+
+BOOST_BIMAP_SYMMETRIC_STATIC_ACCESS_BUILDER
+(
+    core_reverse_iterator_type_by,
+    BimapCore,
+
+    typedef BOOST_DEDUCED_TYPENAME BimapCore::core_type::BOOST_NESTED_TEMPLATE
+        index<BOOST_DEDUCED_TYPENAME BimapCore::left_tag>
+            ::type::reverse_iterator type,
+
+    typedef BOOST_DEDUCED_TYPENAME BimapCore::core_type::BOOST_NESTED_TEMPLATE
+        index<BOOST_DEDUCED_TYPENAME BimapCore::right_tag>
+            ::type::reverse_iterator type
+)
+
+template< class Tag, class BimapCore >
+struct reverse_iterator_type_by
+{
+    typedef ::boost::bimaps::detail::map_view_iterator
+    <
+        Tag,
+        BOOST_DEDUCED_TYPENAME BimapCore::relation,
+        BOOST_DEDUCED_TYPENAME core_reverse_iterator_type_by<Tag,BimapCore>::type
+
+    > type;
+};
+
+// Implementation of const reverse iterator type by metafunction
+
+BOOST_BIMAP_SYMMETRIC_STATIC_ACCESS_BUILDER
+(
+    core_const_reverse_iterator_type_by,
+    BimapCore,
+
+    typedef BOOST_DEDUCED_TYPENAME BimapCore::core_type::BOOST_NESTED_TEMPLATE
+        index<BOOST_DEDUCED_TYPENAME BimapCore::left_tag>
+            ::type::const_reverse_iterator type,
+
+    typedef BOOST_DEDUCED_TYPENAME BimapCore::core_type::BOOST_NESTED_TEMPLATE
+        index<BOOST_DEDUCED_TYPENAME BimapCore::right_tag>
+            ::type::const_reverse_iterator type
+)
+
+template< class Tag, class BimapCore >
+struct const_reverse_iterator_type_by
+{
+
+    typedef ::boost::bimaps::detail::map_view_iterator
+    <
+        Tag,
+        BOOST_DEDUCED_TYPENAME BimapCore::relation,
+        BOOST_DEDUCED_TYPENAME core_const_reverse_iterator_type_by<Tag,BimapCore>::type
+
+    > type;
+};
+
+
+// Implementation of local iterator type by metafunction
+
+BOOST_BIMAP_SYMMETRIC_STATIC_ACCESS_BUILDER
+(
+    core_local_iterator_type_by,
+    BimapCore,
+
+    typedef BOOST_DEDUCED_TYPENAME BimapCore::core_type::BOOST_NESTED_TEMPLATE
+        index<BOOST_DEDUCED_TYPENAME BimapCore::left_tag>
+            ::type::local_iterator type,
+
+    typedef BOOST_DEDUCED_TYPENAME BimapCore::core_type::BOOST_NESTED_TEMPLATE
+        index<BOOST_DEDUCED_TYPENAME BimapCore::right_tag>
+            ::type::local_iterator type
+)
+
+
+template< class Tag, class BimapCore >
+struct local_iterator_type_by
+{
+
+    typedef ::boost::bimaps::detail::map_view_iterator
+    <
+        Tag,
+        BOOST_DEDUCED_TYPENAME BimapCore::relation,
+        BOOST_DEDUCED_TYPENAME core_local_iterator_type_by<Tag,BimapCore>::type
+
+    > type;
+};
+
+
+// Implementation of const local iterator type by metafunction
+
+BOOST_BIMAP_SYMMETRIC_STATIC_ACCESS_BUILDER
+(
+    core_const_local_iterator_type_by,
+    BimapCore,
+
+    typedef BOOST_DEDUCED_TYPENAME BimapCore::core_type::BOOST_NESTED_TEMPLATE
+        index<BOOST_DEDUCED_TYPENAME BimapCore::left_tag>
+            ::type::const_local_iterator type,
+
+    typedef BOOST_DEDUCED_TYPENAME BimapCore::core_type::BOOST_NESTED_TEMPLATE
+        index<BOOST_DEDUCED_TYPENAME BimapCore::right_tag>
+            ::type::const_local_iterator type
+)
+
+template< class Tag, class BimapCore >
+struct const_local_iterator_type_by
+{
+
+    typedef ::boost::bimaps::detail::map_view_iterator
+    <
+        Tag,
+        BOOST_DEDUCED_TYPENAME BimapCore::relation,
+        BOOST_DEDUCED_TYPENAME core_const_local_iterator_type_by<Tag,BimapCore>::type
+
+    > type;
+};
+
+
+} // namespace support
+} // namespace bimaps
+} // namespace boost
+
+#endif // BOOST_BIMAP_DOXYGEN_WILL_NOT_PROCESS_THE_FOLLOWING_LINES
+
+#endif // BOOST_BIMAP_SUPPORT_ITERATOR_TYPE_BY_HPP
+

test/external/boost/bimap/support/key_type_by.hpp

@@ -0,0 +1,64 @@
+// Boost.Bimap
+//
+// Copyright (c) 2006-2007 Matias Capeletto
+//
+// 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)
+
+/// \file support/key_type_by.hpp
+/// \brief Metafunction to access the set types of a bimap
+
+#ifndef BOOST_BIMAP_SUPPORT_KEY_TYPE_BY_HPP
+#define BOOST_BIMAP_SUPPORT_KEY_TYPE_BY_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER>=1200)
+#pragma once
+#endif
+
+#include <boost/config.hpp>
+
+#include <boost/bimap/relation/detail/metadata_access_builder.hpp>
+
+/** \struct boost::bimaps::support::key_type_by
+
+\brief Metafunction to obtain the key type of one of the sides in a bimap
+
+The tag parameter can be either a user defined tag or \c member_at::{side}.
+The returned type is one of the {SetType}_of definition classes.
+
+\code
+
+template< class Tag, class Bimap >
+struct key_type_by
+{
+    typedef typename Bimap::{side}_key_type type;
+};
+
+\endcode
+
+See also member_at.
+\ingroup bimap_group
+                                                                    **/
+
+
+namespace boost {
+namespace bimaps {
+namespace support {
+
+// Implementation of key type type of metafunction
+
+BOOST_BIMAP_SYMMETRIC_METADATA_ACCESS_BUILDER
+(
+    key_type_by,
+    left_key_type,
+    right_key_type
+)
+
+
+} // namespace support
+} // namespace bimaps
+} // namespace boost
+
+#endif // BOOST_BIMAP_SUPPORT_KEY_TYPE_BY_HPP
+

test/external/boost/bimap/support/lambda.hpp

@@ -0,0 +1,46 @@
+// Boost.Bimap
+//
+// Copyright (c) 2006-2007 Matias Capeletto
+//
+// 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)
+
+/// \file support/lambda.hpp
+/// \brief Placeholders definition to help in bimap modify function
+
+#ifndef BOOST_BIMAP_SUPPORT_LAMBDA_HPP
+#define BOOST_BIMAP_SUPPORT_LAMBDA_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER>=1200)
+#pragma once
+#endif
+
+#include <boost/config.hpp>
+
+#include <boost/lambda/lambda.hpp>
+
+namespace boost {
+namespace bimaps {
+
+namespace {
+
+/*
+boost::lambda::placeholder1_type & _first  = boost::lambda::_1;
+boost::lambda::placeholder2_type & _second = boost::lambda::_2;
+
+boost::lambda::placeholder1_type & _left   = boost::lambda::_1;
+boost::lambda::placeholder2_type & _right  = boost::lambda::_2;
+*/
+
+boost::lambda::placeholder1_type & _key  = boost::lambda::_1;
+boost::lambda::placeholder1_type & _data = boost::lambda::_1;
+
+}
+
+} // namespace bimaps
+} // namespace boost
+
+
+#endif // BOOST_BIMAP_SUPPORT_LAMBDA_HPP
+

test/external/boost/bimap/support/map_by.hpp

@@ -0,0 +1,132 @@
+// Boost.Bimap
+//
+// Copyright (c) 2006-2007 Matias Capeletto
+//
+// 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)
+
+/// \file support/map_by.hpp
+/// \brief map_by<tag>(b) function
+
+#ifndef BOOST_BIMAP_SUPPORT_MAP_BY_HPP
+#define BOOST_BIMAP_SUPPORT_MAP_BY_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER>=1200)
+#pragma once
+#endif
+
+#include <boost/config.hpp>
+
+#include <boost/bimap/support/map_type_by.hpp>
+#include <boost/bimap/relation/detail/access_builder.hpp>
+
+
+#ifdef BOOST_BIMAP_ONLY_DOXYGEN_WILL_PROCESS_THE_FOLLOWING_LINES
+
+namespace boost {
+namespace bimaps {
+namespace support {
+
+/** \brief Gets a map view of a bidirectional map
+
+Convertible to \c map_type_by<Tag,Bimap>::type
+Instead of using \c map_type_by<Tag,Bimap>::type this functions use
+\b Boost.call_traits to find the best way to return this value. To help
+the user of this function the following metafunction is provided
+\code
+
+namespace result_of {
+
+template< class Tag, class Bimap >
+struct map_by( Bimap & b );
+
+} // namespace result_of
+
+\endcode
+
+See also member_at, value_type_of.
+\ingroup bimap_group
+                                                                        **/
+
+template< class Tag, class Bimap >
+BOOST_DEDUCED_TYPENAME result_of::map_by<Tag,Bimap>::type
+    map_by( Bimap & b );
+
+} // namespace support
+} // namespace bimaps
+} // namespace boost
+
+#endif // BOOST_BIMAP_ONLY_DOXYGEN_WILL_PROCESS_THE_FOLLOWING_LINES
+
+
+
+#ifndef BOOST_BIMAP_DOXIGEN_WILL_NOT_PROCESS_THE_FOLLOWING_LINES
+
+namespace boost {
+namespace bimaps {
+namespace support {
+
+// Since it is very error-prone to directly write the hole bunch
+// of relation accesor. They are buil from litle macro blocks that
+// are both more readable, leading to self docummenting code and a
+// lot more easier to understand and mantain.
+// It is very important to note that the three building blocks have
+// to laid in the same namespace in order to work. There is also
+// important to keep them in order.
+// The forward declaration are not necesary but they help a lot to
+// the reader, as they undercover what is the signature of the
+// result code.
+// In the end, it is not quicker to do it in this way because you
+// write a lot. But this code has no complexity at all and almost
+// every word writed is for documentation.
+
+// Result of
+// -------------------------------------------------------------------------
+/*
+    namespace result_of {
+
+    template< class Tag, class Bimap >
+    struct map_by<Tag,Bimap>;
+    {
+        typedef -unspecified- type;
+    };
+
+    } // namespace result_of
+
+*/
+
+BOOST_BIMAP_SYMMETRIC_ACCESS_RESULT_OF_BUILDER
+(
+    map_by,
+    map_type_by
+)
+
+// Implementation
+// -------------------------------------------------------------------------
+
+BOOST_BIMAP_SYMMETRIC_ACCESS_IMPLEMENTATION_BUILDER
+(
+    map_by,
+    Bimap,
+    b,
+    return b.left,
+    return b.right
+)
+
+// Interface
+// --------------------------------------------------------------------------
+
+BOOST_BIMAP_SYMMETRIC_ACCESS_INTERFACE_BUILDER
+(
+    map_by
+)
+
+} // namespace support
+} // namespace bimaps
+} // namespace boost
+
+#endif // BOOST_BIMAP_DOXIGEN_WILL_NOT_PROCESS_THE_FOLLOWING_LINES
+
+#endif // BOOST_BIMAP_SUPPORT_MAP_BY_HPP
+

test/external/boost/bimap/support/map_type_by.hpp

@@ -0,0 +1,65 @@
+// Boost.Bimap
+//
+// Copyright (c) 2006-2007 Matias Capeletto
+//
+// 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)
+
+/// \file support/map_type_by.hpp
+/// \brief Metafunction to access the map view types of a bimap
+
+#ifndef BOOST_BIMAP_SUPPORT_MAP_TYPE_BY_HPP
+#define BOOST_BIMAP_SUPPORT_MAP_TYPE_BY_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER>=1200)
+#pragma once
+#endif
+
+#include <boost/config.hpp>
+
+#include <boost/bimap/relation/detail/metadata_access_builder.hpp>
+
+/** \struct boost::bimaps::support::map_type_by
+
+\brief Metafunction to obtain the map view type of a bimap indexed by one of the sides.
+
+The tag parameter can be either a user defined tag or \c member_at::{side}.
+The returned type is signature-compatible with std::pair.
+
+\code
+
+template< class Tag, class Bimap >
+struct map_type_by
+{
+    typedef typename Bimap::{side}_map_type type;
+};
+
+\endcode
+
+See also member_at.
+\ingroup bimap_group
+                                                                    **/
+
+namespace boost {
+namespace bimaps {
+namespace support {
+
+// Implementation of map type by metafunction
+
+BOOST_BIMAP_SYMMETRIC_METADATA_ACCESS_BUILDER
+(
+    map_type_by,
+    left_map,
+    right_map
+)
+
+
+
+} // namespace support
+} // namespace bimaps
+} // namespace boost
+
+
+#endif // BOOST_BIMAP_SUPPORT_MAP_TYPE_BY_HPP
+

test/external/boost/bimap/support/value_type_by.hpp

@@ -0,0 +1,65 @@
+// Boost.Bimap
+//
+// Copyright (c) 2006-2007 Matias Capeletto
+//
+// 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)
+
+/// \file support/value_type_by.hpp
+/// \brief Metafunction to access the value types (std::pair compatibles) of a bimap
+
+#ifndef BOOST_BIMAP_SUPPORT_VALUE_TYPE_BY_HPP
+#define BOOST_BIMAP_SUPPORT_VALUE_TYPE_BY_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER>=1200)
+#pragma once
+#endif
+
+#include <boost/config.hpp>
+
+#include <boost/bimap/relation/detail/metadata_access_builder.hpp>
+
+/** \struct boost::bimaps::support::value_type_by
+
+\brief Metafunction to obtain the value type of a bimap indexed by one of the sides.
+
+The tag parameter can be either a user defined tag or \c member_at::{side}.
+The returned type is signature-compatible with std::pair.
+
+\code
+
+template< class Tag, class Bimap >
+struct value_type_by
+{
+    typedef typename Bimap::{side}_value_type type;
+};
+
+\endcode
+
+See also member_at.
+\ingroup bimap_group
+                                                                    **/
+
+namespace boost {
+namespace bimaps {
+namespace support {
+
+// Implementation of value type by metafunction
+
+BOOST_BIMAP_SYMMETRIC_METADATA_ACCESS_BUILDER
+(
+    value_type_by,
+    left_value_type,
+    right_value_type
+)
+
+
+
+} // namespace support
+} // namespace bimaps
+} // namespace boost
+
+
+#endif // BOOST_BIMAP_SUPPORT_VALUE_TYPE_BY_HPP
+