summaryrefslogtreecommitdiff
path: root/boost/bimap
diff options
context:
space:
mode:
Diffstat (limited to 'boost/bimap')
-rw-r--r--boost/bimap/bimap.hpp431
-rw-r--r--boost/bimap/container_adaptor/associative_container_adaptor.hpp287
-rw-r--r--boost/bimap/container_adaptor/container_adaptor.hpp291
-rw-r--r--boost/bimap/container_adaptor/detail/comparison_adaptor.hpp101
-rw-r--r--boost/bimap/container_adaptor/detail/functor_bag.hpp100
-rw-r--r--boost/bimap/container_adaptor/detail/identity_converters.hpp191
-rw-r--r--boost/bimap/container_adaptor/detail/key_extractor.hpp45
-rw-r--r--boost/bimap/container_adaptor/detail/non_unique_container_helper.hpp62
-rw-r--r--boost/bimap/container_adaptor/list_adaptor.hpp249
-rw-r--r--boost/bimap/container_adaptor/list_map_adaptor.hpp282
-rw-r--r--boost/bimap/container_adaptor/map_adaptor.hpp131
-rw-r--r--boost/bimap/container_adaptor/multimap_adaptor.hpp109
-rw-r--r--boost/bimap/container_adaptor/multiset_adaptor.hpp103
-rw-r--r--boost/bimap/container_adaptor/ordered_associative_container_adaptor.hpp312
-rw-r--r--boost/bimap/container_adaptor/sequence_container_adaptor.hpp356
-rw-r--r--boost/bimap/container_adaptor/set_adaptor.hpp100
-rw-r--r--boost/bimap/container_adaptor/support/iterator_facade_converters.hpp77
-rw-r--r--boost/bimap/container_adaptor/unordered_associative_container_adaptor.hpp293
-rw-r--r--boost/bimap/container_adaptor/unordered_map_adaptor.hpp132
-rw-r--r--boost/bimap/container_adaptor/unordered_multimap_adaptor.hpp110
-rw-r--r--boost/bimap/container_adaptor/unordered_multiset_adaptor.hpp102
-rw-r--r--boost/bimap/container_adaptor/unordered_set_adaptor.hpp98
-rw-r--r--boost/bimap/container_adaptor/vector_adaptor.hpp142
-rw-r--r--boost/bimap/container_adaptor/vector_map_adaptor.hpp103
-rw-r--r--boost/bimap/detail/bimap_core.hpp520
-rw-r--r--boost/bimap/detail/concept_tags.hpp97
-rw-r--r--boost/bimap/detail/debug/static_error.hpp36
-rw-r--r--boost/bimap/detail/generate_index_binder.hpp125
-rw-r--r--boost/bimap/detail/generate_relation_binder.hpp88
-rw-r--r--boost/bimap/detail/generate_view_binder.hpp58
-rw-r--r--boost/bimap/detail/is_set_type_of.hpp66
-rw-r--r--boost/bimap/detail/manage_additional_parameters.hpp243
-rw-r--r--boost/bimap/detail/manage_bimap_key.hpp84
-rw-r--r--boost/bimap/detail/map_view_base.hpp553
-rw-r--r--boost/bimap/detail/map_view_iterator.hpp200
-rw-r--r--boost/bimap/detail/modifier_adaptor.hpp89
-rw-r--r--boost/bimap/detail/non_unique_views_helper.hpp71
-rw-r--r--boost/bimap/detail/set_view_base.hpp331
-rw-r--r--boost/bimap/detail/set_view_iterator.hpp193
-rw-r--r--boost/bimap/detail/test/check_metadata.hpp113
-rw-r--r--boost/bimap/detail/user_interface_config.hpp24
-rw-r--r--boost/bimap/list_of.hpp181
-rw-r--r--boost/bimap/multiset_of.hpp205
-rw-r--r--boost/bimap/property_map/set_support.hpp55
-rw-r--r--boost/bimap/property_map/unordered_set_support.hpp55
-rw-r--r--boost/bimap/relation/detail/access_builder.hpp170
-rw-r--r--boost/bimap/relation/detail/metadata_access_builder.hpp103
-rw-r--r--boost/bimap/relation/detail/mutant.hpp83
-rw-r--r--boost/bimap/relation/detail/static_access_builder.hpp105
-rw-r--r--boost/bimap/relation/detail/to_mutable_relation_functor.hpp102
-rw-r--r--boost/bimap/relation/member_at.hpp72
-rw-r--r--boost/bimap/relation/mutant_relation.hpp430
-rw-r--r--boost/bimap/relation/pair_layout.hpp72
-rw-r--r--boost/bimap/relation/structured_pair.hpp508
-rw-r--r--boost/bimap/relation/support/data_extractor.hpp110
-rw-r--r--boost/bimap/relation/support/get.hpp140
-rw-r--r--boost/bimap/relation/support/get_pair_functor.hpp85
-rw-r--r--boost/bimap/relation/support/is_tag_of_member_at.hpp181
-rw-r--r--boost/bimap/relation/support/member_with_tag.hpp180
-rw-r--r--boost/bimap/relation/support/opposite_tag.hpp61
-rw-r--r--boost/bimap/relation/support/pair_by.hpp120
-rw-r--r--boost/bimap/relation/support/pair_type_by.hpp62
-rw-r--r--boost/bimap/relation/support/value_type_of.hpp91
-rw-r--r--boost/bimap/relation/symmetrical_base.hpp97
-rw-r--r--boost/bimap/set_of.hpp206
-rw-r--r--boost/bimap/support/data_type_by.hpp73
-rw-r--r--boost/bimap/support/iterator_type_by.hpp228
-rw-r--r--boost/bimap/support/key_type_by.hpp64
-rw-r--r--boost/bimap/support/lambda.hpp46
-rw-r--r--boost/bimap/support/map_by.hpp132
-rw-r--r--boost/bimap/support/map_type_by.hpp65
-rw-r--r--boost/bimap/support/value_type_by.hpp65
-rw-r--r--boost/bimap/tags/support/apply_to_value_type.hpp70
-rw-r--r--boost/bimap/tags/support/default_tagged.hpp73
-rw-r--r--boost/bimap/tags/support/is_tagged.hpp64
-rw-r--r--boost/bimap/tags/support/overwrite_tagged.hpp73
-rw-r--r--boost/bimap/tags/support/tag_of.hpp75
-rw-r--r--boost/bimap/tags/support/value_type_of.hpp74
-rw-r--r--boost/bimap/tags/tagged.hpp107
-rw-r--r--boost/bimap/unconstrained_set_of.hpp150
-rw-r--r--boost/bimap/unordered_multiset_of.hpp233
-rw-r--r--boost/bimap/unordered_set_of.hpp230
-rw-r--r--boost/bimap/vector_of.hpp186
-rw-r--r--boost/bimap/views/list_map_view.hpp182
-rw-r--r--boost/bimap/views/list_set_view.hpp109
-rw-r--r--boost/bimap/views/map_view.hpp156
-rw-r--r--boost/bimap/views/multimap_view.hpp123
-rw-r--r--boost/bimap/views/multiset_view.hpp110
-rw-r--r--boost/bimap/views/set_view.hpp106
-rw-r--r--boost/bimap/views/unconstrained_map_view.hpp44
-rw-r--r--boost/bimap/views/unconstrained_set_view.hpp42
-rw-r--r--boost/bimap/views/unordered_map_view.hpp174
-rw-r--r--boost/bimap/views/unordered_multimap_view.hpp136
-rw-r--r--boost/bimap/views/unordered_multiset_view.hpp83
-rw-r--r--boost/bimap/views/unordered_set_view.hpp78
-rw-r--r--boost/bimap/views/vector_map_view.hpp306
-rw-r--r--boost/bimap/views/vector_set_view.hpp279
97 files changed, 14508 insertions, 0 deletions
diff --git a/boost/bimap/bimap.hpp b/boost/bimap/bimap.hpp
new file mode 100644
index 0000000..3021b04
--- /dev/null
+++ b/boost/bimap/bimap.hpp
@@ -0,0 +1,431 @@
+// 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 bimap.hpp
+/// \brief Includes the basic bimap container
+
+/** \mainpage notitle
+\n
+\image html http://matias.capeletto.googlepages.com/boost.bimap.reference.logo.png
+
+\section Introduction
+
+This is the complete reference of Boost.Bimap.
+
+After getting a good understanding of the library from a user perspective
+the next step will be:
+
+ - Understand the tagged idiom. (boost::bimaps::tags)
+ - Understand the internals of the relation class (boost::bimaps::relation)
+ - Read the container_adaptor toolbox docs (boost::bimaps::container_adaptor)
+ - Understand the internals of the bimap class. (boost::bimaps, boost::bimaps::views
+ and boost::bimaps::detail)
+
+
+ **/
+
+/** \defgroup mutant_group mutant idiom
+\brief A safe wrapper around reinterpret_cast
+ **/
+
+/** \defgroup relation_group relation
+\brief The relation
+ **/
+
+/** \defgroup tags_group tagged idiom
+\brief The tagged idiom
+ **/
+
+
+#ifndef BOOST_BIMAP_BIMAP_HPP
+#define BOOST_BIMAP_BIMAP_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER>=1200)
+#pragma once
+#endif
+
+#include <boost/config.hpp>
+#include <boost/bimap/detail/user_interface_config.hpp>
+#include <boost/mpl/aux_/na.hpp>
+
+#ifndef BOOST_BIMAP_DISABLE_SERIALIZATION
+ #include <boost/serialization/nvp.hpp>
+#endif // BOOST_BIMAP_DISABLE_SERIALIZATION
+
+// Boost.Bimap
+#include <boost/bimap/detail/bimap_core.hpp>
+#include <boost/bimap/detail/map_view_base.hpp>
+#include <boost/bimap/detail/modifier_adaptor.hpp>
+#include <boost/bimap/relation/support/data_extractor.hpp>
+#include <boost/bimap/relation/support/member_with_tag.hpp>
+
+#include <boost/bimap/support/map_type_by.hpp>
+#include <boost/bimap/support/map_by.hpp>
+#include <boost/bimap/support/iterator_type_by.hpp>
+
+/// \brief The namespace where all the boost libraries lives.
+
+namespace boost {
+
+/// \brief Boost.Bimap library namespace
+/**
+All the entities in the library are defined in this namespace.
+ **/
+namespace bimaps {
+
+/// \brief The bimap class is the entry point to the library.
+/**
+This class manages the instantiation of the desired bimap type.
+As there are several types of bidirectional maps that can be
+created using it. the main job of it is to find the desired
+type. This is done using metaprogramming to obtain the relation
+type that will be stored, the map_view type of each side and
+the set_view type of the general relationship. The instantiation
+is kept simple using an extended standard set theory, where a
+bidirectional map type is defined by the set types it relates.
+For example, a bidirectional map that has multimap semantics
+viewed from both sides is defined by specifying that the two
+keys sets are of \c multiset_of<Key> type.
+This allows the bimap class to support seamingless N-N, 1-N,
+ordered/unordered and even vector-list types of mapping.
+The three last parameters are used to specify the set type of
+the relation, an inplace hooked data class and the allocator
+type. As a help to the bimap user, these parameters support
+default types but use a special idiom that allow them to be
+specified without interleaving the usual use_default keyword.
+The possible bimap instantiation are enumerated here:
+\c {Side}KeyType can be directly a type, this is default to
+\c set_of<{Side}KeyType>, or can be a \c {SetType}_of<Type>
+specification. Additionally this two parameters can be tagged
+to specify others tags instead of the usual \c member_at::{Side}
+ones.
+
+
+\code
+
+ typedef bimap
+ <
+ LeftCollectionType, RightCollectionType
+
+ [ , SetTypeOfRelation ] // Default to left_based
+ [ , info_hook< Info > ] // Default to no info
+ [ , Allocator ] // Default to std::allocator<>
+
+ > bm;
+
+\endcode
+
+ **/
+
+
+template
+<
+ class KeyTypeA, class KeyTypeB,
+ class AP1 = ::boost::mpl::na,
+ class AP2 = ::boost::mpl::na,
+ class AP3 = ::boost::mpl::na
+>
+class bimap
+:
+ // Bimap Core, use mpl magic to find the desired bimap type
+
+ public ::boost::bimaps::detail::bimap_core<KeyTypeA,KeyTypeB,AP1,AP2,AP3>,
+
+ // You can use bimap as a collection of relations
+
+ public ::boost::bimaps::detail::bimap_core<KeyTypeA,KeyTypeB,AP1,AP2,AP3>
+ ::relation_set,
+
+ // Include extra typedefs (i.e. left_local_iterator for unordered_map)
+
+ public ::boost::bimaps::detail:: left_map_view_extra_typedefs<
+ BOOST_DEDUCED_TYPENAME ::boost::bimaps::detail::left_map_view_type<
+ ::boost::bimaps::detail::bimap_core<KeyTypeA,KeyTypeB,AP1,AP2,AP3>
+ >::type
+ >,
+ public ::boost::bimaps::detail::right_map_view_extra_typedefs<
+ BOOST_DEDUCED_TYPENAME ::boost::bimaps::detail::right_map_view_type<
+ ::boost::bimaps::detail::bimap_core<KeyTypeA,KeyTypeB,AP1,AP2,AP3>
+ >::type
+ >
+{
+ typedef BOOST_DEDUCED_TYPENAME ::boost::bimaps::detail::
+ bimap_core<KeyTypeA,KeyTypeB,AP1,AP2,AP3> base_;
+
+ BOOST_DEDUCED_TYPENAME base_::core_type core;
+
+ public:
+
+ // metadata --------------------------------------------------------
+
+ /*
+ // The rest is computed in the core, because it is quite difficult to
+ // expose a nice interface with so many metaprogramming stuff.
+ // Here it is the complete metadat list.
+
+ // Map by {side} metadata
+
+ typedef -unspecified- {side}_tag;
+ typedef -unspecified- {side}_data_type;
+ typedef -unspecified- {side}_value_type;
+ typedef -unspecified- {side}_key_type;
+ typedef -unspecified- {side}_iterator;
+ typedef -unspecified- {side}_const_iterator;
+
+ ------------------------------------------------------------------*/
+
+ typedef BOOST_DEDUCED_TYPENAME ::boost::bimaps::detail::
+ left_map_view_type<base_>::type left_map;
+ typedef BOOST_DEDUCED_TYPENAME ::boost::bimaps::detail::
+ right_map_view_type<base_>::type right_map;
+
+ typedef BOOST_DEDUCED_TYPENAME
+ left_map::reference left_reference;
+ typedef BOOST_DEDUCED_TYPENAME
+ left_map::const_reference left_const_reference;
+
+ typedef BOOST_DEDUCED_TYPENAME
+ right_map::reference right_reference;
+ typedef BOOST_DEDUCED_TYPENAME
+ right_map::const_reference right_const_reference;
+
+ typedef BOOST_DEDUCED_TYPENAME base_::relation::info_type info_type;
+
+ typedef BOOST_DEDUCED_TYPENAME base_::core_type::allocator_type allocator_type;
+
+ /// Left map view
+ left_map left;
+
+ /// Right map view
+ right_map right;
+
+ typedef BOOST_DEDUCED_TYPENAME base_::logic_relation_set_tag
+ logic_relation_set_tag;
+ typedef BOOST_DEDUCED_TYPENAME base_::logic_left_tag logic_left_tag;
+ typedef BOOST_DEDUCED_TYPENAME base_::logic_right_tag logic_right_tag;
+ typedef BOOST_DEDUCED_TYPENAME base_::core_type::ctor_args_list
+ ctor_args_list;
+
+ bimap(const allocator_type& al = allocator_type()) :
+
+ base_::relation_set(
+ ::boost::multi_index::get<
+ logic_relation_set_tag
+ >(core)
+ ),
+
+ core(al),
+
+ left (
+ ::boost::multi_index::get<
+ logic_left_tag
+ >(core)
+ ),
+ right (
+ ::boost::multi_index::get<
+ logic_right_tag
+ >(core)
+ )
+
+ {}
+
+ template< class InputIterator >
+ bimap(InputIterator first,InputIterator last,
+ const allocator_type& al = allocator_type()) :
+
+ base_::relation_set(
+ ::boost::multi_index::get<logic_relation_set_tag>(core)
+ ),
+
+ core(first,last,ctor_args_list(),al),
+
+ left (
+ ::boost::multi_index::get<logic_left_tag>(core)
+ ),
+ right (
+ ::boost::multi_index::get<logic_right_tag>(core)
+ )
+
+ {}
+
+ bimap(const bimap& x) :
+
+ base_::relation_set(
+ ::boost::multi_index::get<logic_relation_set_tag>(core)
+ ),
+
+ core(x.core),
+
+ left (
+ ::boost::multi_index::get<logic_left_tag>(core)
+ ),
+ right (
+ ::boost::multi_index::get<logic_right_tag>(core)
+ )
+
+ {}
+
+ bimap& operator=(const bimap& x)
+ {
+ core = x.core;
+ return *this;
+ }
+
+ // Projection of iterators
+
+ template< class IteratorType >
+ BOOST_DEDUCED_TYPENAME base_::left_iterator
+ project_left(IteratorType iter)
+ {
+ return core.template project<
+ BOOST_DEDUCED_TYPENAME base_::logic_left_tag>(iter.base());
+ }
+
+ template< class IteratorType >
+ BOOST_DEDUCED_TYPENAME base_::left_const_iterator
+ project_left(IteratorType iter) const
+ {
+ return core.template project<
+ BOOST_DEDUCED_TYPENAME base_::logic_left_tag>(iter.base());
+ }
+
+ template< class IteratorType >
+ BOOST_DEDUCED_TYPENAME base_::right_iterator
+ project_right(IteratorType iter)
+ {
+ return core.template project<
+ BOOST_DEDUCED_TYPENAME base_::logic_right_tag>(iter.base());
+ }
+
+ template< class IteratorType >
+ BOOST_DEDUCED_TYPENAME base_::right_const_iterator
+ project_right(IteratorType iter) const
+ {
+ return core.template project<
+ BOOST_DEDUCED_TYPENAME base_::logic_right_tag>(iter.base());
+ }
+
+ template< class IteratorType >
+ BOOST_DEDUCED_TYPENAME base_::relation_set::iterator
+ project_up(IteratorType iter)
+ {
+ return core.template project<
+ BOOST_DEDUCED_TYPENAME base_::logic_relation_set_tag>(iter.base());
+ }
+
+ template< class IteratorType >
+ BOOST_DEDUCED_TYPENAME base_::relation_set::const_iterator
+ project_up(IteratorType iter) const
+ {
+ return core.template project<
+ BOOST_DEDUCED_TYPENAME base_::logic_relation_set_tag>(iter.base());
+ }
+
+ // Support for tags
+
+ template< class Tag, class IteratorType >
+ BOOST_DEDUCED_TYPENAME ::boost::bimaps::support::
+ iterator_type_by<Tag,bimap>::type
+ project(IteratorType iter
+ BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(Tag))
+ {
+ return core.template project<Tag>(iter.base());
+ }
+
+ template< class Tag, class IteratorType >
+ BOOST_DEDUCED_TYPENAME ::boost::bimaps::support::
+ const_iterator_type_by<Tag,bimap>::type
+ project(IteratorType iter
+ BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(Tag)) const
+ {
+ return core.template project<Tag>(iter.base());
+ }
+
+ template< class Tag >
+ struct map_by :
+ public ::boost::bimaps::support::map_type_by<Tag,bimap>::type
+ {
+ typedef BOOST_DEDUCED_TYPENAME ::boost::bimaps::support::
+ map_type_by<Tag,bimap>::type type;
+
+ private: map_by() {}
+ };
+
+ template< class Tag >
+ BOOST_DEDUCED_TYPENAME ::boost::bimaps::support::
+ map_type_by<Tag,bimap>::type &
+ by(BOOST_EXPLICIT_TEMPLATE_TYPE(Tag))
+ {
+ return ::boost::bimaps::support::map_by<Tag>(*this);
+ }
+
+ template< class Tag >
+ const BOOST_DEDUCED_TYPENAME ::boost::bimaps::support::
+ map_type_by<Tag,bimap>::type &
+ by(BOOST_EXPLICIT_TEMPLATE_TYPE(Tag)) const
+ {
+ return ::boost::bimaps::support::map_by<Tag>(*this);
+ }
+
+
+ #ifndef BOOST_BIMAP_DISABLE_SERIALIZATION
+
+ // Serialization support
+
+ private:
+
+ friend class boost::serialization::access;
+
+ template<class Archive>
+ void serialize(Archive & ar, const unsigned int version)
+ {
+ ar & serialization::make_nvp("mi_core",core);
+ }
+
+ #endif // BOOST_BIMAP_DISABLE_SERIALIZATION
+};
+
+} // namespace bimaps
+} // namespace boost
+
+
+/** \namespace boost::bimaps::support
+\brief Metafunctions to help working with bimaps.
+ **/
+
+/** \namespace boost::bimaps::views
+\brief Bimap views.
+ **/
+
+/** \namespace boost::bimaps::views::detail
+\brief Bimap views details.
+ **/
+
+
+
+// Include basic tools for user commodity
+
+#include <boost/bimap/tags/tagged.hpp>
+#include <boost/bimap/relation/member_at.hpp>
+#include <boost/multi_index/detail/unbounded.hpp>
+
+// Bring the most used namespaces directly to the user main namespace
+namespace boost {
+namespace bimaps {
+
+using ::boost::bimaps::tags::tagged;
+
+namespace member_at = ::boost::bimaps::relation::member_at;
+
+using ::boost::multi_index::unbounded;
+
+} // namespace bimaps
+} // namespace boost
+
+
+#endif // BOOST_BIMAP_BIMAP_HPP
diff --git a/boost/bimap/container_adaptor/associative_container_adaptor.hpp b/boost/bimap/container_adaptor/associative_container_adaptor.hpp
new file mode 100644
index 0000000..18e0359
--- /dev/null
+++ b/boost/bimap/container_adaptor/associative_container_adaptor.hpp
@@ -0,0 +1,287 @@
+// 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 container_adaptor/associative_container_adaptor.hpp
+/// \brief Container adaptor to build a type that is compliant to the concept of an associative container.
+
+#ifndef BOOST_BIMAP_CONTAINER_ADAPTOR_ASSOCIATIVE_CONTAINER_ADAPTOR_HPP
+#define BOOST_BIMAP_CONTAINER_ADAPTOR_ASSOCIATIVE_CONTAINER_ADAPTOR_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER>=1200)
+#pragma once
+#endif
+
+#include <boost/config.hpp>
+
+#include <utility>
+
+#include <boost/mpl/vector.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/mpl/aux_/na.hpp>
+#include <boost/bimap/container_adaptor/detail/identity_converters.hpp>
+#include <boost/bimap/container_adaptor/container_adaptor.hpp>
+#include <boost/call_traits.hpp>
+
+namespace boost {
+namespace bimaps {
+namespace container_adaptor {
+
+#ifndef BOOST_BIMAP_DOXYGEN_WILL_NOT_PROCESS_THE_FOLLOWING_LINES
+
+template
+<
+ class Base, class Iterator, class ConstIterator, class KeyType,
+ class IteratorToBaseConverter, class IteratorFromBaseConverter,
+ class ValueToBaseConverter, class ValueFromBaseConverter, class KeyToBaseConverter,
+ class FunctorsFromDerivedClasses
+>
+struct associative_container_adaptor_base
+{
+ typedef container_adaptor
+ <
+ Base,
+
+ Iterator, ConstIterator,
+
+ IteratorToBaseConverter, IteratorFromBaseConverter,
+ ValueToBaseConverter , ValueFromBaseConverter,
+
+ BOOST_DEDUCED_TYPENAME mpl::push_front<
+
+ FunctorsFromDerivedClasses,
+
+ BOOST_DEDUCED_TYPENAME mpl::if_< ::boost::mpl::is_na<KeyToBaseConverter>,
+ // {
+ detail::key_to_base_identity
+ <
+ BOOST_DEDUCED_TYPENAME Base::key_type, KeyType
+ >,
+ // }
+ // else
+ // {
+ KeyToBaseConverter
+ // }
+
+ >::type
+
+ >::type
+
+ > type;
+};
+
+#endif // BOOST_BIMAP_DOXYGEN_WILL_NOT_PROCESS_THE_FOLLOWING_LINES
+
+
+/// \brief Container adaptor to build a type that is compliant to the concept of an associative container.
+
+template
+<
+ class Base,
+
+ class Iterator,
+ class ConstIterator,
+
+ class KeyType,
+
+ class IteratorToBaseConverter = ::boost::mpl::na,
+ class IteratorFromBaseConverter = ::boost::mpl::na,
+ class ValueToBaseConverter = ::boost::mpl::na,
+ class ValueFromBaseConverter = ::boost::mpl::na,
+ class KeyToBaseConverter = ::boost::mpl::na,
+
+ class FunctorsFromDerivedClasses = mpl::vector<>
+>
+class associative_container_adaptor :
+
+ public associative_container_adaptor_base
+ <
+ Base, Iterator, ConstIterator, KeyType,
+ IteratorToBaseConverter, IteratorFromBaseConverter,
+ ValueToBaseConverter, ValueFromBaseConverter, KeyToBaseConverter,
+ FunctorsFromDerivedClasses
+
+ >::type
+{
+
+ // MetaData -------------------------------------------------------------
+
+ typedef typename associative_container_adaptor_base
+ <
+ Base, Iterator, ConstIterator, KeyType,
+ IteratorToBaseConverter, IteratorFromBaseConverter,
+ ValueToBaseConverter, ValueFromBaseConverter, KeyToBaseConverter,
+ FunctorsFromDerivedClasses
+
+ >::type base_;
+
+ public:
+
+ typedef KeyType key_type;
+
+ protected:
+
+ typedef BOOST_DEDUCED_TYPENAME mpl::if_< ::boost::mpl::is_na<KeyToBaseConverter>,
+ // {
+ detail::key_to_base_identity
+ <
+ BOOST_DEDUCED_TYPENAME Base::key_type, KeyType
+ >,
+ // }
+ // else
+ // {
+ KeyToBaseConverter
+ // }
+
+ >::type key_to_base;
+
+ public:
+
+ explicit associative_container_adaptor(Base & c)
+ : base_(c) {}
+
+ protected:
+
+
+ typedef associative_container_adaptor associative_container_adaptor_;
+
+ // Interface --------------------------------------------------------------
+
+ public:
+
+ template< class CompatibleKey >
+ BOOST_DEDUCED_TYPENAME base_::size_type erase(const CompatibleKey & k)
+ {
+ return this->base().erase
+ (
+ this->template functor<key_to_base>()(k)
+ );
+ }
+
+ // As we redefine erase, the other overloads need to be manually routed
+
+ BOOST_DEDUCED_TYPENAME base_::iterator erase(
+ BOOST_DEDUCED_TYPENAME base_::iterator pos)
+ {
+ return base_::container_adaptor_::erase(pos);
+ }
+
+ BOOST_DEDUCED_TYPENAME base_::iterator erase(
+ BOOST_DEDUCED_TYPENAME base_::iterator first,
+ BOOST_DEDUCED_TYPENAME base_::iterator last)
+ {
+ return base_::container_adaptor_::erase(first,last);
+ }
+
+ template< class CompatibleKey >
+ BOOST_DEDUCED_TYPENAME base_::size_type count(const CompatibleKey & k) const
+ {
+ return this->base().count(
+ this->template functor<key_to_base>()(k)
+ );
+ }
+
+ template< class CompatibleKey >
+ BOOST_DEDUCED_TYPENAME base_::iterator find(const CompatibleKey & k)
+ {
+ return this->template functor<typename base_::iterator_from_base>()
+ (
+ this->base().find(
+ this->template functor<key_to_base>()(k)
+ )
+ );
+ }
+
+ template< class CompatibleKey >
+ BOOST_DEDUCED_TYPENAME base_::const_iterator
+ find(const CompatibleKey & k) const
+ {
+ return this->template functor<
+ BOOST_DEDUCED_TYPENAME base_::iterator_from_base>()
+ (
+ this->base().find(
+ this->template functor<key_to_base>()(k)
+ )
+ );
+ }
+
+ template< class CompatibleKey >
+ std::pair
+ <
+ BOOST_DEDUCED_TYPENAME base_::iterator,
+ BOOST_DEDUCED_TYPENAME base_::iterator
+ >
+ equal_range(const CompatibleKey & k)
+ {
+ std::pair<
+
+ BOOST_DEDUCED_TYPENAME Base::iterator,
+ BOOST_DEDUCED_TYPENAME Base::iterator
+
+ > r( this->base().equal_range(
+ this->template functor<key_to_base>()(k)
+ )
+ );
+
+ return std::pair
+ <
+ BOOST_DEDUCED_TYPENAME base_::iterator,
+ BOOST_DEDUCED_TYPENAME base_::iterator
+ >(
+ this->template functor<
+ BOOST_DEDUCED_TYPENAME base_::iterator_from_base
+ >() ( r.first ),
+ this->template functor<
+ BOOST_DEDUCED_TYPENAME base_::iterator_from_base
+ >() ( r.second )
+ );
+ }
+
+ template< class CompatibleKey >
+ std::pair
+ <
+ BOOST_DEDUCED_TYPENAME base_::const_iterator,
+ BOOST_DEDUCED_TYPENAME base_::const_iterator
+ >
+ equal_range(const CompatibleKey & k) const
+ {
+ std::pair<
+
+ BOOST_DEDUCED_TYPENAME Base::const_iterator,
+ BOOST_DEDUCED_TYPENAME Base::const_iterator
+
+ > r( this->base().equal_range(
+ this->template functor<key_to_base>()(k)
+ )
+ );
+
+ return std::pair
+ <
+ BOOST_DEDUCED_TYPENAME base_::const_iterator,
+ BOOST_DEDUCED_TYPENAME base_::const_iterator
+ >(
+ this->template functor<
+ BOOST_DEDUCED_TYPENAME base_::iterator_from_base
+ >() ( r.first ),
+ this->template functor<
+ BOOST_DEDUCED_TYPENAME base_::iterator_from_base
+ >() ( r.second )
+ );
+ }
+
+};
+
+
+} // namespace container_adaptor
+} // namespace bimaps
+} // namespace boost
+
+
+#endif // BOOST_BIMAP_CONTAINER_ADAPTOR_ASSOCIATIVE_CONTAINER_ADAPTOR_HPP
+
+
+
diff --git a/boost/bimap/container_adaptor/container_adaptor.hpp b/boost/bimap/container_adaptor/container_adaptor.hpp
new file mode 100644
index 0000000..8e78090
--- /dev/null
+++ b/boost/bimap/container_adaptor/container_adaptor.hpp
@@ -0,0 +1,291 @@
+// 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 container_adaptor/container_adaptor.hpp
+/// \brief Container adaptor to build a type that is compliant to the concept of a container.
+
+#ifndef BOOST_BIMAP_CONTAINER_ADAPTOR_CONTAINER_ADAPTOR_HPP
+#define BOOST_BIMAP_CONTAINER_ADAPTOR_CONTAINER_ADAPTOR_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER>=1200)
+#pragma once
+#endif
+
+#include <boost/config.hpp>
+
+#include <utility>
+
+#include <boost/mpl/if.hpp>
+#include <boost/mpl/aux_/na.hpp>
+#include <boost/bimap/container_adaptor/detail/identity_converters.hpp>
+#include <boost/iterator/iterator_traits.hpp>
+
+#include <boost/bimap/container_adaptor/detail/functor_bag.hpp>
+#include <boost/mpl/vector.hpp>
+#include <boost/mpl/copy.hpp>
+#include <boost/mpl/front_inserter.hpp>
+#include <boost/call_traits.hpp>
+
+
+
+namespace boost {
+namespace bimaps {
+
+/// \brief Container Adaptor toolbox, easy way to build new containers from existing ones.
+
+namespace container_adaptor {
+
+/// \brief Container adaptor to build a type that is compliant to the concept of a container.
+
+template
+<
+ class Base,
+
+ class Iterator,
+ class ConstIterator,
+
+ class IteratorToBaseConverter = ::boost::mpl::na,
+ class IteratorFromBaseConverter = ::boost::mpl::na,
+ class ValueToBaseConverter = ::boost::mpl::na,
+ class ValueFromBaseConverter = ::boost::mpl::na,
+
+ class FunctorsFromDerivedClasses = mpl::vector<>
+>
+class container_adaptor
+{
+ // MetaData -------------------------------------------------------------
+
+ public:
+
+ typedef Iterator iterator;
+ typedef ConstIterator const_iterator;
+
+ typedef BOOST_DEDUCED_TYPENAME iterator_value < iterator >::type value_type;
+ typedef BOOST_DEDUCED_TYPENAME iterator_pointer < iterator >::type pointer;
+ typedef BOOST_DEDUCED_TYPENAME iterator_reference< iterator >::type reference;
+ typedef BOOST_DEDUCED_TYPENAME iterator_reference< const_iterator >::type const_reference;
+
+ typedef BOOST_DEDUCED_TYPENAME Base::size_type size_type;
+ typedef BOOST_DEDUCED_TYPENAME Base::difference_type difference_type;
+
+ typedef BOOST_DEDUCED_TYPENAME mpl::if_< ::boost::mpl::is_na<IteratorToBaseConverter>,
+ // {
+ ::boost::bimaps::container_adaptor::detail::
+ iterator_to_base_identity
+ <
+ BOOST_DEDUCED_TYPENAME Base::iterator , iterator,
+ BOOST_DEDUCED_TYPENAME Base::const_iterator , const_iterator
+ >,
+ // }
+ // else
+ // {
+ IteratorToBaseConverter
+ // }
+
+ >::type iterator_to_base;
+
+ typedef BOOST_DEDUCED_TYPENAME mpl::if_< ::boost::mpl::is_na<IteratorFromBaseConverter>,
+ // {
+ ::boost::bimaps::container_adaptor::detail::
+ iterator_from_base_identity
+ <
+ BOOST_DEDUCED_TYPENAME Base::iterator , iterator,
+ BOOST_DEDUCED_TYPENAME Base::const_iterator , const_iterator
+ >,
+ // }
+ // else
+ // {
+ IteratorFromBaseConverter
+ // }
+
+ >::type iterator_from_base;
+
+ typedef BOOST_DEDUCED_TYPENAME mpl::if_< ::boost::mpl::is_na<ValueToBaseConverter>,
+ // {
+ ::boost::bimaps::container_adaptor::detail::
+ value_to_base_identity
+ <
+ BOOST_DEDUCED_TYPENAME Base::value_type,
+ value_type
+ >,
+ // }
+ // else
+ // {
+ ValueToBaseConverter
+ // }
+
+ >::type value_to_base;
+
+ typedef BOOST_DEDUCED_TYPENAME mpl::if_< ::boost::mpl::is_na<ValueFromBaseConverter>,
+ // {
+ ::boost::bimaps::container_adaptor::detail::
+ value_from_base_identity
+ <
+ BOOST_DEDUCED_TYPENAME Base::value_type,
+ value_type
+ >,
+ // }
+ // else
+ // {
+ ValueFromBaseConverter
+ // }
+
+ >::type value_from_base;
+
+ // ACCESS -----------------------------------------------------------------
+
+ public:
+
+ explicit container_adaptor(Base & c) : dwfb(c) {}
+
+ protected:
+
+ typedef Base base_type;
+
+ typedef container_adaptor container_adaptor_;
+
+ const Base & base() const { return dwfb.data; }
+ Base & base() { return dwfb.data; }
+
+ // Interface --------------------------------------------------------------
+
+ public:
+
+ size_type size() const { return base().size(); }
+ size_type max_size() const { return base().max_size(); }
+ bool empty() const { return base().empty(); }
+
+ iterator begin()
+ {
+ return this->template functor<iterator_from_base>()( base().begin() );
+ }
+
+ iterator end()
+ {
+ return this->template functor<iterator_from_base>()( base().end() );
+ }
+
+ const_iterator begin() const
+ {
+ return this->template functor<iterator_from_base>()( base().begin() );
+ }
+
+ const_iterator end() const
+ {
+ return this->template functor<iterator_from_base>()( base().end() );
+ }
+
+
+ iterator erase(iterator pos)
+ {
+ return this->template functor<iterator_from_base>()(
+ base().erase(this->template functor<iterator_to_base>()(pos))
+ );
+ }
+
+ iterator erase(iterator first, iterator last)
+ {
+ return this->template functor<iterator_from_base>()(
+ base().erase(
+ this->template functor<iterator_to_base>()(first),
+ this->template functor<iterator_to_base>()(last)
+ )
+ );
+ }
+
+ void clear()
+ {
+ base().clear();
+ }
+
+ template< class InputIterator >
+ void insert(InputIterator iterBegin, InputIterator iterEnd)
+ {
+ for( ; iterBegin != iterEnd ; ++iterBegin )
+ {
+ base().insert( this->template
+ functor<value_to_base>()( *iterBegin )
+ );
+ }
+ }
+
+ std::pair<iterator, bool> insert(
+ BOOST_DEDUCED_TYPENAME ::boost::call_traits< value_type >::param_type x)
+ {
+ std::pair< BOOST_DEDUCED_TYPENAME Base::iterator, bool > r(
+ base().insert( this->template functor<value_to_base>()(x) )
+ );
+
+ return std::pair<iterator, bool>( this->template
+ functor<iterator_from_base>()(r.first),r.second
+ );
+ }
+
+ iterator insert(iterator pos,
+ BOOST_DEDUCED_TYPENAME ::boost::call_traits< value_type >::param_type x)
+ {
+ return this->template functor<iterator_from_base>()(
+ base().insert(
+ this->template functor<iterator_to_base>()(pos),
+ this->template functor<value_to_base>()(x))
+ );
+ }
+
+ void swap( container_adaptor & c )
+ {
+ base().swap( c.base() );
+ }
+
+ // Access to functors ----------------------------------------------------
+
+ protected:
+
+ template< class Functor >
+ Functor & functor()
+ {
+ return dwfb.template functor<Functor>();
+ }
+
+ template< class Functor >
+ Functor const & functor() const
+ {
+ return dwfb.template functor<Functor>();
+ }
+
+ // Data ------------------------------------------------------------------
+
+ private:
+
+ ::boost::bimaps::container_adaptor::detail::data_with_functor_bag
+ <
+ Base &,
+
+ BOOST_DEDUCED_TYPENAME mpl::copy
+ <
+ mpl::vector
+ <
+ iterator_to_base,
+ iterator_from_base,
+ value_to_base,
+ value_from_base
+ >,
+
+ mpl::front_inserter< FunctorsFromDerivedClasses >
+
+ >::type
+
+ > dwfb;
+};
+
+
+} // namespace container_adaptor
+} // namespace bimaps
+} // namespace boost
+
+
+#endif // BOOST_BIMAP_CONTAINER_ADAPTOR_CONTAINER_ADAPTOR_HPP
diff --git a/boost/bimap/container_adaptor/detail/comparison_adaptor.hpp b/boost/bimap/container_adaptor/detail/comparison_adaptor.hpp
new file mode 100644
index 0000000..9051a46
--- /dev/null
+++ b/boost/bimap/container_adaptor/detail/comparison_adaptor.hpp
@@ -0,0 +1,101 @@
+// 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 container_adaptor/detail/comparison_adaptor.hpp
+/// \brief Comparison adaptor.
+
+#ifndef BOOST_BIMAP_CONTAINER_ADAPTOR_DETAIL_COMPARISON_ADAPTOR_HPP
+#define BOOST_BIMAP_CONTAINER_ADAPTOR_DETAIL_COMPARISON_ADAPTOR_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER>=1200)
+#pragma once
+#endif
+
+#include <boost/config.hpp>
+
+#include <boost/call_traits.hpp>
+#include <functional>
+
+namespace boost {
+namespace bimaps {
+namespace container_adaptor {
+namespace detail {
+
+/// \brief Comparison adaptor
+/**
+
+A simple comparison adaptor.
+ **/
+
+template < class Compare, class NewType, class Converter >
+struct comparison_adaptor : std::binary_function<NewType,NewType,bool>
+{
+ comparison_adaptor( const Compare & comp, const Converter & conv)
+ : compare(comp), converter(conv) {}
+
+ bool operator()( BOOST_DEDUCED_TYPENAME call_traits<NewType>::param_type x,
+ BOOST_DEDUCED_TYPENAME call_traits<NewType>::param_type y) const
+ {
+ return compare( converter(x), converter(y) );
+ }
+
+ private:
+ Compare compare;
+ Converter converter;
+};
+
+template < class Compare, class NewType, class Converter >
+struct compatible_comparison_adaptor : std::binary_function<NewType,NewType,bool>
+{
+ compatible_comparison_adaptor( const Compare & comp, const Converter & conv)
+ : compare(comp), converter(conv) {}
+
+ template< class CompatibleTypeLeft, class CompatibleTypeRight >
+ bool operator()( const CompatibleTypeLeft & x,
+ const CompatibleTypeRight & y) const
+ {
+ return compare( converter(x), converter(y) );
+ }
+
+ private:
+ Compare compare;
+ Converter converter;
+};
+
+
+/// \brief Unary Check adaptor
+/**
+
+A simple unary check adaptor.
+ **/
+
+template < class Compare, class NewType, class Converter >
+struct unary_check_adaptor : std::unary_function<NewType,bool>
+{
+ unary_check_adaptor( const Compare & comp, const Converter & conv ) :
+ compare(comp), converter(conv) {}
+
+ bool operator()( BOOST_DEDUCED_TYPENAME call_traits<NewType>::param_type x) const
+ {
+ return compare( converter(x) );
+ }
+
+ private:
+ Compare compare;
+ Converter converter;
+};
+
+} // namespace detail
+} // namespace container_adaptor
+} // namespace bimaps
+} // namespace boost
+
+
+#endif // BOOST_BIMAP_CONTAINER_ADAPTOR_DETAIL_COMPARISON_ADAPTOR_HPP
+
+
diff --git a/boost/bimap/container_adaptor/detail/functor_bag.hpp b/boost/bimap/container_adaptor/detail/functor_bag.hpp
new file mode 100644
index 0000000..fd8c435
--- /dev/null
+++ b/boost/bimap/container_adaptor/detail/functor_bag.hpp
@@ -0,0 +1,100 @@
+// 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 container_adaptor/detail/functor_bag.hpp
+/// \brief Defines a EBO optimizacion helper for functors.
+
+#ifndef BOOST_BIMAP_CONTAINER_ADAPTOR_DETAIL_FUNCTOR_BAG_HPP
+#define BOOST_BIMAP_CONTAINER_ADAPTOR_DETAIL_FUNCTOR_BAG_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER>=1200)
+#pragma once
+#endif
+
+#include <boost/config.hpp>
+
+#if defined(BOOST_MSVC)
+// This bogus warning will appear when add_const is applied to a
+// const volatile reference because we can't detect const volatile
+// references with MSVC6.
+# pragma warning(push)
+# pragma warning(disable:4181)
+// warning C4181: qualifier applied to reference type ignored
+#endif
+
+#include <boost/mpl/placeholders.hpp>
+
+#include <boost/type_traits/add_reference.hpp>
+#include <boost/type_traits/is_base_of.hpp>
+
+#include <boost/mpl/inherit_linearly.hpp>
+#include <boost/mpl/inherit.hpp>
+
+namespace boost {
+namespace bimaps {
+namespace container_adaptor {
+namespace detail {
+
+/// \brief EBO optimizacion helper for functors
+/**
+
+This class is a generalization of a helper class explained in an article by
+Nathan C. Myers.\n
+See it at \link http://www.cantrip.org/emptyopt.html
+ **/
+
+template < class Data, class FunctorList >
+struct data_with_functor_bag :
+
+ public mpl::inherit_linearly<
+
+ FunctorList,
+ mpl::if_< is_base_of< mpl::_2, mpl::_1 >,
+ // {
+ mpl::_1,
+ // }
+ // else
+ // {
+ mpl::inherit< mpl::_1, mpl::_2 >
+ // }
+ >
+
+ >::type
+{
+ Data data;
+
+ data_with_functor_bag() {}
+
+ data_with_functor_bag(BOOST_DEDUCED_TYPENAME add_reference<Data>::type d)
+ : data(d) {}
+
+ template< class Functor >
+ Functor& functor()
+ {
+ return *(static_cast<Functor*>(this));
+ }
+
+ template< class Functor >
+ const Functor& functor() const
+ {
+ return *(static_cast<Functor const *>(this));
+ }
+};
+
+} // namespace detail
+} // namespace container_adaptor
+} // namespace bimaps
+} // namespace boost
+
+#if defined(BOOST_MSVC)
+# pragma warning(pop)
+#endif
+
+#endif // BOOST_BIMAP_CONTAINER_ADAPTOR_DETAIL_FUNCTOR_BAG_HPP
+
+
diff --git a/boost/bimap/container_adaptor/detail/identity_converters.hpp b/boost/bimap/container_adaptor/detail/identity_converters.hpp
new file mode 100644
index 0000000..f6f5864
--- /dev/null
+++ b/boost/bimap/container_adaptor/detail/identity_converters.hpp
@@ -0,0 +1,191 @@
+// 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 container_adaptor/detail/identity_converters.hpp
+/// \brief Value and iterators identity converters.
+
+#ifndef BOOST_BIMAP_CONTAINER_ADAPTOR_DETAIL_IDENTITY_CONVERTERS_HPP
+#define BOOST_BIMAP_CONTAINER_ADAPTOR_DETAIL_IDENTITY_CONVERTERS_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER>=1200)
+#pragma once
+#endif
+
+#include <boost/config.hpp>
+
+namespace boost {
+namespace bimaps {
+namespace container_adaptor {
+
+/// \brief Details of the container adaptor toolbox
+
+namespace detail {
+
+/// \brief Iterator identity converter used by default in container adaptors.
+/**
+If Iterator and ConstIterator are of the same type one of the convert function is not
+included.
+ **/
+
+template
+<
+ class BaseIterator , class Iterator,
+ class BaseConstIterator , class ConstIterator
+>
+struct iterator_to_base_identity
+{
+ BaseIterator operator()(Iterator iter) const
+ {
+ return BaseIterator(iter);
+ }
+
+ BaseConstIterator operator()(ConstIterator iter) const
+ {
+ return BaseConstIterator(iter);
+ }
+};
+
+#ifndef BOOST_BIMAP_DOXYGEN_WILL_NOT_PROCESS_THE_FOLLOWING_LINES
+
+template< class BaseIterator, class Iterator >
+struct iterator_to_base_identity<BaseIterator,Iterator,BaseIterator,Iterator>
+{
+ BaseIterator operator()(Iterator iter) const
+ {
+ return BaseIterator(iter);
+ }
+};
+
+#endif // BOOST_BIMAP_DOXYGEN_WILL_NOT_PROCESS_THE_FOLLOWING_LINES
+
+/// \brief Iterator from base identity converter used by default in container adaptors.
+/**
+If Iterator and ConstIterator are of the same type one of the convert function is not
+included.
+ **/
+
+template
+<
+ class BaseIterator , class Iterator,
+ class BaseConstIterator , class ConstIterator
+>
+struct iterator_from_base_identity
+{
+ Iterator operator()(BaseIterator iter) const
+ {
+ return Iterator(iter);
+ }
+ ConstIterator operator()(BaseConstIterator iter) const
+ {
+ return ConstIterator(iter);
+ }
+};
+
+#ifndef BOOST_BIMAP_DOXYGEN_WILL_NOT_PROCESS_THE_FOLLOWING_LINES
+
+template< class BaseIterator, class Iterator, class ConstIterator >
+struct iterator_from_base_identity<BaseIterator,Iterator,BaseIterator,ConstIterator>
+{
+ Iterator operator()(BaseIterator iter) const
+ {
+ return Iterator(iter);
+ }
+};
+
+#endif // BOOST_BIMAP_DOXYGEN_WILL_NOT_PROCESS_THE_FOLLOWING_LINES
+
+/// \brief Value to base identity converter used by default in container adaptors.
+
+template< class BaseValue, class Value >
+struct value_to_base_identity
+{
+ BaseValue operator()(const Value & val) const
+ {
+ return BaseValue(val);
+ }
+};
+
+#ifndef BOOST_BIMAP_DOXYGEN_WILL_NOT_PROCESS_THE_FOLLOWING_LINES
+
+template< class Value >
+struct value_to_base_identity< Value, Value >
+{
+ const Value & operator()(const Value & val) const
+ {
+ return val;
+ }
+};
+
+#endif // BOOST_BIMAP_DOXYGEN_WILL_NOT_PROCESS_THE_FOLLOWING_LINES
+
+/// \brief Value from base identity converter used by default in container adaptors.
+
+template< class BaseValue, class Value >
+struct value_from_base_identity
+{
+ Value operator()(const BaseValue & val) const
+ {
+ return Value(val);
+ }
+};
+
+#ifndef BOOST_BIMAP_DOXYGEN_WILL_NOT_PROCESS_THE_FOLLOWING_LINES
+
+template< class Value >
+struct value_from_base_identity<Value,Value>
+{
+ Value & operator()(Value & val) const
+ {
+ return val;
+ }
+
+ const Value & operator()(const Value & val) const
+ {
+ return val;
+ }
+};
+
+#endif // BOOST_BIMAP_DOXYGEN_WILL_NOT_PROCESS_THE_FOLLOWING_LINES
+
+/// \brief Key to base identity converter used by default in container adaptors.
+
+template< class BaseKey, class Key >
+struct key_to_base_identity
+{
+ BaseKey operator()(const Key & k) const
+ {
+ return BaseKey(k);
+ }
+};
+
+#ifndef BOOST_BIMAP_DOXYGEN_WILL_NOT_PROCESS_THE_FOLLOWING_LINES
+
+template< class Key >
+struct key_to_base_identity< Key, Key >
+{
+ // As default accept any type as key in order to allow container
+ // adaptors to work with compatible key types
+
+ template< class CompatibleKey >
+ const CompatibleKey & operator()(const CompatibleKey & k) const
+ {
+ return k;
+ }
+};
+
+#endif // BOOST_BIMAP_DOXYGEN_WILL_NOT_PROCESS_THE_FOLLOWING_LINES
+
+} // namespace detail
+} // namespace container_adaptor
+} // namespace bimaps
+} // namespace boost
+
+
+#endif // BOOST_BIMAP_CONTAINER_ADAPTOR_DETAIL_IDENTITY_CONVERTERS_HPP
+
+
diff --git a/boost/bimap/container_adaptor/detail/key_extractor.hpp b/boost/bimap/container_adaptor/detail/key_extractor.hpp
new file mode 100644
index 0000000..3835b7c
--- /dev/null
+++ b/boost/bimap/container_adaptor/detail/key_extractor.hpp
@@ -0,0 +1,45 @@
+// 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 container_adaptor/detail/key_extractor.hpp
+/// \brief Key extractor for a pair<Key,Data>.
+
+#ifndef BOOST_BIMAP_CONTAINER_ADAPTOR_DETAIL_KEY_EXTRACTOR_HPP
+#define BOOST_BIMAP_CONTAINER_ADAPTOR_DETAIL_KEY_EXTRACTOR_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER>=1200)
+#pragma once
+#endif
+
+#include <boost/config.hpp>
+
+#include <functional>
+
+namespace boost {
+namespace bimaps {
+namespace container_adaptor {
+namespace detail {
+
+/// \brief Key Extractor
+
+template < class T >
+struct key_from_pair_extractor
+ : std::unary_function< T, BOOST_DEDUCED_TYPENAME T::first_type >
+{
+ bool operator()( const T & p ) { return p.first; }
+};
+
+} // namespace detail
+} // namespace container_adaptor
+} // namespace bimaps
+} // namespace boost
+
+
+#endif // BOOST_BIMAP_CONTAINER_ADAPTOR_DETAIL_KEY_EXTRACTOR_HPP
+
+
diff --git a/boost/bimap/container_adaptor/detail/non_unique_container_helper.hpp b/boost/bimap/container_adaptor/detail/non_unique_container_helper.hpp
new file mode 100644
index 0000000..6957045
--- /dev/null
+++ b/boost/bimap/container_adaptor/detail/non_unique_container_helper.hpp
@@ -0,0 +1,62 @@
+// 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 container_adaptor/detail/non_unique_container_helper.hpp
+/// \brief Details for non unique containers
+
+#ifndef BOOST_BIMAP_CONTAINER_ADAPTOR_DETAIL_NON_UNIQUE_CONTAINER_HELPER_HPP
+#define BOOST_BIMAP_CONTAINER_ADAPTOR_DETAIL_NON_UNIQUE_CONTAINER_HELPER_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER>=1200)
+#pragma once
+#endif
+
+#include <boost/config.hpp>
+
+/*****************************************************************************/
+#define BOOST_BIMAP_NON_UNIQUE_CONTAINER_ADAPTOR_INSERT_FUNCTIONS \
+ \
+template <class InputIterator> \
+void insert(InputIterator iterBegin, InputIterator iterEnd) \
+{ \
+ for( ; iterBegin != iterEnd ; ++iterBegin ) \
+ { \
+ this->base().insert( \
+ this->template functor< \
+ BOOST_DEDUCED_TYPENAME base_::value_to_base>()( \
+ BOOST_DEDUCED_TYPENAME base_::value_type(*iterBegin)) ); \
+ } \
+} \
+ \
+BOOST_DEDUCED_TYPENAME base_::iterator insert( \
+ BOOST_DEDUCED_TYPENAME ::boost::call_traits< \
+ BOOST_DEDUCED_TYPENAME base_::value_type >::param_type x) \
+{ \
+ return this->base().insert( this->template functor< \
+ BOOST_DEDUCED_TYPENAME base_:: \
+ value_to_base>()(x) ); \
+} \
+ \
+BOOST_DEDUCED_TYPENAME base_::iterator \
+ insert(BOOST_DEDUCED_TYPENAME base_::iterator pos, \
+ BOOST_DEDUCED_TYPENAME ::boost::call_traits< \
+ BOOST_DEDUCED_TYPENAME base_::value_type >::param_type x) \
+{ \
+ return this->template functor< \
+ BOOST_DEDUCED_TYPENAME base_::iterator_from_base>()( \
+ this->base().insert(this->template functor< \
+ BOOST_DEDUCED_TYPENAME base_::iterator_to_base>()(pos), \
+ this->template functor< \
+ BOOST_DEDUCED_TYPENAME base_::value_to_base>()(x)) \
+ ); \
+}
+/*****************************************************************************/
+
+#endif // BOOST_BIMAP_CONTAINER_ADAPTOR_DETAIL_NON_UNIQUE_CONTAINER_HELPER_HPP
+
+
diff --git a/boost/bimap/container_adaptor/list_adaptor.hpp b/boost/bimap/container_adaptor/list_adaptor.hpp
new file mode 100644
index 0000000..310e2b4
--- /dev/null
+++ b/boost/bimap/container_adaptor/list_adaptor.hpp
@@ -0,0 +1,249 @@
+// 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 container_adaptor/list_adaptor.hpp
+/// \brief Container adaptor to easily build a std::list signature compatible container.
+
+#ifndef BOOST_BIMAP_CONTAINER_ADAPTOR_LIST_ADAPTOR_HPP
+#define BOOST_BIMAP_CONTAINER_ADAPTOR_LIST_ADAPTOR_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER>=1200)
+#pragma once
+#endif
+
+#include <boost/config.hpp>
+
+#include <boost/bimap/container_adaptor/sequence_container_adaptor.hpp>
+#include <boost/bimap/container_adaptor/detail/comparison_adaptor.hpp>
+#include <boost/mpl/aux_/na.hpp>
+#include <boost/mpl/vector.hpp>
+#include <boost/call_traits.hpp>
+#include <functional>
+
+namespace boost {
+namespace bimaps {
+namespace container_adaptor {
+
+/// \brief Container adaptor to easily build a std::list signature compatible container.
+
+template
+<
+ class Base,
+
+ class Iterator,
+ class ConstIterator,
+ class ReverseIterator,
+ class ConstReverseIterator,
+
+ class IteratorToBaseConverter = ::boost::mpl::na,
+ class IteratorFromBaseConverter = ::boost::mpl::na,
+ class ReverseIteratorFromBaseConverter = ::boost::mpl::na,
+ class ValueToBaseConverter = ::boost::mpl::na,
+ class ValueFromBaseConverter = ::boost::mpl::na,
+
+ class FunctorsFromDerivedClasses = mpl::vector<>
+>
+class list_adaptor :
+
+ public ::boost::bimaps::container_adaptor::sequence_container_adaptor
+ <
+ Base, Iterator, ConstIterator, ReverseIterator, ConstReverseIterator,
+ IteratorToBaseConverter, IteratorFromBaseConverter,
+ ReverseIteratorFromBaseConverter,
+ ValueToBaseConverter, ValueFromBaseConverter,
+ FunctorsFromDerivedClasses
+ >
+{
+ typedef ::boost::bimaps::container_adaptor::sequence_container_adaptor
+ <
+ Base, Iterator, ConstIterator, ReverseIterator, ConstReverseIterator,
+ IteratorToBaseConverter, IteratorFromBaseConverter,
+ ReverseIteratorFromBaseConverter,
+ ValueToBaseConverter, ValueFromBaseConverter,
+ FunctorsFromDerivedClasses
+
+ > base_;
+
+ // Access -----------------------------------------------------------------
+
+ public:
+
+ explicit list_adaptor(Base & c) :
+ base_(c) {}
+
+ protected:
+
+ typedef list_adaptor list_adaptor_;
+
+ // Interface -------------------------------------------------------------
+
+ public:
+
+ void splice(Iterator position, list_adaptor & x)
+ {
+ this->base().splice(
+ this->template functor<BOOST_DEDUCED_TYPENAME base_::iterator_to_base>()
+ (position),
+ x.base()
+ );
+ }
+
+ void splice(Iterator position, list_adaptor & x, Iterator i)
+ {
+ this->base().splice(
+ this->template functor<BOOST_DEDUCED_TYPENAME base_::iterator_to_base>()
+ (position),
+ x.base(),
+ this->template functor<BOOST_DEDUCED_TYPENAME base_::iterator_to_base>()(i)
+ );
+ }
+
+ void splice(Iterator position, list_adaptor & x,
+ Iterator first, Iterator last)
+ {
+ this->base().splice(
+ this->template functor<BOOST_DEDUCED_TYPENAME base_::iterator_to_base>()
+ (position),
+ x.base(),
+ this->template functor<BOOST_DEDUCED_TYPENAME base_::iterator_to_base>()(first),
+ this->template functor<BOOST_DEDUCED_TYPENAME base_::iterator_to_base>()(last)
+ );
+ }
+
+ void remove(
+ BOOST_DEDUCED_TYPENAME ::boost::call_traits<
+ BOOST_DEDUCED_TYPENAME base_::value_type
+ >::param_type value
+ )
+ {
+ this->base().remove(
+ this->template functor<BOOST_DEDUCED_TYPENAME base_::value_to_base>()(value)
+ );
+ }
+
+ template< class Predicate >
+ void remove_if(Predicate pred)
+ {
+ this->base().remove_if(
+ ::boost::bimaps::container_adaptor::detail::unary_check_adaptor
+ <
+ Predicate,
+ BOOST_DEDUCED_TYPENAME Base::value_type,
+ BOOST_DEDUCED_TYPENAME base_::value_from_base
+
+ >( pred, this->template functor<BOOST_DEDUCED_TYPENAME base_::value_from_base>() )
+ );
+ }
+
+ void unique()
+ {
+ this->base().unique(
+ ::boost::bimaps::container_adaptor::detail::comparison_adaptor
+ <
+ std::equal_to<BOOST_DEDUCED_TYPENAME base_::value_type>,
+ BOOST_DEDUCED_TYPENAME Base::value_type,
+ BOOST_DEDUCED_TYPENAME base_::value_from_base
+
+ >(
+ std::equal_to<BOOST_DEDUCED_TYPENAME base_::value_type>(),
+ this->template functor<BOOST_DEDUCED_TYPENAME base_::value_from_base>()
+ )
+ );
+ }
+
+ template< class BinaryPredicate >
+ void unique(BinaryPredicate binary_pred)
+ {
+ this->base().unique(
+ ::boost::bimaps::container_adaptor::detail::comparison_adaptor
+ <
+ BinaryPredicate,
+ BOOST_DEDUCED_TYPENAME Base::value_type,
+ BOOST_DEDUCED_TYPENAME base_::value_from_base
+
+ >( binary_pred,
+ this->template functor<BOOST_DEDUCED_TYPENAME base_::value_from_base>() )
+ );
+ }
+
+ void merge(list_adaptor & x)
+ {
+ this->base().merge(x.base(),
+ ::boost::bimaps::container_adaptor::detail::comparison_adaptor
+ <
+ std::less<BOOST_DEDUCED_TYPENAME base_::value_type>,
+ BOOST_DEDUCED_TYPENAME Base::value_type,
+ BOOST_DEDUCED_TYPENAME base_::value_from_base
+
+ >(
+ std::less<BOOST_DEDUCED_TYPENAME base_::value_type>(),
+ this->template functor<BOOST_DEDUCED_TYPENAME base_::value_from_base>()
+ )
+ );
+ }
+
+ template< class Compare >
+ void merge(list_adaptor & x, Compare comp)
+ {
+ this->base().merge(x.base(),
+ ::boost::bimaps::container_adaptor::detail::comparison_adaptor
+ <
+ Compare,
+ BOOST_DEDUCED_TYPENAME Base::value_type,
+ BOOST_DEDUCED_TYPENAME base_::value_from_base
+
+ >( comp, this->template functor<BOOST_DEDUCED_TYPENAME base_::value_from_base>() )
+ );
+ }
+
+ void sort()
+ {
+ this->base().sort(
+ ::boost::bimaps::container_adaptor::detail::comparison_adaptor
+ <
+ std::less<BOOST_DEDUCED_TYPENAME base_::value_type>,
+ BOOST_DEDUCED_TYPENAME Base::value_type,
+ BOOST_DEDUCED_TYPENAME base_::value_from_base
+
+ >(
+ std::less<BOOST_DEDUCED_TYPENAME base_::value_type>(),
+ this->template functor<BOOST_DEDUCED_TYPENAME base_::value_from_base>()
+ )
+ );
+ }
+
+ template< class Compare >
+ void sort(Compare comp)
+ {
+ this->base().sort(
+ ::boost::bimaps::container_adaptor::detail::comparison_adaptor
+ <
+ Compare,
+ BOOST_DEDUCED_TYPENAME Base::value_type,
+ BOOST_DEDUCED_TYPENAME base_::value_from_base
+
+ >( comp, this->template functor<BOOST_DEDUCED_TYPENAME base_::value_from_base>() )
+ );
+ }
+
+ void reverse()
+ {
+ this->base().reverse();
+ }
+
+};
+
+
+} // namespace container_adaptor
+} // namespace bimaps
+} // namespace boost
+
+
+#endif // BOOST_BIMAP_CONTAINER_ADAPTOR_SET_ADAPTOR_HPP
+
+
diff --git a/boost/bimap/container_adaptor/list_map_adaptor.hpp b/boost/bimap/container_adaptor/list_map_adaptor.hpp
new file mode 100644
index 0000000..ff7a540
--- /dev/null
+++ b/boost/bimap/container_adaptor/list_map_adaptor.hpp
@@ -0,0 +1,282 @@
+ // 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 container_adaptor/list_map_adaptor.hpp
+/// \brief Container adaptor.
+
+#ifndef BOOST_BIMAP_CONTAINER_ADAPTOR_LIST_MAP_ADAPTOR_HPP
+#define BOOST_BIMAP_CONTAINER_ADAPTOR_LIST_MAP_ADAPTOR_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER>=1200)
+#pragma once
+#endif
+
+#include <boost/config.hpp>
+
+#include <boost/mpl/list.hpp>
+#include <boost/mpl/push_front.hpp>
+
+#include <boost/bimap/container_adaptor/list_adaptor.hpp>
+#include <boost/bimap/container_adaptor/detail/identity_converters.hpp>
+#include <boost/bimap/container_adaptor/detail/key_extractor.hpp>
+#include <boost/bimap/container_adaptor/detail/comparison_adaptor.hpp>
+#include <boost/mpl/vector.hpp>
+#include <boost/mpl/aux_/na.hpp>
+#include <boost/mpl/if.hpp>
+
+namespace boost {
+namespace bimaps {
+namespace container_adaptor {
+
+#ifndef BOOST_BIMAP_DOXYGEN_WILL_NOT_PROCESS_THE_FOLLOWING_LINES
+
+template
+<
+ class Base, class Iterator, class ConstIterator,
+ class ReverseIterator, class ConstReverseIterator,
+ class IteratorToBaseConverter, class IteratorFromBaseConverter,
+ class ReverseIteratorFromBaseConverter,
+ class ValueToBaseConverter, class ValueFromBaseConverter,
+ class KeyFromBaseValueConverter,
+ class FunctorsFromDerivedClasses
+>
+struct list_map_adaptor_base
+{
+ typedef list_adaptor
+ <
+ Base,
+
+ Iterator, ConstIterator, ReverseIterator, ConstReverseIterator,
+
+ IteratorToBaseConverter, IteratorFromBaseConverter,
+
+ ReverseIteratorFromBaseConverter,
+
+ ValueToBaseConverter, ValueFromBaseConverter,
+
+ BOOST_DEDUCED_TYPENAME mpl::push_front<
+
+ FunctorsFromDerivedClasses,
+
+ BOOST_DEDUCED_TYPENAME mpl::if_< ::boost::mpl::is_na<KeyFromBaseValueConverter>,
+ // {
+ detail::key_from_pair_extractor
+ <
+ BOOST_DEDUCED_TYPENAME Iterator::value_type
+ >,
+ // }
+ // else
+ // {
+ KeyFromBaseValueConverter
+ // }
+
+ >::type
+
+ >::type
+
+ > type;
+};
+
+#endif // BOOST_BIMAP_DOXYGEN_WILL_NOT_PROCESS_THE_FOLLOWING_LINES
+
+/// \brief Container adaptor to easily build a list map container
+
+template
+<
+ class Base,
+
+ class Iterator,
+ class ConstIterator,
+ class ReverseIterator,
+ class ConstReverseIterator,
+
+ class IteratorToBaseConverter = ::boost::mpl::na,
+ class IteratorFromBaseConverter = ::boost::mpl::na,
+ class ReverseIteratorFromBaseConverter = ::boost::mpl::na,
+ class ValueToBaseConverter = ::boost::mpl::na,
+ class ValueFromBaseConverter = ::boost::mpl::na,
+ class KeyFromBaseValueConverter = ::boost::mpl::na,
+
+ class FunctorsFromDerivedClasses = mpl::vector<>
+>
+class list_map_adaptor :
+
+ public list_map_adaptor_base
+ <
+ Base, Iterator, ConstIterator, ReverseIterator, ConstReverseIterator,
+ IteratorToBaseConverter, IteratorFromBaseConverter,
+ ReverseIteratorFromBaseConverter,
+ ValueToBaseConverter, ValueFromBaseConverter,
+ KeyFromBaseValueConverter,
+ FunctorsFromDerivedClasses
+
+ >::type
+{
+ typedef BOOST_DEDUCED_TYPENAME list_map_adaptor_base
+ <
+ Base, Iterator, ConstIterator, ReverseIterator, ConstReverseIterator,
+ IteratorToBaseConverter, IteratorFromBaseConverter,
+ ReverseIteratorFromBaseConverter,
+ ValueToBaseConverter, ValueFromBaseConverter,
+ KeyFromBaseValueConverter,
+ FunctorsFromDerivedClasses
+
+ >::type base_;
+
+ // MetaData -------------------------------------------------------------
+
+ public:
+
+ typedef BOOST_DEDUCED_TYPENAME Iterator::value_type::first_type key_type;
+ typedef BOOST_DEDUCED_TYPENAME Iterator::value_type::second_type data_type;
+
+ protected:
+
+ typedef BOOST_DEDUCED_TYPENAME mpl::if_< ::boost::mpl::is_na<KeyFromBaseValueConverter>,
+ // {
+ detail::key_from_pair_extractor< BOOST_DEDUCED_TYPENAME Iterator::value_type >,
+ // }
+ // else
+ // {
+ KeyFromBaseValueConverter
+ // }
+
+ >::type key_from_base_value;
+
+ // Access -----------------------------------------------------------------
+
+ public:
+
+ explicit list_map_adaptor(Base & c) :
+ base_(c) {}
+
+ protected:
+
+ typedef list_map_adaptor list_map_adaptor_;
+
+ // Functions -------------------------------------------------------------
+
+ public:
+
+ // The following functions are overwritten in order to work
+ // with key_type instead of value_type
+
+ template< class Predicate >
+ void remove_if(Predicate pred)
+ {
+ this->base().remove_if(
+ ::boost::bimaps::container_adaptor::detail::unary_check_adaptor
+ <
+ Predicate,
+ BOOST_DEDUCED_TYPENAME Base::value_type,
+ key_from_base_value
+
+ >( pred, this->template functor<key_from_base_value>() )
+ );
+ }
+
+ void unique()
+ {
+ this->base().unique(
+ ::boost::bimaps::container_adaptor::detail::comparison_adaptor
+ <
+ std::equal_to<key_type>,
+ BOOST_DEDUCED_TYPENAME Base::value_type,
+ key_from_base_value
+
+ >(
+ std::equal_to<key_type>(),
+ this->template functor<key_from_base_value>()
+ )
+ );
+ }
+
+ template< class BinaryPredicate >
+ void unique(BinaryPredicate binary_pred)
+ {
+ this->base().unique(
+ ::boost::bimaps::container_adaptor::detail::comparison_adaptor
+ <
+ BinaryPredicate,
+ BOOST_DEDUCED_TYPENAME Base::value_type,
+ key_from_base_value
+
+ >( binary_pred, this->template functor<key_from_base_value>() )
+ );
+ }
+
+ void merge(list_map_adaptor & x)
+ {
+ this->base().merge(x.base(),
+ ::boost::bimaps::container_adaptor::detail::comparison_adaptor
+ <
+ std::less<key_type>,
+ BOOST_DEDUCED_TYPENAME Base::value_type,
+ key_from_base_value
+
+ >(
+ std::less<key_type>(),
+ this->template functor<key_from_base_value>()
+ )
+ );
+ }
+
+ template< class Compare >
+ void merge(list_map_adaptor & x, Compare comp)
+ {
+ this->base().merge(x.base(),
+ ::boost::bimaps::container_adaptor::detail::comparison_adaptor
+ <
+ Compare,
+ BOOST_DEDUCED_TYPENAME Base::value_type,
+ key_from_base_value
+
+ >( comp, this->template functor<key_from_base_value>() )
+ );
+ }
+
+ void sort()
+ {
+ this->base().sort(
+ ::boost::bimaps::container_adaptor::detail::comparison_adaptor
+ <
+ std::less<key_type>,
+ BOOST_DEDUCED_TYPENAME Base::value_type,
+ key_from_base_value
+
+ >(
+ std::less<key_type>(),
+ this->template functor<key_from_base_value>()
+ )
+ );
+ }
+
+ template< class Compare >
+ void sort(Compare comp)
+ {
+ this->base().sort(
+ ::boost::bimaps::container_adaptor::detail::comparison_adaptor
+ <
+ Compare,
+ BOOST_DEDUCED_TYPENAME Base::value_type,
+ key_from_base_value
+
+ >( comp, this->template functor<key_from_base_value>() )
+ );
+ }
+
+};
+
+
+} // namespace container_adaptor
+} // namespace bimaps
+} // namespace boost
+
+
+#endif // BOOST_BIMAP_CONTAINER_ADAPTOR_LIST_MAP_ADAPTOR_HPP
+
diff --git a/boost/bimap/container_adaptor/map_adaptor.hpp b/boost/bimap/container_adaptor/map_adaptor.hpp
new file mode 100644
index 0000000..f1a6f64
--- /dev/null
+++ b/boost/bimap/container_adaptor/map_adaptor.hpp
@@ -0,0 +1,131 @@
+// 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 container_adaptor/map_adaptor.hpp
+/// \brief Container adaptor to easily build a std::map signature compatible container.
+
+#ifndef BOOST_BIMAP_CONTAINER_ADAPTOR_MAP_ADAPTOR_HPP
+#define BOOST_BIMAP_CONTAINER_ADAPTOR_MAP_ADAPTOR_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER>=1200)
+#pragma once
+#endif
+
+#include <boost/config.hpp>
+
+#include <boost/bimap/container_adaptor/ordered_associative_container_adaptor.hpp>
+#include <boost/mpl/vector.hpp>
+#include <boost/mpl/aux_/na.hpp>
+#include <boost/call_traits.hpp>
+
+namespace boost {
+namespace bimaps {
+namespace container_adaptor {
+
+/// \brief Container adaptor to easily build a std::map signature compatible container.
+
+template
+<
+ class Base,
+
+ class Iterator,
+ class ConstIterator,
+ class ReverseIterator,
+ class ConstReverseIterator,
+
+ class IteratorToBaseConverter = ::boost::mpl::na,
+ class IteratorFromBaseConverter = ::boost::mpl::na,
+ class ReverseIteratorFromBaseConverter = ::boost::mpl::na,
+ class ValueToBaseConverter = ::boost::mpl::na,
+ class ValueFromBaseConverter = ::boost::mpl::na,
+ class KeyToBaseConverter = ::boost::mpl::na,
+
+ class FunctorsFromDerivedClasses = mpl::vector<>
+>
+class map_adaptor :
+
+ public ::boost::bimaps::container_adaptor::
+ ordered_associative_container_adaptor
+ <
+ Base,
+ Iterator, ConstIterator, ReverseIterator, ConstReverseIterator,
+ BOOST_DEDUCED_TYPENAME Iterator::value_type::first_type,
+ IteratorToBaseConverter, IteratorFromBaseConverter,
+ ReverseIteratorFromBaseConverter,
+ ValueToBaseConverter, ValueFromBaseConverter,
+ KeyToBaseConverter,
+ FunctorsFromDerivedClasses
+ >
+{
+
+ typedef ::boost::bimaps::container_adaptor::
+ ordered_associative_container_adaptor
+ <
+ Base,
+ Iterator, ConstIterator, ReverseIterator, ConstReverseIterator,
+ BOOST_DEDUCED_TYPENAME Iterator::value_type::first_type,
+ IteratorToBaseConverter, IteratorFromBaseConverter,
+ ReverseIteratorFromBaseConverter,
+ ValueToBaseConverter, ValueFromBaseConverter,
+ KeyToBaseConverter,
+ FunctorsFromDerivedClasses
+
+ > base_;
+
+ // MetaData -------------------------------------------------------------
+
+ public:
+
+ typedef BOOST_DEDUCED_TYPENAME Iterator::value_type::second_type data_type;
+
+ // Access -----------------------------------------------------------------
+
+ public:
+
+ explicit map_adaptor(Base & c) :
+ base_(c) {}
+
+ protected:
+
+ typedef map_adaptor map_adaptor_;
+
+ // Interface --------------------------------------------------------------
+
+ public:
+
+ template< class CompatibleKey >
+ data_type& operator[](const CompatibleKey & k)
+ {
+ return this->base()
+ [this->template functor<BOOST_DEDUCED_TYPENAME base_::key_to_base>()(k)];
+ }
+
+ template< class CompatibleKey >
+ data_type& at(const CompatibleKey & k)
+ {
+ return this->base().
+ at(this->template functor<BOOST_DEDUCED_TYPENAME base_::key_to_base>()(k));
+ }
+
+ template< class CompatibleKey >
+ const data_type& at(const CompatibleKey & k) const
+ {
+ return this->base().
+ at(this->template functor<BOOST_DEDUCED_TYPENAME base_::key_to_base>()(k));
+ }
+
+};
+
+
+} // namespace container_adaptor
+} // namespace bimaps
+} // namespace boost
+
+
+#endif // BOOST_BIMAP_CONTAINER_ADAPTOR_MAP_ADAPTOR_HPP
+
diff --git a/boost/bimap/container_adaptor/multimap_adaptor.hpp b/boost/bimap/container_adaptor/multimap_adaptor.hpp
new file mode 100644
index 0000000..ad5edf2
--- /dev/null
+++ b/boost/bimap/container_adaptor/multimap_adaptor.hpp
@@ -0,0 +1,109 @@
+// 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 container_adaptor/multimap_adaptor.hpp
+/// \brief Container adaptor to easily build a std::multimap signature compatible container.
+
+#ifndef BOOST_BIMAP_CONTAINER_ADAPTOR_MULTIMAP_ADAPTOR_HPP
+#define BOOST_BIMAP_CONTAINER_ADAPTOR_MULTIMAP_ADAPTOR_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER>=1200)
+#pragma once
+#endif
+
+#include <boost/config.hpp>
+
+#include <boost/bimap/container_adaptor/ordered_associative_container_adaptor.hpp>
+#include <boost/bimap/container_adaptor/detail/non_unique_container_helper.hpp>
+#include <boost/mpl/aux_/na.hpp>
+#include <boost/mpl/vector.hpp>
+
+namespace boost {
+namespace bimaps {
+namespace container_adaptor {
+
+/// \brief Container adaptor to easily build a std::multimap signature compatible container.
+
+template
+<
+ class Base,
+
+ class Iterator,
+ class ConstIterator,
+ class ReverseIterator,
+ class ConstReverseIterator,
+
+ class IteratorToBaseConverter = ::boost::mpl::na,
+ class IteratorFromBaseConverter = ::boost::mpl::na,
+ class ReverseIteratorFromBaseConverter = ::boost::mpl::na,
+ class ValueToBaseConverter = ::boost::mpl::na,
+ class ValueFromBaseConverter = ::boost::mpl::na,
+ class KeyToBaseConverter = ::boost::mpl::na,
+
+ class FunctorsFromDerivedClasses = mpl::vector<>
+>
+class multimap_adaptor :
+
+ public ::boost::bimaps::container_adaptor::
+ ordered_associative_container_adaptor
+ <
+ Base,
+ Iterator, ConstIterator, ReverseIterator, ConstReverseIterator,
+ BOOST_DEDUCED_TYPENAME Iterator::value_type::first_type,
+ IteratorToBaseConverter, IteratorFromBaseConverter,
+ ReverseIteratorFromBaseConverter,
+ ValueToBaseConverter, ValueFromBaseConverter,
+ KeyToBaseConverter,
+ FunctorsFromDerivedClasses
+ >
+{
+ typedef ::boost::bimaps::container_adaptor::
+ ordered_associative_container_adaptor
+ <
+ Base,
+ Iterator, ConstIterator, ReverseIterator, ConstReverseIterator,
+ BOOST_DEDUCED_TYPENAME Iterator::value_type::first_type,
+ IteratorToBaseConverter, IteratorFromBaseConverter,
+ ReverseIteratorFromBaseConverter,
+ ValueToBaseConverter, ValueFromBaseConverter,
+ KeyToBaseConverter,
+ FunctorsFromDerivedClasses
+
+ > base_;
+
+ // MetaData -------------------------------------------------------------
+
+ public:
+
+ typedef BOOST_DEDUCED_TYPENAME Iterator::value_type::second_type data_type;
+
+ // Access -----------------------------------------------------------------
+
+ public:
+
+ explicit multimap_adaptor(Base & c) :
+ base_(c) {}
+
+ protected:
+
+ typedef multimap_adaptor multimap_adaptor_;
+
+ public:
+
+ BOOST_BIMAP_NON_UNIQUE_CONTAINER_ADAPTOR_INSERT_FUNCTIONS
+};
+
+
+} // namespace container_adaptor
+} // namespace bimaps
+} // namespace boost
+
+
+#endif // BOOST_BIMAP_CONTAINER_ADAPTOR_MULTIMAP_ADAPTOR_HPP
+
+
diff --git a/boost/bimap/container_adaptor/multiset_adaptor.hpp b/boost/bimap/container_adaptor/multiset_adaptor.hpp
new file mode 100644
index 0000000..fe89d9a
--- /dev/null
+++ b/boost/bimap/container_adaptor/multiset_adaptor.hpp
@@ -0,0 +1,103 @@
+// 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 container_adaptor/multiset_adaptor.hpp
+/// \brief Container adaptor to easily build a std::multiset signature compatible container.
+
+#ifndef BOOST_BIMAP_CONTAINER_ADAPTOR_MULTISET_ADAPTOR_HPP
+#define BOOST_BIMAP_CONTAINER_ADAPTOR_MULTISET_ADAPTOR_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER>=1200)
+#pragma once
+#endif
+
+#include <boost/config.hpp>
+
+#include <boost/bimap/container_adaptor/ordered_associative_container_adaptor.hpp>
+#include <boost/bimap/container_adaptor/detail/non_unique_container_helper.hpp>
+#include <boost/mpl/aux_/na.hpp>
+#include <boost/mpl/vector.hpp>
+
+namespace boost {
+namespace bimaps {
+namespace container_adaptor {
+
+/// \brief Container adaptor to easily build a std::multiset signature compatible container.
+
+template
+<
+ class Base,
+
+ class Iterator,
+ class ConstIterator,
+ class ReverseIterator,
+ class ConstReverseIterator,
+
+ class IteratorToBaseConverter = ::boost::mpl::na,
+ class IteratorFromBaseConverter = ::boost::mpl::na,
+ class ReverseIteratorFromBaseConverter = ::boost::mpl::na,
+ class ValueToBaseConverter = ::boost::mpl::na,
+ class ValueFromBaseConverter = ::boost::mpl::na,
+ class KeyToBaseConverter = ::boost::mpl::na,
+
+ class FunctorsFromDerivedClasses = mpl::vector<>
+>
+class multiset_adaptor :
+
+ public ::boost::bimaps::container_adaptor::
+ ordered_associative_container_adaptor
+ <
+ Base,
+ Iterator, ConstIterator, ReverseIterator, ConstReverseIterator,
+ BOOST_DEDUCED_TYPENAME Iterator::value_type,
+ IteratorToBaseConverter, IteratorFromBaseConverter,
+ ReverseIteratorFromBaseConverter,
+ ValueToBaseConverter, ValueFromBaseConverter,
+ KeyToBaseConverter,
+ FunctorsFromDerivedClasses
+ >
+{
+
+ typedef ::boost::bimaps::container_adaptor::
+ ordered_associative_container_adaptor
+ <
+ Base,
+ Iterator, ConstIterator, ReverseIterator, ConstReverseIterator,
+ BOOST_DEDUCED_TYPENAME Iterator::value_type,
+ IteratorToBaseConverter, IteratorFromBaseConverter,
+ ReverseIteratorFromBaseConverter,
+ ValueToBaseConverter, ValueFromBaseConverter,
+ KeyToBaseConverter,
+ FunctorsFromDerivedClasses
+
+ > base_;
+
+ // Access -----------------------------------------------------------------
+
+ public:
+
+ explicit multiset_adaptor(Base & c) :
+ base_(c) {}
+
+ protected:
+
+ typedef multiset_adaptor multiset_adaptor_;
+
+ public:
+
+ BOOST_BIMAP_NON_UNIQUE_CONTAINER_ADAPTOR_INSERT_FUNCTIONS
+};
+
+
+} // namespace container_adaptor
+} // namespace bimaps
+} // namespace boost
+
+
+#endif // BOOST_BIMAP_CONTAINER_ADAPTOR_MULTISET_ADAPTOR_HPP
+
diff --git a/boost/bimap/container_adaptor/ordered_associative_container_adaptor.hpp b/boost/bimap/container_adaptor/ordered_associative_container_adaptor.hpp
new file mode 100644
index 0000000..6278844
--- /dev/null
+++ b/boost/bimap/container_adaptor/ordered_associative_container_adaptor.hpp
@@ -0,0 +1,312 @@
+// 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 container_adaptor/ordered_associative_container_adaptor.hpp
+/// \brief Container adaptor to build a type that is compliant to the concept of an ordered associative container.
+
+#ifndef BOOST_BIMAP_CONTAINER_ADAPTOR_ORDERED_ASSOCIATIVE_CONTAINER_ADAPTOR_HPP
+#define BOOST_BIMAP_CONTAINER_ADAPTOR_ORDERED_ASSOCIATIVE_CONTAINER_ADAPTOR_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER>=1200)
+#pragma once
+#endif
+
+#include <boost/config.hpp>
+
+#include <boost/bimap/container_adaptor/associative_container_adaptor.hpp>
+#include <boost/bimap/container_adaptor/detail/comparison_adaptor.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/mpl/vector.hpp>
+#include <boost/mpl/push_front.hpp>
+#include <boost/mpl/aux_/na.hpp>
+#include <boost/operators.hpp>
+#include <boost/call_traits.hpp>
+
+namespace boost {
+namespace bimaps {
+namespace container_adaptor {
+
+#ifndef BOOST_BIMAP_DOXYGEN_WILL_NOT_PROCESS_THE_FOLLOWING_LINES
+
+template
+<
+ class Base, class Iterator, class ConstIterator,
+ class ReverseIterator, class ConstReverseIterator, class KeyType,
+ class IteratorToBaseConverter, class IteratorFromBaseConverter,
+ class ReverseIteratorFromBaseConverter,
+ class ValueToBaseConverter, class ValueFromBaseConverter,
+ class KeyToBaseConverter,
+ class FunctorsFromDerivedClasses
+>
+struct ordered_associative_container_adaptor_base
+{
+ typedef associative_container_adaptor<
+ Base, Iterator, ConstIterator, KeyType,
+ IteratorToBaseConverter, IteratorFromBaseConverter,
+ ValueToBaseConverter, ValueFromBaseConverter, KeyToBaseConverter,
+
+ BOOST_DEDUCED_TYPENAME mpl::push_front<
+
+ FunctorsFromDerivedClasses,
+
+ BOOST_DEDUCED_TYPENAME mpl::if_<
+ ::boost::mpl::is_na<ReverseIteratorFromBaseConverter>,
+ // {
+ detail::iterator_from_base_identity
+ <
+ BOOST_DEDUCED_TYPENAME Base::reverse_iterator,
+ ReverseIterator,
+ BOOST_DEDUCED_TYPENAME Base::const_reverse_iterator,
+ ConstReverseIterator
+ >,
+ // }
+ // else
+ // {
+ ReverseIteratorFromBaseConverter
+ // }
+
+ >::type
+
+ >::type
+
+ > type;
+};
+
+#endif // BOOST_BIMAP_DOXYGEN_WILL_NOT_PROCESS_THE_FOLLOWING_LINES
+
+/// \brief Container adaptor to build a type that is compliant to the concept of an ordered associative container.
+
+template
+<
+ class Base,
+
+ class Iterator,
+ class ConstIterator,
+ class ReverseIterator,
+ class ConstReverseIterator,
+
+ class KeyType,
+
+ class IteratorToBaseConverter = ::boost::mpl::na,
+ class IteratorFromBaseConverter = ::boost::mpl::na,
+ class ReverseIteratorFromBaseConverter = ::boost::mpl::na,
+ class ValueToBaseConverter = ::boost::mpl::na,
+ class ValueFromBaseConverter = ::boost::mpl::na,
+ class KeyToBaseConverter = ::boost::mpl::na,
+
+ class FunctorsFromDerivedClasses = mpl::vector<>
+>
+class ordered_associative_container_adaptor :
+
+ public ordered_associative_container_adaptor_base
+ <
+ Base, Iterator, ConstIterator,
+ ReverseIterator, ConstReverseIterator, KeyType,
+ IteratorToBaseConverter, IteratorFromBaseConverter,
+ ReverseIteratorFromBaseConverter,
+ ValueToBaseConverter, ValueFromBaseConverter, KeyToBaseConverter,
+ FunctorsFromDerivedClasses
+
+ >::type,
+
+ ::boost::totally_ordered
+ <
+ ordered_associative_container_adaptor
+ <
+ Base, Iterator, ConstIterator,
+ ReverseIterator, ConstReverseIterator,
+ KeyType, IteratorToBaseConverter, IteratorFromBaseConverter,
+ ReverseIteratorFromBaseConverter,
+ ValueToBaseConverter, ValueFromBaseConverter,
+ KeyToBaseConverter, FunctorsFromDerivedClasses
+ >
+ >
+{
+ // MetaData -------------------------------------------------------------
+
+ typedef BOOST_DEDUCED_TYPENAME ordered_associative_container_adaptor_base
+ <
+ Base, Iterator, ConstIterator,
+ ReverseIterator, ConstReverseIterator, KeyType,
+ IteratorToBaseConverter, IteratorFromBaseConverter,
+ ReverseIteratorFromBaseConverter,
+ ValueToBaseConverter, ValueFromBaseConverter, KeyToBaseConverter,
+ FunctorsFromDerivedClasses
+
+ >::type base_;
+
+ public:
+
+ typedef detail::compatible_comparison_adaptor
+ <
+ BOOST_DEDUCED_TYPENAME Base::key_compare,
+ BOOST_DEDUCED_TYPENAME base_::key_type,
+ BOOST_DEDUCED_TYPENAME base_::key_to_base
+
+ > key_compare;
+
+ typedef detail::comparison_adaptor
+ <
+ BOOST_DEDUCED_TYPENAME Base::value_compare,
+ BOOST_DEDUCED_TYPENAME base_::value_type,
+ BOOST_DEDUCED_TYPENAME base_::value_to_base
+
+ > value_compare;
+
+ typedef ReverseIterator reverse_iterator;
+ typedef ConstReverseIterator const_reverse_iterator;
+
+ protected:
+
+ typedef BOOST_DEDUCED_TYPENAME mpl::if_<
+ ::boost::mpl::is_na<ReverseIteratorFromBaseConverter>,
+ // {
+ detail::iterator_from_base_identity
+ <
+ BOOST_DEDUCED_TYPENAME Base::reverse_iterator,
+ reverse_iterator,
+ BOOST_DEDUCED_TYPENAME Base::const_reverse_iterator,
+ const_reverse_iterator
+ >,
+ // }
+ // else
+ // {
+ ReverseIteratorFromBaseConverter
+ // }
+
+ >::type reverse_iterator_from_base;
+
+ // Access -----------------------------------------------------------------
+
+ public:
+
+ explicit ordered_associative_container_adaptor(Base & c)
+ : base_(c) {}
+
+ protected:
+
+ typedef ordered_associative_container_adaptor
+ ordered_associative_container_adaptor_;
+
+ // Interface --------------------------------------------------------------
+
+ public:
+
+ reverse_iterator rbegin()
+ {
+ return this->template functor<
+ reverse_iterator_from_base
+ >() ( this->base().rbegin() );
+
+ }
+
+ reverse_iterator rend()
+ {
+ return this->template functor<
+ reverse_iterator_from_base
+ >() ( this->base().rend() );
+ }
+
+ const_reverse_iterator rbegin() const
+ {
+ return this->template functor<
+ reverse_iterator_from_base
+ >() ( this->base().rbegin() );
+ }
+
+ const_reverse_iterator rend() const
+ {
+ return this->template functor<
+ reverse_iterator_from_base
+ >() ( this->base().rend() );
+ }
+
+ key_compare key_comp() const
+ {
+ typedef BOOST_DEDUCED_TYPENAME base_::key_to_base key_to_base_;
+
+ return key_compare(
+ this->base().key_comp(),
+ this->template functor<key_to_base_>()
+ );
+ }
+
+ value_compare value_comp() const
+ {
+ typedef BOOST_DEDUCED_TYPENAME base_::value_to_base value_to_base_;
+
+ return value_compare(
+ this->base().value_comp(),
+ this->template functor<value_to_base_>()
+ );
+ }
+
+ template< class CompatibleKey >
+ BOOST_DEDUCED_TYPENAME base_::iterator lower_bound(const CompatibleKey & k)
+ {
+ return this->template functor<
+ BOOST_DEDUCED_TYPENAME base_::iterator_from_base>()(
+ this->base().lower_bound(
+ this->template functor<BOOST_DEDUCED_TYPENAME base_::key_to_base>()(k)
+ )
+ );
+ }
+
+ template< class CompatibleKey >
+ BOOST_DEDUCED_TYPENAME base_::const_iterator lower_bound(const CompatibleKey & k) const
+ {
+ return this->template functor<
+ BOOST_DEDUCED_TYPENAME base_::iterator_from_base>()(
+ this->base().lower_bound(
+ this->template functor<BOOST_DEDUCED_TYPENAME base_::key_to_base>()(k)
+ )
+ );
+ }
+
+ template< class CompatibleKey >
+ BOOST_DEDUCED_TYPENAME base_::iterator upper_bound(const CompatibleKey & k)
+ {
+ return this->template functor<
+ BOOST_DEDUCED_TYPENAME base_::iterator_from_base>()(
+ this->base().upper_bound(
+ this->template functor<BOOST_DEDUCED_TYPENAME base_::key_to_base>()(k)
+ )
+ );
+ }
+
+ template< class CompatibleKey >
+ BOOST_DEDUCED_TYPENAME base_::const_iterator upper_bound(const CompatibleKey & k) const
+ {
+ return this->template functor<
+ BOOST_DEDUCED_TYPENAME base_::iterator_from_base>()(
+ this->base().upper_bound(
+ this->template functor<BOOST_DEDUCED_TYPENAME base_::key_to_base>()(k)
+ )
+ );
+ }
+
+ // Totally ordered implementation
+
+ bool operator==(const ordered_associative_container_adaptor & c) const
+ {
+ return ( this->base() == c.base() );
+ }
+
+ bool operator<(const ordered_associative_container_adaptor & c) const
+ {
+ return ( this->base() < c.base() );
+ }
+};
+
+
+} // namespace container_adaptor
+} // namespace bimaps
+} // namespace boost
+
+
+#endif // BOOST_BIMAP_CONTAINER_ADAPTOR_ORDERED_ASSOCIATIVE_CONTAINER_ADAPTOR_HPP
diff --git a/boost/bimap/container_adaptor/sequence_container_adaptor.hpp b/boost/bimap/container_adaptor/sequence_container_adaptor.hpp
new file mode 100644
index 0000000..4771149
--- /dev/null
+++ b/boost/bimap/container_adaptor/sequence_container_adaptor.hpp
@@ -0,0 +1,356 @@
+// 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 container_adaptor/sequence_container_adaptor.hpp
+/// \brief Container adaptor to build a type that is compliant to the concept of a weak associative container.
+
+#ifndef BOOST_BIMAP_CONTAINER_ADAPTOR_SEQUENCE_CONTAINER_ADAPTOR_HPP
+#define BOOST_BIMAP_CONTAINER_ADAPTOR_SEQUENCE_CONTAINER_ADAPTOR_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER>=1200)
+#pragma once
+#endif
+
+#include <boost/config.hpp>
+
+#include <utility>
+
+#include <boost/mpl/if.hpp>
+#include <boost/mpl/vector.hpp>
+#include <boost/mpl/aux_/na.hpp>
+#include <boost/bimap/container_adaptor/detail/identity_converters.hpp>
+#include <boost/bimap/container_adaptor/container_adaptor.hpp>
+#include <boost/call_traits.hpp>
+#include <boost/operators.hpp>
+
+namespace boost {
+namespace bimaps {
+namespace container_adaptor {
+
+#ifndef BOOST_BIMAP_DOXYGEN_WILL_NOT_PROCESS_THE_FOLLOWING_LINES
+
+template
+<
+ class Base, class Iterator, class ConstIterator,
+ class ReverseIterator, class ConstReverseIterator,
+ class IteratorToBaseConverter, class IteratorFromBaseConverter,
+ class ReverseIteratorFromBaseConverter,
+ class ValueToBaseConverter, class ValueFromBaseConverter,
+ class FunctorsFromDerivedClasses
+>
+struct sequence_container_adaptor_base
+{
+ typedef container_adaptor
+ <
+ Base, Iterator, ConstIterator,
+ IteratorToBaseConverter, IteratorFromBaseConverter,
+ ValueToBaseConverter, ValueFromBaseConverter,
+
+ BOOST_DEDUCED_TYPENAME mpl::push_front<
+
+ FunctorsFromDerivedClasses,
+
+ BOOST_DEDUCED_TYPENAME mpl::if_<
+ ::boost::mpl::is_na<ReverseIteratorFromBaseConverter>,
+ // {
+ detail::iterator_from_base_identity
+ <
+ BOOST_DEDUCED_TYPENAME Base::reverse_iterator,
+ ReverseIterator,
+ BOOST_DEDUCED_TYPENAME Base::const_reverse_iterator,
+ ConstReverseIterator
+ >,
+ // }
+ // else
+ // {
+ ReverseIteratorFromBaseConverter
+ // }
+
+ >::type
+
+ >::type
+
+ > type;
+};
+
+#endif // BOOST_BIMAP_DOXYGEN_WILL_NOT_PROCESS_THE_FOLLOWING_LINES
+
+/// \brief Container adaptor to build a type that is compliant to the concept of a sequence container.
+
+template
+<
+ class Base,
+
+ class Iterator,
+ class ConstIterator,
+
+ class ReverseIterator,
+ class ConstReverseIterator,
+
+ class IteratorToBaseConverter = ::boost::mpl::na,
+ class IteratorFromBaseConverter = ::boost::mpl::na,
+ class ReverseIteratorFromBaseConverter = ::boost::mpl::na,
+ class ValueToBaseConverter = ::boost::mpl::na,
+ class ValueFromBaseConverter = ::boost::mpl::na,
+
+ class FunctorsFromDerivedClasses = mpl::vector<>
+>
+class sequence_container_adaptor :
+
+ public sequence_container_adaptor_base
+ <
+ Base, Iterator, ConstIterator,
+ ReverseIterator, ConstReverseIterator,
+ IteratorToBaseConverter, IteratorFromBaseConverter,
+ ReverseIteratorFromBaseConverter,
+ ValueToBaseConverter, ValueFromBaseConverter,
+ FunctorsFromDerivedClasses
+
+ >::type,
+
+ ::boost::totally_ordered
+ <
+ sequence_container_adaptor
+ <
+ Base, Iterator, ConstIterator,
+ ReverseIterator, ConstReverseIterator,
+ IteratorToBaseConverter, IteratorFromBaseConverter,
+ ReverseIteratorFromBaseConverter,
+ ValueToBaseConverter, ValueFromBaseConverter,
+ FunctorsFromDerivedClasses
+ >
+ >
+{
+ typedef BOOST_DEDUCED_TYPENAME sequence_container_adaptor_base
+ <
+ Base, Iterator, ConstIterator,
+ ReverseIterator, ConstReverseIterator,
+ IteratorToBaseConverter, IteratorFromBaseConverter,
+ ReverseIteratorFromBaseConverter,
+ ValueToBaseConverter, ValueFromBaseConverter,
+ FunctorsFromDerivedClasses
+
+ >::type base_;
+
+ // MetaData -------------------------------------------------------------
+
+ public:
+
+ typedef ReverseIterator reverse_iterator;
+ typedef ConstReverseIterator const_reverse_iterator;
+
+ protected:
+
+ typedef BOOST_DEDUCED_TYPENAME mpl::if_<
+ ::boost::mpl::is_na<ReverseIteratorFromBaseConverter>,
+ // {
+ detail::iterator_from_base_identity
+ <
+ BOOST_DEDUCED_TYPENAME Base::reverse_iterator,
+ reverse_iterator,
+ BOOST_DEDUCED_TYPENAME Base::const_reverse_iterator,
+ const_reverse_iterator
+ >,
+ // }
+ // else
+ // {
+ ReverseIteratorFromBaseConverter
+ // }
+
+ >::type reverse_iterator_from_base;
+
+
+ // Access -----------------------------------------------------------------
+
+ public:
+
+ explicit sequence_container_adaptor(Base & c)
+ : base_(c) {}
+
+ protected:
+
+
+ typedef sequence_container_adaptor sequence_container_adaptor_;
+
+ // Interface --------------------------------------------------------------
+
+ public:
+
+ reverse_iterator rbegin()
+ {
+ return this->template functor<
+ reverse_iterator_from_base
+ >() ( this->base().rbegin() );
+
+ }
+
+ reverse_iterator rend()
+ {
+ return this->template functor<
+ reverse_iterator_from_base
+ >() ( this->base().rend() );
+ }
+
+ const_reverse_iterator rbegin() const
+ {
+ return this->template functor<
+ reverse_iterator_from_base
+ >() ( this->base().rbegin() );
+ }
+
+ const_reverse_iterator rend() const
+ {
+ return this->template functor<
+ reverse_iterator_from_base
+ >() ( this->base().rend() );
+ }
+
+ void resize(BOOST_DEDUCED_TYPENAME base_::size_type n,
+ BOOST_DEDUCED_TYPENAME ::boost::call_traits<
+ BOOST_DEDUCED_TYPENAME base_::value_type >::param_type x =
+ BOOST_DEDUCED_TYPENAME base_::value_type())
+ {
+ this->base().resize(n,
+ this->template functor<BOOST_DEDUCED_TYPENAME base_::value_to_base>()(x)
+ );
+ }
+
+ BOOST_DEDUCED_TYPENAME base_::reference front()
+ {
+ return this->template functor<
+ BOOST_DEDUCED_TYPENAME base_::value_from_base>()
+ (
+ this->base().front()
+ );
+ }
+
+ BOOST_DEDUCED_TYPENAME base_::reference back()
+ {
+ return this->template functor<
+ BOOST_DEDUCED_TYPENAME base_::value_from_base>()
+ (
+ this->base().back()
+ );
+ }
+
+ BOOST_DEDUCED_TYPENAME base_::const_reference front() const
+ {
+ return this->template functor<
+ BOOST_DEDUCED_TYPENAME base_::value_from_base>()
+ (
+ this->base().front()
+ );
+ }
+
+ BOOST_DEDUCED_TYPENAME base_::const_reference back() const
+ {
+ return this->template functor<
+ BOOST_DEDUCED_TYPENAME base_::value_from_base>()
+ (
+ this->base().back()
+ );
+ }
+
+ void push_front(
+ BOOST_DEDUCED_TYPENAME ::boost::call_traits<
+ BOOST_DEDUCED_TYPENAME base_::value_type >::param_type x)
+ {
+ this->base().push_front(
+ this->template functor<BOOST_DEDUCED_TYPENAME base_::value_to_base>()(x));
+ }
+
+ void pop_front()
+ {
+ this->base().pop_front();
+ }
+
+ void push_back(
+ BOOST_DEDUCED_TYPENAME ::boost::call_traits<
+ BOOST_DEDUCED_TYPENAME base_::value_type >::param_type x)
+ {
+ this->base().push_back(
+ this->template functor<BOOST_DEDUCED_TYPENAME base_::value_to_base>()(x));
+ }
+
+ void pop_back()
+ {
+ this->base().pop_back();
+ }
+
+ std::pair<BOOST_DEDUCED_TYPENAME base_::iterator,bool>
+ insert(BOOST_DEDUCED_TYPENAME base_::iterator position,
+ BOOST_DEDUCED_TYPENAME ::boost::call_traits<
+ BOOST_DEDUCED_TYPENAME base_::value_type >::param_type x)
+ {
+ std::pair< BOOST_DEDUCED_TYPENAME Base::iterator, bool > r(
+ this->base().insert(
+ this->template functor<
+ BOOST_DEDUCED_TYPENAME base_::iterator_to_base>()(position),
+ this->template functor<
+ BOOST_DEDUCED_TYPENAME base_::value_to_base >()(x)
+ )
+ );
+
+ return std::pair<BOOST_DEDUCED_TYPENAME base_::iterator, bool>(
+ this->template functor<
+ BOOST_DEDUCED_TYPENAME base_::iterator_from_base>()(r.first),
+ r.second
+ );
+ }
+
+ void insert(BOOST_DEDUCED_TYPENAME base_::iterator position,
+ BOOST_DEDUCED_TYPENAME base_::size_type m,
+ BOOST_DEDUCED_TYPENAME ::boost::call_traits<
+ BOOST_DEDUCED_TYPENAME base_::value_type >::param_type x)
+ {
+ this->base().insert(
+ this->template functor<
+ BOOST_DEDUCED_TYPENAME base_::iterator_to_base>()(position),
+ m,
+ this->template functor<BOOST_DEDUCED_TYPENAME base_::value_to_base >()(x)
+ );
+ }
+
+ template< class InputIterator >
+ void insert(BOOST_DEDUCED_TYPENAME base_::iterator position,
+ InputIterator first, InputIterator last)
+ {
+ // This is the same problem found in the insert function
+ // of container_adaptor
+ // For now, do the simple thing. This can be optimized
+
+ for( ; first != last ; ++first )
+ {
+ this->base().insert(
+ this->template functor<
+ BOOST_DEDUCED_TYPENAME base_::iterator_to_base>()( position ),
+ this->template functor<
+ BOOST_DEDUCED_TYPENAME base_::value_to_base >()( *first )
+ );
+ }
+ }
+
+ // Totally ordered implementation
+
+ bool operator==(const sequence_container_adaptor & c) const
+ {
+ return ( this->base() == c.base() );
+ }
+
+ bool operator<(const sequence_container_adaptor & c) const
+ {
+ return ( this->base() < c.base() );
+ }
+};
+
+} // namespace container_adaptor
+} // namespace bimaps
+} // namespace boost
+
+
+#endif // BOOST_BIMAP_CONTAINER_ADAPTOR_SEQUENCE_CONTAINER_ADAPTOR_HPP
diff --git a/boost/bimap/container_adaptor/set_adaptor.hpp b/boost/bimap/container_adaptor/set_adaptor.hpp
new file mode 100644
index 0000000..6c8dbf3
--- /dev/null
+++ b/boost/bimap/container_adaptor/set_adaptor.hpp
@@ -0,0 +1,100 @@
+// 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 container_adaptor/set_adaptor.hpp
+/// \brief Container adaptor to easily build a std::set signature compatible container.
+
+#ifndef BOOST_BIMAP_CONTAINER_ADAPTOR_SET_ADAPTOR_HPP
+#define BOOST_BIMAP_CONTAINER_ADAPTOR_SET_ADAPTOR_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER>=1200)
+#pragma once
+#endif
+
+#include <boost/config.hpp>
+
+#include <boost/bimap/container_adaptor/ordered_associative_container_adaptor.hpp>
+#include <boost/mpl/vector.hpp>
+#include <boost/mpl/aux_/na.hpp>
+
+namespace boost {
+namespace bimaps {
+namespace container_adaptor {
+
+/// \brief Container adaptor to easily build a std::set signature compatible container.
+
+template
+<
+ class Base,
+
+ class Iterator,
+ class ConstIterator,
+ class ReverseIterator,
+ class ConstReverseIterator,
+
+ class IteratorToBaseConverter = ::boost::mpl::na,
+ class IteratorFromBaseConverter = ::boost::mpl::na,
+ class ReverseIteratorFromBaseConverter = ::boost::mpl::na,
+ class ValueToBaseConverter = ::boost::mpl::na,
+ class ValueFromBaseConverter = ::boost::mpl::na,
+ class KeyToBaseConverter = ::boost::mpl::na,
+
+ class FunctorsFromDerivedClasses = mpl::vector<>
+>
+class set_adaptor :
+
+ public ::boost::bimaps::container_adaptor::
+ ordered_associative_container_adaptor
+ <
+ Base,
+ Iterator, ConstIterator, ReverseIterator, ConstReverseIterator,
+ BOOST_DEDUCED_TYPENAME Iterator::value_type,
+ IteratorToBaseConverter, IteratorFromBaseConverter,
+ ReverseIteratorFromBaseConverter,
+ ValueToBaseConverter, ValueFromBaseConverter,
+ KeyToBaseConverter,
+ FunctorsFromDerivedClasses
+ >
+{
+
+ typedef ::boost::bimaps::container_adaptor::
+ ordered_associative_container_adaptor
+ <
+ Base,
+ Iterator, ConstIterator, ReverseIterator, ConstReverseIterator,
+ BOOST_DEDUCED_TYPENAME Iterator::value_type,
+ IteratorToBaseConverter, IteratorFromBaseConverter,
+ ReverseIteratorFromBaseConverter,
+ ValueToBaseConverter, ValueFromBaseConverter,
+ KeyToBaseConverter,
+ FunctorsFromDerivedClasses
+
+ > base_;
+
+ // Access -----------------------------------------------------------------
+
+ public:
+
+ explicit set_adaptor(Base & c) :
+ base_(c) {}
+
+ protected:
+
+ typedef set_adaptor set_adaptor_;
+
+};
+
+
+} // namespace container_adaptor
+} // namespace bimaps
+} // namespace boost
+
+
+#endif // BOOST_BIMAP_CONTAINER_ADAPTOR_SET_ADAPTOR_HPP
+
+
diff --git a/boost/bimap/container_adaptor/support/iterator_facade_converters.hpp b/boost/bimap/container_adaptor/support/iterator_facade_converters.hpp
new file mode 100644
index 0000000..4bde159
--- /dev/null
+++ b/boost/bimap/container_adaptor/support/iterator_facade_converters.hpp
@@ -0,0 +1,77 @@
+// 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 container_adaptor/support/iterator_facade_converters.hpp
+/// \brief Converter for Boost.Iterators based iterators.
+
+#ifndef BOOST_BIMAP_CONTAINER_ADAPTOR_DETAIL_ITERATOR_FACADE_CONVERTERS_HPP
+#define BOOST_BIMAP_CONTAINER_ADAPTOR_DETAIL_ITERATOR_FACADE_CONVERTERS_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER>=1200)
+#pragma once
+#endif
+
+#include <boost/config.hpp>
+
+namespace boost {
+namespace bimaps {
+namespace container_adaptor {
+
+/// \brief Utilities to help in the construction of a container adaptor
+
+namespace support {
+
+/// \brief Converter for Boost.Iterators based iterators.
+/**
+Container adaptor is dessigned to play well with Boost.Iterators. This
+converter can be used if this library is used to adapt the iterators.
+ **/
+template
+<
+ class Iterator,
+ class ConstIterator
+>
+struct iterator_facade_to_base
+{
+ BOOST_DEDUCED_TYPENAME Iterator::base_type operator()(Iterator iter) const
+ {
+ return iter.base();
+ }
+
+ BOOST_DEDUCED_TYPENAME ConstIterator::base_type operator()(ConstIterator iter) const
+ {
+ return iter.base();
+ }
+};
+
+#ifndef BOOST_BIMAP_DOXYGEN_WILL_NOT_PROCESS_THE_FOLLOWING_LINES
+
+template
+<
+ class Iterator
+>
+struct iterator_facade_to_base<Iterator,Iterator>
+{
+ BOOST_DEDUCED_TYPENAME Iterator::base_type operator()(Iterator iter) const
+ {
+ return iter.base();
+ }
+};
+
+#endif // BOOST_BIMAP_DOXYGEN_WILL_NOT_PROCESS_THE_FOLLOWING_LINES
+
+#undef BOOST_BIMAP_CONTAINER_ADAPTOR_IMPLEMENT_CONVERT_FACADE_FUNCTION
+
+
+} // namespace support
+} // namespace container_adaptor
+} // namespace bimaps
+} // namespace boost
+
+
+#endif // BOOST_BIMAP_CONTAINER_ADAPTOR_DETAIL_ITERATOR_FACADE_CONVERTERS_HPP
diff --git a/boost/bimap/container_adaptor/unordered_associative_container_adaptor.hpp b/boost/bimap/container_adaptor/unordered_associative_container_adaptor.hpp
new file mode 100644
index 0000000..937a0d8
--- /dev/null
+++ b/boost/bimap/container_adaptor/unordered_associative_container_adaptor.hpp
@@ -0,0 +1,293 @@
+// 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 container_adaptor/unordered_associative_container_adaptor.hpp
+/// \brief Container adaptor to build a type that is compliant to the concept of an unordered associative container.
+
+#ifndef BOOST_BIMAP_CONTAINER_ADAPTOR_UNORDERED_ASSOCIATIVE_CONTAINER_ADAPTOR_HPP
+#define BOOST_BIMAP_CONTAINER_ADAPTOR_UNORDERED_ASSOCIATIVE_CONTAINER_ADAPTOR_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER>=1200)
+#pragma once
+#endif
+
+#include <boost/config.hpp>
+
+#include <boost/bimap/container_adaptor/associative_container_adaptor.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/mpl/vector.hpp>
+#include <boost/mpl/push_front.hpp>
+#include <boost/mpl/aux_/na.hpp>
+#include <boost/call_traits.hpp>
+
+namespace boost {
+namespace bimaps {
+namespace container_adaptor {
+
+
+#ifndef BOOST_BIMAP_DOXYGEN_WILL_NOT_PROCESS_THE_FOLLOWING_LINES
+
+template
+<
+ class Base, class Iterator, class ConstIterator,
+ class LocalIterator, class ConstLocalIterator,
+ class KeyType,
+ class IteratorToBaseConverter, class IteratorFromBaseConverter,
+ class LocalIteratorFromBaseConverter,
+ class ValueToBaseConverter, class ValueFromBaseConverter,
+ class KeyToBaseConverter,
+ class FunctorsFromDerivedClasses
+>
+struct unordered_associative_container_adaptor_base
+{
+
+ typedef associative_container_adaptor
+ <
+ Base, Iterator, ConstIterator, KeyType,
+ IteratorToBaseConverter, IteratorFromBaseConverter,
+ ValueToBaseConverter , ValueFromBaseConverter,
+ KeyToBaseConverter,
+
+ BOOST_DEDUCED_TYPENAME mpl::push_front<
+
+ FunctorsFromDerivedClasses,
+
+ BOOST_DEDUCED_TYPENAME mpl::if_<
+ ::boost::mpl::is_na<LocalIteratorFromBaseConverter>,
+ // {
+ detail::iterator_from_base_identity
+ <
+ BOOST_DEDUCED_TYPENAME Base::local_iterator,
+ LocalIterator,
+ BOOST_DEDUCED_TYPENAME Base::const_local_iterator,
+ ConstLocalIterator
+ >,
+ // }
+ // else
+ // {
+ LocalIteratorFromBaseConverter
+ // }
+
+ >::type
+
+ >::type
+
+ > type;
+};
+
+#endif // BOOST_BIMAP_DOXYGEN_WILL_NOT_PROCESS_THE_FOLLOWING_LINES
+
+
+/// \brief Container adaptor to build a type that is compliant to the concept of an unordered associative container.
+
+template
+<
+ class Base,
+
+ class Iterator,
+ class ConstIterator,
+
+ class LocalIterator,
+ class ConstLocalIterator,
+
+ class KeyType,
+
+ class IteratorToBaseConverter = ::boost::mpl::na,
+ class IteratorFromBaseConverter = ::boost::mpl::na,
+ class LocalIteratorFromBaseConverter = ::boost::mpl::na,
+ class ValueToBaseConverter = ::boost::mpl::na,
+ class ValueFromBaseConverter = ::boost::mpl::na,
+ class KeyToBaseConverter = ::boost::mpl::na,
+
+ class FunctorsFromDerivedClasses = mpl::vector<>
+
+>
+class unordered_associative_container_adaptor :
+
+ public unordered_associative_container_adaptor_base
+ <
+ Base, Iterator, ConstIterator,
+ LocalIterator, ConstLocalIterator,
+ KeyType,
+ IteratorToBaseConverter, IteratorFromBaseConverter,
+ LocalIteratorFromBaseConverter,
+ ValueToBaseConverter, ValueFromBaseConverter,
+ KeyToBaseConverter,
+ FunctorsFromDerivedClasses
+
+ >::type
+{
+ typedef BOOST_DEDUCED_TYPENAME unordered_associative_container_adaptor_base
+ <
+ Base, Iterator, ConstIterator,
+ LocalIterator, ConstLocalIterator,
+ KeyType,
+ IteratorToBaseConverter, IteratorFromBaseConverter,
+ LocalIteratorFromBaseConverter,
+ ValueToBaseConverter, ValueFromBaseConverter,
+ KeyToBaseConverter,
+ FunctorsFromDerivedClasses
+
+ >::type base_;
+
+ // Metadata ---------------------------------------------------------------
+
+ public:
+
+ typedef BOOST_DEDUCED_TYPENAME Base::key_equal key_equal;
+ typedef BOOST_DEDUCED_TYPENAME Base::hasher hasher;
+
+ typedef LocalIterator local_iterator;
+ typedef ConstLocalIterator const_local_iterator;
+
+ protected:
+
+ typedef BOOST_DEDUCED_TYPENAME mpl::if_<
+ ::boost::mpl::is_na<LocalIteratorFromBaseConverter>,
+ // {
+ detail::iterator_from_base_identity
+ <
+ BOOST_DEDUCED_TYPENAME Base::local_iterator,
+ local_iterator,
+ BOOST_DEDUCED_TYPENAME Base::const_local_iterator,
+ const_local_iterator
+ >,
+ // }
+ // else
+ // {
+ LocalIteratorFromBaseConverter
+ // }
+
+ >::type local_iterator_from_base;
+
+ // Access -----------------------------------------------------------------
+
+ public:
+
+ explicit unordered_associative_container_adaptor(Base & c)
+ : base_(c) {}
+
+ protected:
+
+
+ typedef unordered_associative_container_adaptor
+ unordered_associative_container_adaptor_;
+
+ // Interface --------------------------------------------------------------
+
+ public:
+
+ // bucket interface:
+
+ BOOST_DEDUCED_TYPENAME base_::size_type bucket_count() const
+ {
+ return this->base().bucket_count();
+ }
+
+ BOOST_DEDUCED_TYPENAME base_::size_type max_bucket_count() const
+ {
+ return this->base().max_bucket_count();
+ }
+
+ BOOST_DEDUCED_TYPENAME base_::size_type bucket_size(
+ BOOST_DEDUCED_TYPENAME base_::size_type n) const
+ {
+ return this->base().bucket_size(n);
+ }
+
+ template< class CompatibleKey >
+ BOOST_DEDUCED_TYPENAME base_::size_type bucket(
+ const CompatibleKey & k) const
+ {
+ typedef BOOST_DEDUCED_TYPENAME base_::key_to_base key_to_base;
+ return this->base().bucket(
+ this->template functor<key_to_base>()(k)
+ );
+ }
+
+ local_iterator begin(BOOST_DEDUCED_TYPENAME base_::size_type n)
+ {
+ return this->template functor<
+ local_iterator_from_base
+ >() ( this->base().begin(n) );
+ }
+
+ const_local_iterator begin(BOOST_DEDUCED_TYPENAME base_::size_type n) const
+ {
+ return this->template functor<
+ local_iterator_from_base
+ >() ( this->base().begin(n) );
+ }
+
+ local_iterator end(BOOST_DEDUCED_TYPENAME base_::size_type n)
+ {
+ return this->template functor<
+ local_iterator_from_base
+ >() ( this->base().end(n) );
+ }
+
+ const_local_iterator end(BOOST_DEDUCED_TYPENAME base_::size_type n) const
+ {
+ return this->template functor<
+ local_iterator_from_base
+ >() ( this->base().end(n) );
+ }
+
+ // hash policy
+
+ float load_factor() const
+ {
+ return this->base().load_factor();
+ }
+
+ float max_load_factor() const
+ {
+ return this->base().max_load_factor();
+ }
+
+ void max_load_factor(float z)
+ {
+ return this->base().max_load_factor(z);
+ }
+
+ void rehash(BOOST_DEDUCED_TYPENAME base_::size_type n)
+ {
+ return this->base().rehash(n);
+ }
+
+ // We have redefined end and begin so we have to manually route the old ones
+
+ BOOST_DEDUCED_TYPENAME base_::iterator begin()
+ {
+ return base_::container_adaptor_::begin();
+ }
+
+ BOOST_DEDUCED_TYPENAME base_::iterator end()
+ {
+ return base_::container_adaptor_::end();
+ }
+
+ BOOST_DEDUCED_TYPENAME base_::const_iterator begin() const
+ {
+ return base_::container_adaptor_::begin();
+ }
+
+ BOOST_DEDUCED_TYPENAME base_::const_iterator end() const
+ {
+ return base_::container_adaptor_::end();
+ }
+
+};
+
+
+} // namespace container_adaptor
+} // namespace bimaps
+} // namespace boost
+
+
+#endif // BOOST_BIMAP_CONTAINER_ADAPTOR_UNORDERED_ASSOCIATIVE_CONTAINER_ADAPTOR_HPP
diff --git a/boost/bimap/container_adaptor/unordered_map_adaptor.hpp b/boost/bimap/container_adaptor/unordered_map_adaptor.hpp
new file mode 100644
index 0000000..762a643
--- /dev/null
+++ b/boost/bimap/container_adaptor/unordered_map_adaptor.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 container_adaptor/unordered_map_adaptor.hpp
+/// \brief Container adaptor to easily build a std::unordered_map signature compatible container.
+
+#ifndef BOOST_BIMAP_CONTAINER_ADAPTOR_UNORDERED_MAP_ADAPTOR_HPP
+#define BOOST_BIMAP_CONTAINER_ADAPTOR_UNORDERED_MAP_ADAPTOR_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER>=1200)
+#pragma once
+#endif
+
+#include <boost/config.hpp>
+
+#include <boost/bimap/container_adaptor/unordered_associative_container_adaptor.hpp>
+#include <boost/mpl/aux_/na.hpp>
+#include <boost/mpl/vector.hpp>
+#include <boost/call_traits.hpp>
+
+namespace boost {
+namespace bimaps {
+namespace container_adaptor {
+
+/// \brief Container adaptor to easily build a std::unordered_map signature compatible container.
+
+template
+<
+ class Base,
+
+ class Iterator,
+ class ConstIterator,
+ class LocalIterator,
+ class ConstLocalIterator,
+
+ class IteratorToBaseConverter = ::boost::mpl::na,
+ class IteratorFromBaseConverter = ::boost::mpl::na,
+ class LocalIteratorFromBaseConverter = ::boost::mpl::na,
+ class ValueToBaseConverter = ::boost::mpl::na,
+ class ValueFromBaseConverter = ::boost::mpl::na,
+ class KeyToBaseConverter = ::boost::mpl::na,
+
+ class FunctorsFromDerivedClasses = mpl::vector<>
+>
+class unordered_map_adaptor :
+
+ public ::boost::bimaps::container_adaptor::
+ unordered_associative_container_adaptor
+ <
+ Base,
+ Iterator, ConstIterator, LocalIterator, ConstLocalIterator,
+ BOOST_DEDUCED_TYPENAME Iterator::value_type::first_type,
+ IteratorToBaseConverter, IteratorFromBaseConverter,
+ LocalIteratorFromBaseConverter,
+ ValueToBaseConverter, ValueFromBaseConverter,
+ KeyToBaseConverter,
+ FunctorsFromDerivedClasses
+ >
+{
+
+ typedef ::boost::bimaps::container_adaptor::
+ unordered_associative_container_adaptor
+ <
+ Base,
+ Iterator, ConstIterator, LocalIterator, ConstLocalIterator,
+ BOOST_DEDUCED_TYPENAME Iterator::value_type::first_type,
+ IteratorToBaseConverter, IteratorFromBaseConverter,
+ LocalIteratorFromBaseConverter,
+ ValueToBaseConverter, ValueFromBaseConverter,
+ KeyToBaseConverter,
+ FunctorsFromDerivedClasses
+
+ > base_;
+
+ // MetaData -------------------------------------------------------------
+
+ public:
+
+ typedef BOOST_DEDUCED_TYPENAME Iterator::value_type::second_type data_type;
+
+ // Access -----------------------------------------------------------------
+
+ public:
+
+ explicit unordered_map_adaptor(Base & c) :
+ base_(c) {}
+
+ protected:
+
+ typedef unordered_map_adaptor unordered_map_adaptor_;
+
+ // Interface --------------------------------------------------------------
+
+ public:
+
+ template< class CompatibleKey >
+ data_type& operator[](const CompatibleKey & k)
+ {
+ return this->base()
+ [this->template functor<BOOST_DEDUCED_TYPENAME base_::key_to_base>()(k)];
+ }
+
+ template< class CompatibleKey >
+ data_type& at(const CompatibleKey & k)
+ {
+ return this->base().
+ at(this->template functor<BOOST_DEDUCED_TYPENAME base_::key_to_base>()(k));
+ }
+
+ template< class CompatibleKey >
+ const data_type& at(const CompatibleKey & k) const
+ {
+ return this->base().
+ at(this->template functor<BOOST_DEDUCED_TYPENAME base_::key_to_base>()(k));
+ }
+
+};
+
+
+
+} // namespace container_adaptor
+} // namespace bimaps
+} // namespace boost
+
+
+#endif // BOOST_BIMAP_CONTAINER_ADAPTOR_UNORDERED_MAP_ADAPTOR_HPP
+
diff --git a/boost/bimap/container_adaptor/unordered_multimap_adaptor.hpp b/boost/bimap/container_adaptor/unordered_multimap_adaptor.hpp
new file mode 100644
index 0000000..be28b3a
--- /dev/null
+++ b/boost/bimap/container_adaptor/unordered_multimap_adaptor.hpp
@@ -0,0 +1,110 @@
+// 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 container_adaptor/unordered_multimap_adaptor.hpp
+/// \brief Container adaptor to easily build a std::unordered_multimap signature compatible container.
+
+#ifndef BOOST_BIMAP_CONTAINER_ADAPTOR_UNORDERED_MULTIMAP_ADAPTOR_HPP
+#define BOOST_BIMAP_CONTAINER_ADAPTOR_UNORDERED_MULTIMAP_ADAPTOR_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER>=1200)
+#pragma once
+#endif
+
+#include <boost/config.hpp>
+
+#include <boost/bimap/container_adaptor/unordered_associative_container_adaptor.hpp>
+#include <boost/bimap/container_adaptor/detail/non_unique_container_helper.hpp>
+#include <boost/mpl/aux_/na.hpp>
+#include <boost/mpl/vector.hpp>
+
+namespace boost {
+namespace bimaps {
+namespace container_adaptor {
+
+/// \brief Container adaptor to easily build a std::unordered_multimap signature compatible container.
+
+template
+<
+ class Base,
+
+ class Iterator,
+ class ConstIterator,
+ class LocalIterator,
+ class ConstLocalIterator,
+
+ class IteratorToBaseConverter = ::boost::mpl::na,
+ class IteratorFromBaseConverter = ::boost::mpl::na,
+ class LocalIteratorFromBaseConverter = ::boost::mpl::na,
+ class ValueToBaseConverter = ::boost::mpl::na,
+ class ValueFromBaseConverter = ::boost::mpl::na,
+ class KeyToBaseConverter = ::boost::mpl::na,
+
+ class FunctorsFromDerivedClasses = mpl::vector<>
+>
+class unordered_multimap_adaptor :
+
+ public ::boost::bimaps::container_adaptor::
+ unordered_associative_container_adaptor
+ <
+ Base,
+ Iterator, ConstIterator, LocalIterator, ConstLocalIterator,
+ BOOST_DEDUCED_TYPENAME Iterator::value_type::first_type,
+ IteratorToBaseConverter, IteratorFromBaseConverter,
+ LocalIteratorFromBaseConverter,
+ ValueToBaseConverter, ValueFromBaseConverter,
+ KeyToBaseConverter,
+ FunctorsFromDerivedClasses
+ >
+{
+ typedef ::boost::bimaps::container_adaptor::
+ unordered_associative_container_adaptor
+ <
+ Base,
+ Iterator, ConstIterator, LocalIterator, ConstLocalIterator,
+ BOOST_DEDUCED_TYPENAME Iterator::value_type::first_type,
+ IteratorToBaseConverter, IteratorFromBaseConverter,
+ LocalIteratorFromBaseConverter,
+ ValueToBaseConverter, ValueFromBaseConverter,
+ KeyToBaseConverter,
+ FunctorsFromDerivedClasses
+
+ > base_;
+
+ // MetaData -------------------------------------------------------------
+
+ public:
+
+ typedef BOOST_DEDUCED_TYPENAME Iterator::value_type::second_type data_type;
+
+ // Access -----------------------------------------------------------------
+
+ public:
+
+ explicit unordered_multimap_adaptor(Base & c) :
+ base_(c) {}
+
+ protected:
+
+ typedef unordered_multimap_adaptor unordered_multimap_adaptor_;
+
+ public:
+
+ BOOST_BIMAP_NON_UNIQUE_CONTAINER_ADAPTOR_INSERT_FUNCTIONS
+};
+
+
+
+} // namespace container_adaptor
+} // namespace bimaps
+} // namespace boost
+
+
+#endif // BOOST_BIMAP_CONTAINER_ADAPTOR_UNORDERED_MULTIMAP_ADAPTOR_HPP
+
+
diff --git a/boost/bimap/container_adaptor/unordered_multiset_adaptor.hpp b/boost/bimap/container_adaptor/unordered_multiset_adaptor.hpp
new file mode 100644
index 0000000..1d8e4c9
--- /dev/null
+++ b/boost/bimap/container_adaptor/unordered_multiset_adaptor.hpp
@@ -0,0 +1,102 @@
+// 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 container_adaptor/unordered_multiset_adaptor.hpp
+/// \brief Container adaptor to easily build a std::unordered_multiset signature compatible container.
+
+#ifndef BOOST_BIMAP_CONTAINER_ADAPTOR_UNORDERED_MULTISET_ADAPTOR_HPP
+#define BOOST_BIMAP_CONTAINER_ADAPTOR_UNORDERED_MULTISET_ADAPTOR_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER>=1200)
+#pragma once
+#endif
+
+#include <boost/config.hpp>
+
+#include <boost/bimap/container_adaptor/unordered_associative_container_adaptor.hpp>
+#include <boost/bimap/container_adaptor/detail/non_unique_container_helper.hpp>
+#include <boost/mpl/aux_/na.hpp>
+#include <boost/mpl/vector.hpp>
+
+namespace boost {
+namespace bimaps {
+namespace container_adaptor {
+
+/// \brief Container adaptor to easily build a std::unordered_multiset signature compatible container.
+
+template
+<
+ class Base,
+
+ class Iterator,
+ class ConstIterator,
+ class LocalIterator,
+ class ConstLocalIterator,
+
+ class IteratorToBaseConverter = ::boost::mpl::na,
+ class IteratorFromBaseConverter = ::boost::mpl::na,
+ class LocalIteratorFromBaseConverter = ::boost::mpl::na,
+ class ValueToBaseConverter = ::boost::mpl::na,
+ class ValueFromBaseConverter = ::boost::mpl::na,
+ class KeyToBaseConverter = ::boost::mpl::na,
+
+ class FunctorsFromDerivedClasses = mpl::vector<>
+>
+class unordered_multiset_adaptor :
+
+ public ::boost::bimaps::container_adaptor::
+ unordered_associative_container_adaptor
+ <
+ Base,
+ Iterator, ConstIterator, LocalIterator, ConstLocalIterator,
+ BOOST_DEDUCED_TYPENAME Iterator::value_type,
+ IteratorToBaseConverter, IteratorFromBaseConverter,
+ LocalIteratorFromBaseConverter,
+ ValueToBaseConverter, ValueFromBaseConverter,
+ KeyToBaseConverter,
+ FunctorsFromDerivedClasses
+ >
+{
+ typedef ::boost::bimaps::container_adaptor::
+ unordered_associative_container_adaptor
+ <
+ Base,
+ Iterator, ConstIterator, LocalIterator, ConstLocalIterator,
+ BOOST_DEDUCED_TYPENAME Iterator::value_type,
+ IteratorToBaseConverter, IteratorFromBaseConverter,
+ LocalIteratorFromBaseConverter,
+ ValueToBaseConverter, ValueFromBaseConverter,
+ KeyToBaseConverter,
+ FunctorsFromDerivedClasses
+
+ > base_;
+
+ // Access -----------------------------------------------------------------
+
+ public:
+
+ explicit unordered_multiset_adaptor(Base & c) :
+ base_(c) {}
+
+ protected:
+
+ typedef unordered_multiset_adaptor unordered_multiset_adaptor_;
+
+ public:
+
+ BOOST_BIMAP_NON_UNIQUE_CONTAINER_ADAPTOR_INSERT_FUNCTIONS
+};
+
+
+} // namespace container_adaptor
+} // namespace bimaps
+} // namespace boost
+
+
+#endif // BOOST_BIMAP_CONTAINER_ADAPTOR_UNORDERED_MULTISET_ADAPTOR_HPP
+
diff --git a/boost/bimap/container_adaptor/unordered_set_adaptor.hpp b/boost/bimap/container_adaptor/unordered_set_adaptor.hpp
new file mode 100644
index 0000000..cf00b0f
--- /dev/null
+++ b/boost/bimap/container_adaptor/unordered_set_adaptor.hpp
@@ -0,0 +1,98 @@
+// 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 container_adaptor/unordered_set_adaptor.hpp
+/// \brief Container adaptor to easily build a std::unordered_set signature compatible container.
+
+#ifndef BOOST_BIMAP_CONTAINER_ADAPTOR_UNORDERED_SET_ADAPTOR_HPP
+#define BOOST_BIMAP_CONTAINER_ADAPTOR_UNORDERED_SET_ADAPTOR_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER>=1200)
+#pragma once
+#endif
+
+#include <boost/config.hpp>
+
+#include <boost/bimap/container_adaptor/unordered_associative_container_adaptor.hpp>
+#include <boost/mpl/aux_/na.hpp>
+#include <boost/mpl/vector.hpp>
+
+namespace boost {
+namespace bimaps {
+namespace container_adaptor {
+
+/// \brief Container adaptor to easily build a std::unordered_set signature compatible container.
+
+template
+<
+ class Base,
+
+ class Iterator,
+ class ConstIterator,
+ class LocalIterator,
+ class ConstLocalIterator,
+
+ class IteratorToBaseConverter = ::boost::mpl::na,
+ class IteratorFromBaseConverter = ::boost::mpl::na,
+ class LocalIteratorFromBaseConverter = ::boost::mpl::na,
+ class ValueToBaseConverter = ::boost::mpl::na,
+ class ValueFromBaseConverter = ::boost::mpl::na,
+ class KeyToBaseConverter = ::boost::mpl::na,
+
+ class FunctorsFromDerivedClasses = mpl::vector<>
+>
+class unordered_set_adaptor :
+
+ public ::boost::bimaps::container_adaptor::
+ unordered_associative_container_adaptor
+ <
+ Base,
+ Iterator, ConstIterator, LocalIterator, ConstLocalIterator,
+ BOOST_DEDUCED_TYPENAME Iterator::value_type,
+ IteratorToBaseConverter, IteratorFromBaseConverter,
+ LocalIteratorFromBaseConverter,
+ ValueToBaseConverter, ValueFromBaseConverter,
+ KeyToBaseConverter,
+ FunctorsFromDerivedClasses
+ >
+{
+ typedef ::boost::bimaps::container_adaptor::
+ unordered_associative_container_adaptor
+ <
+ Base,
+ Iterator, ConstIterator, LocalIterator, ConstLocalIterator,
+ BOOST_DEDUCED_TYPENAME Iterator::value_type,
+ IteratorToBaseConverter, IteratorFromBaseConverter,
+ LocalIteratorFromBaseConverter,
+ ValueToBaseConverter, ValueFromBaseConverter,
+ KeyToBaseConverter,
+ FunctorsFromDerivedClasses
+
+ > base_;
+
+ // Access -----------------------------------------------------------------
+
+ public:
+
+ explicit unordered_set_adaptor(Base & c) :
+ base_(c) {}
+
+ protected:
+
+ typedef unordered_set_adaptor unordered_set_adaptor_;
+
+};
+
+
+} // namespace container_adaptor
+} // namespace bimaps
+} // namespace boost
+
+
+#endif // BOOST_BIMAP_CONTAINER_ADAPTOR_UNORDERED_SET_ADAPTOR_HPP
+
diff --git a/boost/bimap/container_adaptor/vector_adaptor.hpp b/boost/bimap/container_adaptor/vector_adaptor.hpp
new file mode 100644
index 0000000..de6e391
--- /dev/null
+++ b/boost/bimap/container_adaptor/vector_adaptor.hpp
@@ -0,0 +1,142 @@
+// 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 container_adaptor/vector_adaptor.hpp
+/// \brief Container adaptor to easily build a std::vector signature compatible container.
+
+#ifndef BOOST_BIMAP_CONTAINER_ADAPTOR_VECTOR_ADAPTOR_HPP
+#define BOOST_BIMAP_CONTAINER_ADAPTOR_VECTOR_ADAPTOR_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER>=1200)
+#pragma once
+#endif
+
+#include <boost/config.hpp>
+
+#include <boost/bimap/container_adaptor/sequence_container_adaptor.hpp>
+#include <boost/mpl/aux_/na.hpp>
+#include <boost/mpl/vector.hpp>
+
+namespace boost {
+namespace bimaps {
+namespace container_adaptor {
+
+/// \brief Container adaptor to easily build a std::vector signature compatible container.
+
+template
+<
+ class Base,
+
+ class Iterator,
+ class ConstIterator,
+ class ReverseIterator,
+ class ConstReverseIterator,
+
+ class IteratorToBaseConverter = ::boost::mpl::na,
+ class IteratorFromBaseConverter = ::boost::mpl::na,
+ class ReverseIteratorFromBaseConverter = ::boost::mpl::na,
+ class ValueToBaseConverter = ::boost::mpl::na,
+ class ValueFromBaseConverter = ::boost::mpl::na,
+
+ class FunctorsFromDerivedClasses = mpl::vector<>
+>
+class vector_adaptor :
+
+ public ::boost::bimaps::container_adaptor::sequence_container_adaptor
+ <
+ Base,
+ Iterator, ConstIterator, ReverseIterator, ConstReverseIterator,
+ IteratorToBaseConverter, IteratorFromBaseConverter,
+ ReverseIteratorFromBaseConverter,
+ ValueToBaseConverter, ValueFromBaseConverter,
+ FunctorsFromDerivedClasses
+ >
+{
+
+ typedef ::boost::bimaps::container_adaptor::sequence_container_adaptor
+ <
+ Base,
+ Iterator, ConstIterator, ReverseIterator, ConstReverseIterator,
+ IteratorToBaseConverter, IteratorFromBaseConverter,
+ ReverseIteratorFromBaseConverter,
+ ValueToBaseConverter, ValueFromBaseConverter,
+ FunctorsFromDerivedClasses
+
+ > base_;
+
+ // Access -----------------------------------------------------------------
+
+ public:
+
+ vector_adaptor() {}
+
+ explicit vector_adaptor(Base & c) :
+ base_(c) {}
+
+ protected:
+
+ typedef vector_adaptor vector_adaptor_;
+
+ // Interface --------------------------------------------------------------
+
+ public:
+
+ BOOST_DEDUCED_TYPENAME base_::size_type capacity() const
+ {
+ return this->base().capacity();
+ }
+
+ void reserve(BOOST_DEDUCED_TYPENAME base_::size_type m)
+ {
+ this->base().resize(m);
+ }
+
+ void resize(BOOST_DEDUCED_TYPENAME base_::size_type n,
+ BOOST_DEDUCED_TYPENAME ::boost::call_traits<
+ BOOST_DEDUCED_TYPENAME base_::value_type >::param_type x =
+ BOOST_DEDUCED_TYPENAME base_::value_type())
+ {
+ this->base().resize(n,
+ this->template functor<BOOST_DEDUCED_TYPENAME base_::value_to_base>()(x)
+ );
+ }
+
+ BOOST_DEDUCED_TYPENAME base_::const_reference
+ operator[](BOOST_DEDUCED_TYPENAME base_::size_type n) const
+ {
+ return this->base().operator[](n);
+ }
+
+ BOOST_DEDUCED_TYPENAME base_::const_reference
+ at(BOOST_DEDUCED_TYPENAME base_::size_type n) const
+ {
+ return this->base().at(n);
+ }
+
+ BOOST_DEDUCED_TYPENAME base_::reference
+ operator[](BOOST_DEDUCED_TYPENAME base_::size_type n)
+ {
+ return this->base().operator[](n);
+ }
+
+ BOOST_DEDUCED_TYPENAME base_::reference
+ at(BOOST_DEDUCED_TYPENAME base_::size_type n)
+ {
+ return this->base().at(n);
+ }
+};
+
+
+} // namespace container_adaptor
+} // namespace bimaps
+} // namespace boost
+
+
+#endif // BOOST_BIMAP_CONTAINER_ADAPTOR_VECTOR_ADAPTOR_HPP
+
+
diff --git a/boost/bimap/container_adaptor/vector_map_adaptor.hpp b/boost/bimap/container_adaptor/vector_map_adaptor.hpp
new file mode 100644
index 0000000..9b0b9d3
--- /dev/null
+++ b/boost/bimap/container_adaptor/vector_map_adaptor.hpp
@@ -0,0 +1,103 @@
+// 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 container_adaptor/vector_map_adaptor.hpp
+/// \brief Container adaptor.
+
+#ifndef BOOST_BIMAP_CONTAINER_ADAPTOR_VECTOR_MAP_ADAPTOR_HPP
+#define BOOST_BIMAP_CONTAINER_ADAPTOR_VECTOR_MAP_ADAPTOR_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER>=1200)
+#pragma once
+#endif
+
+#include <boost/config.hpp>
+
+#include <boost/mpl/list.hpp>
+#include <boost/mpl/push_front.hpp>
+#include <boost/mpl/aux_/na.hpp>
+#include <boost/bimap/container_adaptor/vector_adaptor.hpp>
+#include <boost/bimap/container_adaptor/detail/identity_converters.hpp>
+#include <boost/mpl/vector.hpp>
+
+namespace boost {
+namespace bimaps {
+namespace container_adaptor {
+
+/// \brief Container adaptor.
+
+template
+<
+ class Base,
+
+ class Iterator,
+ class ConstIterator,
+ class ReverseIterator,
+ class ConstReverseIterator,
+
+ class IteratorToBaseConverter = ::boost::mpl::na,
+ class IteratorFromBaseConverter = ::boost::mpl::na,
+ class ReverseIteratorFromBaseConverter = ::boost::mpl::na,
+ class ValueToBaseConverter = ::boost::mpl::na,
+ class ValueFromBaseConverter = ::boost::mpl::na,
+
+ class FunctorsFromDerivedClasses = mpl::vector<>
+>
+class vector_map_adaptor :
+
+ public vector_adaptor
+ <
+ Base,
+ Iterator, ConstIterator, ReverseIterator, ConstReverseIterator,
+ IteratorToBaseConverter, IteratorFromBaseConverter,
+ ReverseIteratorFromBaseConverter,
+ ValueToBaseConverter, ValueFromBaseConverter,
+ FunctorsFromDerivedClasses
+ >
+{
+ typedef vector_adaptor
+ <
+ Base,
+ Iterator, ConstIterator, ReverseIterator, ConstReverseIterator,
+ IteratorToBaseConverter, IteratorFromBaseConverter,
+ ReverseIteratorFromBaseConverter,
+ ValueToBaseConverter, ValueFromBaseConverter,
+ FunctorsFromDerivedClasses
+
+ > base_;
+
+ // MetaData -------------------------------------------------------------
+
+ public:
+
+ typedef BOOST_DEDUCED_TYPENAME Iterator::value_type::first_type key_type;
+ typedef BOOST_DEDUCED_TYPENAME Iterator::value_type::second_type data_type;
+
+ // Access -----------------------------------------------------------------
+
+ public:
+
+ vector_map_adaptor() {}
+
+ explicit vector_map_adaptor(Base & c) :
+ base_(c) {}
+
+ protected:
+
+ typedef vector_map_adaptor vector_map_adaptor_;
+
+};
+
+
+} // namespace container_adaptor
+} // namespace bimaps
+} // namespace boost
+
+
+#endif // BOOST_BIMAP_CONTAINER_ADAPTOR_VECTOR_MAP_ADAPTOR_HPP
+
diff --git a/boost/bimap/detail/bimap_core.hpp b/boost/bimap/detail/bimap_core.hpp
new file mode 100644
index 0000000..f37d968
--- /dev/null
+++ b/boost/bimap/detail/bimap_core.hpp
@@ -0,0 +1,520 @@
+// 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 detail/bimap_core.hpp
+/// \brief Bimap base definition.
+
+#ifndef BOOST_BIMAP_DETAIL_BIMAP_CORE_HPP
+#define BOOST_BIMAP_DETAIL_BIMAP_CORE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER>=1200)
+#pragma once
+#endif
+
+#include <boost/config.hpp>
+
+#include <boost/mpl/placeholders.hpp>
+#include <boost/mpl/push_front.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/mpl/and.hpp>
+#include <boost/mpl/not.hpp>
+#include <boost/mpl/vector.hpp>
+
+#include <boost/type_traits/add_const.hpp>
+#include <boost/type_traits/is_same.hpp>
+
+#include <boost/concept_check.hpp>
+
+// Boost.MultiIndex
+#include <boost/multi_index_container.hpp>
+#include <boost/multi_index/member.hpp>
+
+// Boost.Bimap
+#include <boost/bimap/relation/mutant_relation.hpp>
+#include <boost/bimap/relation/member_at.hpp>
+#include <boost/bimap/relation/support/data_extractor.hpp>
+#include <boost/bimap/tags/support/default_tagged.hpp>
+#include <boost/bimap/tags/tagged.hpp>
+#include <boost/bimap/detail/manage_bimap_key.hpp>
+#include <boost/bimap/detail/manage_additional_parameters.hpp>
+#include <boost/bimap/detail/map_view_iterator.hpp>
+#include <boost/bimap/detail/set_view_iterator.hpp>
+
+#include <boost/bimap/set_of.hpp>
+#include <boost/bimap/unconstrained_set_of.hpp>
+
+namespace boost {
+namespace bimaps {
+
+/// \brief Library details
+
+namespace detail {
+
+#ifndef BOOST_BIMAP_DOXYGEN_WILL_NOT_PROCESS_THE_FOLLOWING_LINES
+
+template< class Type >
+struct get_value_type
+{
+ typedef BOOST_DEDUCED_TYPENAME Type::value_type type;
+};
+
+struct independent_index_tag {};
+
+#endif // BOOST_BIMAP_DOXYGEN_WILL_NOT_PROCESS_THE_FOLLOWING_LINES
+
+
+/// \brief Base for the bimap class.
+/**
+
+
+See also bimap.
+ **/
+
+
+template< class LeftSetType, class RightSetType, class AP1, class AP2, class AP3 >
+class bimap_core
+{
+ // Manage bimap key instantiation
+ // --------------------------------------------------------------------
+ public:
+
+ typedef BOOST_DEDUCED_TYPENAME manage_bimap_key
+ <
+ LeftSetType
+
+ >::type left_set_type;
+
+ typedef BOOST_DEDUCED_TYPENAME manage_bimap_key
+ <
+ RightSetType
+
+ >::type right_set_type;
+
+
+ private:
+
+ typedef BOOST_DEDUCED_TYPENAME ::boost::bimaps::tags::support::default_tagged
+ <
+ BOOST_DEDUCED_TYPENAME left_set_type::user_type,
+ ::boost::bimaps::relation::member_at::left
+
+ >::type left_tagged_type;
+
+ typedef BOOST_DEDUCED_TYPENAME ::boost::bimaps::tags::support::default_tagged
+ <
+ BOOST_DEDUCED_TYPENAME right_set_type::user_type,
+ ::boost::bimaps::relation::member_at::right
+
+ >::type right_tagged_type;
+
+ public:
+
+ //@{
+
+ typedef BOOST_DEDUCED_TYPENAME left_tagged_type::tag left_tag;
+ typedef BOOST_DEDUCED_TYPENAME right_tagged_type::tag right_tag;
+
+ //@}
+
+ //@{
+
+ typedef BOOST_DEDUCED_TYPENAME left_set_type::value_type left_key_type;
+ typedef BOOST_DEDUCED_TYPENAME right_set_type::value_type right_key_type;
+
+ //@}
+
+ //@{
+
+ typedef right_key_type left_data_type;
+ typedef left_key_type right_data_type;
+
+ //@}
+
+ // Manage the additional parameters
+ // --------------------------------------------------------------------
+ private:
+
+ typedef BOOST_DEDUCED_TYPENAME manage_additional_parameters<AP1,AP2,AP3>::type parameters;
+
+ /// \brief Relation type stored by the bimap.
+ // --------------------------------------------------------------------
+ public:
+
+ typedef ::boost::bimaps::relation::mutant_relation
+ <
+
+ ::boost::bimaps::tags::tagged<
+ BOOST_DEDUCED_TYPENAME mpl::if_<
+ mpl::and_
+ <
+ BOOST_DEDUCED_TYPENAME left_set_type::mutable_key,
+ BOOST_DEDUCED_TYPENAME parameters::set_type_of_relation::left_mutable_key
+ >,
+ // {
+ left_key_type,
+ // }
+ // else
+ // {
+ BOOST_DEDUCED_TYPENAME ::boost::add_const< left_key_type >::type
+ // }
+
+ >::type,
+ left_tag
+ >,
+
+ ::boost::bimaps::tags::tagged<
+ BOOST_DEDUCED_TYPENAME mpl::if_<
+ mpl::and_
+ <
+ BOOST_DEDUCED_TYPENAME right_set_type::mutable_key,
+ BOOST_DEDUCED_TYPENAME parameters::set_type_of_relation::right_mutable_key
+ >,
+ // {
+ right_key_type,
+ // }
+ // else
+ // {
+ BOOST_DEDUCED_TYPENAME ::boost::add_const< right_key_type >::type
+ // }
+
+ >::type,
+ right_tag
+ >,
+
+ // It is ::boost::mpl::na if no info_hook was included
+ BOOST_DEDUCED_TYPENAME parameters::additional_info,
+
+ // Force mutable keys
+ true
+
+ > relation;
+
+ //@{
+
+ typedef BOOST_DEDUCED_TYPENAME relation::left_pair left_value_type;
+ typedef BOOST_DEDUCED_TYPENAME relation::right_pair right_value_type;
+
+ //@}
+
+ // Bind the member of the relation, so multi_index can manage them
+ // --------------------------------------------------------------------
+ private:
+
+ typedef BOOST_DEDUCED_TYPENAME relation::storage_base relation_storage_base;
+
+ typedef BOOST_MULTI_INDEX_MEMBER(relation_storage_base, left_key_type, left)
+ left_member_extractor;
+
+ typedef BOOST_MULTI_INDEX_MEMBER(relation_storage_base,right_key_type,right)
+ right_member_extractor;
+
+ // The core indices are somewhat complicated to calculate, because they
+ // can be zero, one, two or three indices, depending on the use of
+ // {side}_based set type of relations and unconstrained_set_of and
+ // unconstrained_set_of_relation specifications.
+
+ typedef BOOST_DEDUCED_TYPENAME mpl::if_<
+ ::boost::bimaps::detail::is_unconstrained_set_of< left_set_type >,
+ // {
+ mpl::vector<>,
+ // }
+ // else
+ // {
+ mpl::vector
+ <
+ BOOST_DEDUCED_TYPENAME left_set_type::
+ BOOST_NESTED_TEMPLATE index_bind
+ <
+ left_member_extractor,
+ left_tag
+
+ >::type
+ >
+ // }
+ >::type left_core_indices;
+
+ typedef BOOST_DEDUCED_TYPENAME mpl::if_<
+ ::boost::bimaps::detail::is_unconstrained_set_of< right_set_type >,
+ // {
+ left_core_indices,
+ // }
+ // else
+ // {
+ BOOST_DEDUCED_TYPENAME mpl::push_front
+ <
+ left_core_indices,
+
+ BOOST_DEDUCED_TYPENAME right_set_type::
+ BOOST_NESTED_TEMPLATE index_bind
+ <
+ right_member_extractor,
+ right_tag
+
+ >::type
+
+ >::type
+ // }
+ >::type basic_core_indices;
+
+ // If it is based either on the left or on the right, then only the side
+ // indices are needed. But the set type of the relation can be completely
+ // diferent from the one used for the sides in wich case we have to add yet
+ // another index to the core.
+
+ // TODO
+ // If all the set types are unsconstrained there must be readable compile
+ // time error.
+
+ typedef BOOST_DEDUCED_TYPENAME mpl::if_<
+
+ is_same< BOOST_DEDUCED_TYPENAME parameters::set_type_of_relation, left_based >,
+ // {
+ ::boost::bimaps::tags::tagged< left_set_type, left_tag >,
+ // }
+ /* else */ BOOST_DEDUCED_TYPENAME mpl::if_<
+ is_same< BOOST_DEDUCED_TYPENAME parameters::set_type_of_relation, right_based >,
+ // {
+ ::boost::bimaps::tags::tagged< right_set_type, right_tag >,
+ // }
+ // else
+ // {
+ tags::tagged
+ <
+ BOOST_DEDUCED_TYPENAME parameters::
+ set_type_of_relation::BOOST_NESTED_TEMPLATE bind_to
+ <
+ relation
+
+ >::type,
+ independent_index_tag
+ >
+ // }
+ >::type
+ >::type tagged_set_of_relation_type;
+
+ protected:
+
+ typedef BOOST_DEDUCED_TYPENAME tagged_set_of_relation_type::tag
+ relation_set_tag;
+
+ typedef BOOST_DEDUCED_TYPENAME tagged_set_of_relation_type::value_type
+ relation_set_type_of;
+
+ // Logic tags
+ // This is a necesary extra level of indirection to allow unconstrained
+ // sets to be plug in the design. The bimap constructors use this logic
+ // tags.
+
+ typedef BOOST_DEDUCED_TYPENAME mpl::if_<
+ ::boost::bimaps::detail::is_unconstrained_set_of< left_set_type >,
+
+ BOOST_DEDUCED_TYPENAME mpl::if_<
+ ::boost::bimaps::detail::is_unconstrained_set_of< right_set_type >,
+
+ independent_index_tag,
+ right_tag
+
+ >::type,
+
+ left_tag
+
+ >::type logic_left_tag;
+
+ typedef BOOST_DEDUCED_TYPENAME mpl::if_<
+ ::boost::bimaps::detail::is_unconstrained_set_of< right_set_type >,
+
+ BOOST_DEDUCED_TYPENAME mpl::if_<
+ ::boost::bimaps::detail::is_unconstrained_set_of< left_set_type >,
+
+ independent_index_tag,
+ left_tag
+
+ >::type,
+
+ right_tag
+
+ >::type logic_right_tag;
+
+ typedef BOOST_DEDUCED_TYPENAME mpl::if_<
+ is_same< relation_set_tag, independent_index_tag >,
+
+ BOOST_DEDUCED_TYPENAME mpl::if_<
+ ::boost::bimaps::detail::
+ is_unconstrained_set_of< relation_set_type_of >,
+
+ logic_left_tag,
+ independent_index_tag
+
+ >::type,
+
+ BOOST_DEDUCED_TYPENAME mpl::if_<
+ is_same< BOOST_DEDUCED_TYPENAME parameters::set_type_of_relation, left_based >,
+
+ logic_left_tag,
+ logic_right_tag
+
+ >::type
+
+ >::type logic_relation_set_tag;
+
+ private:
+
+ typedef BOOST_DEDUCED_TYPENAME mpl::if_<
+ mpl::and_< is_same< relation_set_tag, independent_index_tag >,
+ mpl::not_<
+ ::boost::bimaps::detail::
+ is_unconstrained_set_of< relation_set_type_of >
+ >
+ >,
+ // {
+ BOOST_DEDUCED_TYPENAME mpl::push_front
+ <
+ basic_core_indices,
+
+ BOOST_DEDUCED_TYPENAME relation_set_type_of::
+ BOOST_NESTED_TEMPLATE index_bind
+ <
+ ::boost::bimaps::relation::support::both_keys_extractor<relation>,
+ independent_index_tag
+
+ >::type
+
+ >::type,
+ // }
+ // else
+ // {
+ basic_core_indices
+ // }
+
+ >::type complete_core_indices;
+
+ struct core_indices : public complete_core_indices {};
+
+ // Define the core using compute_index_type to translate the
+ // set type to an multi-index specification
+ // --------------------------------------------------------------------
+ public:
+
+ typedef multi_index::multi_index_container
+ <
+ relation,
+ core_indices,
+ BOOST_DEDUCED_TYPENAME parameters::allocator::
+ BOOST_NESTED_TEMPLATE rebind<relation>::other
+
+ > core_type;
+
+ // Core metadata
+ // --------------------------------------------------------------------
+ public:
+
+ typedef BOOST_DEDUCED_TYPENAME ::boost::multi_index::
+ index<core_type, logic_left_tag>::type left_index;
+
+ typedef BOOST_DEDUCED_TYPENAME ::boost::multi_index::
+ index<core_type,logic_right_tag>::type right_index;
+
+ typedef BOOST_DEDUCED_TYPENAME left_index::iterator left_core_iterator;
+ typedef BOOST_DEDUCED_TYPENAME left_index::const_iterator left_core_const_iterator;
+
+ typedef BOOST_DEDUCED_TYPENAME right_index::iterator right_core_iterator;
+ typedef BOOST_DEDUCED_TYPENAME right_index::const_iterator right_core_const_iterator;
+
+ // Map by {side} iterator metadata
+ // --------------------------------------------------------------------
+ public:
+
+ //@{
+
+ typedef ::boost::bimaps::detail::map_view_iterator
+ <
+ left_tag,
+ relation,
+ left_core_iterator
+
+ > left_iterator;
+
+ typedef ::boost::bimaps::detail::map_view_iterator
+ <
+ right_tag,
+ relation,
+ right_core_iterator
+
+ > right_iterator;
+
+ //@}
+
+ //@{
+
+ typedef ::boost::bimaps::detail::const_map_view_iterator
+ <
+ left_tag,
+ relation,
+ left_core_const_iterator
+
+ > left_const_iterator;
+
+ typedef ::boost::bimaps::detail::const_map_view_iterator
+ <
+ right_tag,
+ relation,
+ right_core_const_iterator
+
+ > right_const_iterator;
+
+ //@}
+
+ // Relation set view
+
+ typedef BOOST_DEDUCED_TYPENAME ::boost::multi_index::index
+ <
+ core_type, logic_relation_set_tag
+
+ >::type relation_set_core_index;
+
+ typedef BOOST_DEDUCED_TYPENAME relation_set_type_of::
+ BOOST_NESTED_TEMPLATE set_view_bind
+ <
+ relation_set_core_index
+
+ >::type relation_set;
+
+ public:
+
+ typedef bimap_core bimap_core_;
+};
+
+// Two auxiliar metafunctions to compute the map view types
+// The map view type can not be computed inside the bimap core because a
+// they need the bimap core to be parsed first.
+
+template< class BimapBaseType >
+struct left_map_view_type
+{
+ typedef BOOST_DEDUCED_TYPENAME BimapBaseType::left_set_type left_set_type;
+ typedef BOOST_DEDUCED_TYPENAME
+ left_set_type::BOOST_NESTED_TEMPLATE map_view_bind<
+ BOOST_DEDUCED_TYPENAME BimapBaseType::left_tag, BimapBaseType
+ >::type type;
+};
+
+template< class BimapBaseType >
+struct right_map_view_type
+{
+ typedef BOOST_DEDUCED_TYPENAME BimapBaseType::right_set_type right_set_type;
+ typedef BOOST_DEDUCED_TYPENAME
+ right_set_type::BOOST_NESTED_TEMPLATE map_view_bind<
+ BOOST_DEDUCED_TYPENAME BimapBaseType::right_tag, BimapBaseType
+ >::type type;
+};
+
+} // namespace detail
+} // namespace bimaps
+} // namespace boost
+
+#endif // BOOST_BIMAP_DETAIL_BIMAP_CORE_HPP
diff --git a/boost/bimap/detail/concept_tags.hpp b/boost/bimap/detail/concept_tags.hpp
new file mode 100644
index 0000000..1f252e3
--- /dev/null
+++ b/boost/bimap/detail/concept_tags.hpp
@@ -0,0 +1,97 @@
+// 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 detail/concept_tags.hpp
+/// \brief Bimap tags and concepts
+
+#ifndef BOOST_BIMAP_DETAIL_CONCEPT_TAGS_HPP
+#define BOOST_BIMAP_DETAIL_CONCEPT_TAGS_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER>=1200)
+#pragma once
+#endif
+
+#include <boost/config.hpp>
+
+#include <boost/mpl/identity.hpp>
+#include <boost/mpl/placeholders.hpp>
+#include <boost/mpl/bool.hpp>
+
+namespace boost {
+namespace bimaps {
+namespace detail {
+
+/// \brief Tag of {SetType}_of definition classes
+/**
+The {SetType}_of classes are derived from this class so it is easy to construct
+metafunctions. For example now is easy to create a is_set_type_of metafunction.
+ **/
+
+struct set_type_of_tag {};
+
+/// \brief Tag of {SetType}_of_relation defition classes
+
+struct set_type_of_relation_tag {};
+
+/// \brief Tag of {Side}_based identifiers
+
+struct side_based_tag : set_type_of_relation_tag {};
+
+} // namespace detail
+
+
+/** \struct boost::bimaps::left_based
+ \brief Tag to indicate that the main view will be based on the left side.
+
+This is convenient because the multi-index core will be more efficient.
+If possible use this options or the right based one.
+
+See also right_based.
+ **/
+
+/** \struct boost::bimaps::right_based
+ \brief Tag to indicate that the main view will be based on the right side.
+
+This is convenient because the multi-index core will be more efficient.
+If possible use this options or the right based one.
+
+See also left_based.
+ **/
+
+#ifndef BOOST_BIMAP_DOXYGEN_WILL_NOT_PROCESS_THE_FOLLOWING_LINES
+
+struct left_based : ::boost::bimaps::detail::side_based_tag
+{
+ // I run into troubles if I do not define bind for side based tags.
+ // Maybe a more coherent way of binding the relation can be developped.
+ template< class Relation > struct bind_to { typedef void type; };
+
+ typedef mpl::bool_<true> left_mutable_key;
+ typedef mpl::bool_<true> right_mutable_key;
+};
+
+struct right_based : ::boost::bimaps::detail::side_based_tag
+{
+ // I run into troubles if I do not define bind for side based tags.
+ // Maybe a more coherent way of binding the relation can be developped.
+ template< class Relation > struct bind_to { typedef void type; };
+
+ typedef mpl::bool_<true> left_mutable_key;
+ typedef mpl::bool_<true> right_mutable_key;
+};
+
+#endif // BOOST_BIMAP_DOXYGEN_WILL_NOT_PROCESS_THE_FOLLOWING_LINES
+
+typedef mpl::_ _relation;
+
+} // namespace bimaps
+} // namespace boost
+
+
+#endif // BOOST_BIMAP_DETAIL_CONCEPT_TAGS_HPP
+
diff --git a/boost/bimap/detail/debug/static_error.hpp b/boost/bimap/detail/debug/static_error.hpp
new file mode 100644
index 0000000..3a8ed63
--- /dev/null
+++ b/boost/bimap/detail/debug/static_error.hpp
@@ -0,0 +1,36 @@
+// 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 detail/debug/static_error.hpp
+/// \brief Formatted compile time error
+
+#ifndef BOOST_BIMAP_DETAIL_DEBUG_STATIC_ERROR_HPP
+#define BOOST_BIMAP_DETAIL_DEBUG_STATIC_ERROR_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER>=1200)
+#pragma once
+#endif
+
+#include <boost/config.hpp>
+
+#include <boost/mpl/assert.hpp>
+#include <boost/preprocessor/cat.hpp>
+
+// Easier way to call BOOST_MPL_ASSERT_MSG in class scope to generate
+// a static error.
+/*===========================================================================*/
+#define BOOST_BIMAP_STATIC_ERROR(MESSAGE,VARIABLES) \
+ struct BOOST_PP_CAT(BIMAP_STATIC_ERROR__,MESSAGE) {}; \
+ BOOST_MPL_ASSERT_MSG(false, \
+ BOOST_PP_CAT(BIMAP_STATIC_ERROR__,MESSAGE), \
+ VARIABLES)
+/*===========================================================================*/
+
+
+
+#endif // BOOST_BIMAP_DETAIL_DEBUG_STATIC_ERROR_HPP
diff --git a/boost/bimap/detail/generate_index_binder.hpp b/boost/bimap/detail/generate_index_binder.hpp
new file mode 100644
index 0000000..01c899d
--- /dev/null
+++ b/boost/bimap/detail/generate_index_binder.hpp
@@ -0,0 +1,125 @@
+// 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 detail/generate_index_binder.hpp
+/// \brief Define macros to help building the set type of definitions
+
+
+#ifndef BOOST_BIMAP_DETAIL_GENERATE_INDEX_BINDER_HPP
+#define BOOST_BIMAP_DETAIL_GENERATE_INDEX_BINDER_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER>=1200)
+#pragma once
+#endif
+
+#include <boost/config.hpp>
+
+#include <boost/multi_index/tag.hpp>
+
+
+/*===========================================================================*/
+#define BOOST_BIMAP_GENERATE_INDEX_BINDER_0CP( \
+ \
+ MULTI_INDEX_TYPE \
+ \
+) \
+ \
+template< class KeyExtractor, class Tag > \
+struct index_bind \
+{ \
+ typedef MULTI_INDEX_TYPE \
+ < \
+ multi_index::tag< Tag >, \
+ KeyExtractor \
+ \
+ > type; \
+};
+/*===========================================================================*/
+
+
+
+/*===========================================================================*/
+#define BOOST_BIMAP_GENERATE_INDEX_BINDER_1CP( \
+ \
+ MULTI_INDEX_TYPE, \
+ CONFIG_PARAMETER \
+ \
+) \
+ \
+template< class KeyExtractor, class Tag > \
+struct index_bind \
+{ \
+ typedef MULTI_INDEX_TYPE \
+ < \
+ multi_index::tag< Tag >, \
+ KeyExtractor, \
+ CONFIG_PARAMETER \
+ \
+ > type; \
+};
+/*===========================================================================*/
+
+
+
+
+/*===========================================================================*/
+#define BOOST_BIMAP_GENERATE_INDEX_BINDER_2CP( \
+ \
+ MULTI_INDEX_TYPE, \
+ CONFIG_PARAMETER_1, \
+ CONFIG_PARAMETER_2 \
+) \
+ \
+template< class KeyExtractor, class Tag > \
+struct index_bind \
+{ \
+ typedef MULTI_INDEX_TYPE \
+ < \
+ multi_index::tag< Tag >, \
+ KeyExtractor, \
+ CONFIG_PARAMETER_1, \
+ CONFIG_PARAMETER_2 \
+ \
+ > type; \
+ \
+};
+/*===========================================================================*/
+
+
+// This is a special registration to allow sequenced and random access indices
+// to play along smoothly with the other index types.
+
+/*===========================================================================*/
+#define BOOST_BIMAP_GENERATE_INDEX_BINDER_0CP_NO_EXTRACTOR( \
+ \
+ MULTI_INDEX_TYPE \
+ \
+) \
+ \
+template< class KeyExtractor, class Tag > \
+struct index_bind \
+{ \
+ typedef MULTI_INDEX_TYPE< multi_index::tag< Tag > > type; \
+};
+/*===========================================================================*/
+
+
+// This is yet another special registration to allow unconstrained sets
+// to play along smoothly with the other index types.
+
+/*===========================================================================*/
+#define BOOST_BIMAP_GENERATE_INDEX_BINDER_FAKE \
+ \
+template< class KeyExtractor, class Tag > \
+struct index_bind \
+{ \
+ typedef void type; \
+}; \
+/*===========================================================================*/
+
+#endif // BOOST_BIMAP_DETAIL_GENERATE_INDEX_BINDER_HPP
diff --git a/boost/bimap/detail/generate_relation_binder.hpp b/boost/bimap/detail/generate_relation_binder.hpp
new file mode 100644
index 0000000..0ff4762
--- /dev/null
+++ b/boost/bimap/detail/generate_relation_binder.hpp
@@ -0,0 +1,88 @@
+// 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 detail/generate_relation_binder.hpp
+/// \brief Define macros to help building the set type of definitions
+
+#ifndef BOOST_BIMAP_DETAIL_GENERATE_RELATION_BINDER_HPP
+#define BOOST_BIMAP_DETAIL_GENERATE_RELATION_BINDER_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER>=1200)
+#pragma once
+#endif
+
+#include <boost/config.hpp>
+
+#include <boost/mpl/apply.hpp>
+
+/*===========================================================================*/
+#define BOOST_BIMAP_GENERATE_RELATION_BINDER_0CP( \
+ \
+ SET_TYPE_OF \
+ ) \
+ \
+ template< class Relation > \
+ struct bind_to \
+ { \
+ typedef SET_TYPE_OF<Relation> type; \
+ \
+ };
+/*===========================================================================*/
+
+
+
+/*===========================================================================*/
+#define BOOST_BIMAP_GENERATE_RELATION_BINDER_1CP( \
+ \
+ SET_TYPE_OF, \
+ CP1 \
+ ) \
+ \
+ template< class Relation > \
+ struct bind_to \
+ { \
+ typedef SET_TYPE_OF \
+ < \
+ Relation, \
+ BOOST_DEDUCED_TYPENAME mpl::apply<CP1, \
+ BOOST_DEDUCED_TYPENAME Relation::storage_base >::type \
+ \
+ > type; \
+ \
+ };
+/*===========================================================================*/
+
+
+
+/*===========================================================================*/
+#define BOOST_BIMAP_GENERATE_RELATION_BINDER_2CP( \
+ \
+ SET_TYPE_OF, \
+ CP1, \
+ CP2 \
+ ) \
+ \
+ template< class Relation > \
+ struct bind_to \
+ { \
+ typedef SET_TYPE_OF \
+ < \
+ Relation, \
+ BOOST_DEDUCED_TYPENAME mpl::apply<CP1, \
+ BOOST_DEDUCED_TYPENAME Relation::storage_base >::type, \
+ BOOST_DEDUCED_TYPENAME mpl::apply<CP2, \
+ BOOST_DEDUCED_TYPENAME Relation::storage_base >::type \
+ \
+ > type; \
+ \
+ };
+/*===========================================================================*/
+
+
+
+#endif // BOOST_BIMAP_DETAIL_GENERATE_RELATION_BINDER_HPP
diff --git a/boost/bimap/detail/generate_view_binder.hpp b/boost/bimap/detail/generate_view_binder.hpp
new file mode 100644
index 0000000..925184c
--- /dev/null
+++ b/boost/bimap/detail/generate_view_binder.hpp
@@ -0,0 +1,58 @@
+// 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 detail/generate_view_binder.hpp
+/// \brief Define macros to help building the set type of definitions
+
+#ifndef BOOST_BIMAP_DETAIL_GENERATE_VIEW_BINDER_HPP
+#define BOOST_BIMAP_DETAIL_GENERATE_VIEW_BINDER_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER>=1200)
+#pragma once
+#endif
+
+#include <boost/config.hpp>
+
+#include <boost/multi_index/tag.hpp>
+
+/*===========================================================================*/
+#define BOOST_BIMAP_GENERATE_MAP_VIEW_BINDER( \
+ \
+ MAP_VIEW_TYPE \
+ \
+) \
+ \
+template< class Tag, class BimapType > \
+struct map_view_bind \
+{ \
+ typedef MAP_VIEW_TYPE \
+ < \
+ Tag, \
+ BimapType \
+ \
+ > type; \
+};
+/*===========================================================================*/
+
+
+/*===========================================================================*/
+#define BOOST_BIMAP_GENERATE_SET_VIEW_BINDER( \
+ \
+ SET_VIEW_TYPE \
+ \
+) \
+ \
+template< class IndexType > \
+struct set_view_bind \
+{ \
+ typedef SET_VIEW_TYPE<IndexType> type; \
+};
+/*===========================================================================*/
+
+
+#endif // BOOST_BIMAP_DETAIL_GENERATE_VIEW_BINDER_HPP
diff --git a/boost/bimap/detail/is_set_type_of.hpp b/boost/bimap/detail/is_set_type_of.hpp
new file mode 100644
index 0000000..13d52c1
--- /dev/null
+++ b/boost/bimap/detail/is_set_type_of.hpp
@@ -0,0 +1,66 @@
+// 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 detail/is_set_type_of.hpp
+/// \brief Is set type of and is set type of relation metafunctions.
+
+#ifndef BOOST_BIMAP_DETAIL_IS_SET_TYPE_OF_HPP
+#define BOOST_BIMAP_DETAIL_IS_SET_TYPE_OF_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER>=1200)
+#pragma once
+#endif
+
+#include <boost/config.hpp>
+
+#include <boost/type_traits/is_base_of.hpp>
+#include <boost/bimap/detail/concept_tags.hpp>
+
+/** \struct boost::bimaps::detail::is_set_type_of
+
+\brief Type trait to check if a class is a set_type_of specification
+
+\code
+template< class Type >
+struct is_set_type_of : {true_|false_} {};
+\endcode
+ **/
+
+/** \struct boost::bimaps::detail::is_set_type_of_relation
+
+\brief Type trait to check if a class is a set_type_of_relation specification
+
+\code
+template< class Type >
+struct is_set_type_of_relation : {true_|false_} {};
+\endcode
+
+ **/
+
+#ifndef BOOST_BIMAP_DOXYGEN_WILL_NOT_PROCESS_THE_FOLLOWING_LINES
+
+namespace boost {
+namespace bimaps {
+namespace detail {
+
+template< class Type >
+struct is_set_type_of :
+ is_base_of< set_type_of_tag, Type > {};
+
+template< class Type >
+struct is_set_type_of_relation :
+ is_base_of< set_type_of_relation_tag, Type > {};
+
+} // namespace detail
+} // namespace bimaps
+} // namespace boost
+
+#endif // BOOST_BIMAP_DOXYGEN_WILL_NOT_PROCESS_THE_FOLLOWING_LINES
+
+#endif // BOOST_BIMAP_DETAIL_IS_SET_TYPE_OF_HPP
+
diff --git a/boost/bimap/detail/manage_additional_parameters.hpp b/boost/bimap/detail/manage_additional_parameters.hpp
new file mode 100644
index 0000000..3d22d73
--- /dev/null
+++ b/boost/bimap/detail/manage_additional_parameters.hpp
@@ -0,0 +1,243 @@
+// 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 detail/manage_additional_parameters.hpp
+/// \brief Utility class to extract the additional parameters from the template parameters.
+
+#ifndef BOOST_BIMAP_DETAIL_MANAGE_ADDITIONAL_PARAMETERS_HPP
+#define BOOST_BIMAP_DETAIL_MANAGE_ADDITIONAL_PARAMETERS_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER>=1200)
+#pragma once
+#endif
+
+#include <boost/config.hpp>
+
+#include <memory>
+
+// Boost.MPL
+#include <boost/mpl/bool.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/mpl/aux_/na.hpp>
+#include <boost/type_traits/is_same.hpp>
+
+#include <boost/bimap/detail/is_set_type_of.hpp>
+
+namespace boost {
+namespace bimaps {
+
+template< class Type >
+struct with_info
+{
+ typedef Type value_type;
+};
+
+namespace detail {
+
+/// \brief Metafunction to check if a given type is a data_hook specification.
+
+template< class Type >
+struct is_with_info : ::boost::mpl::false_ {};
+
+template< class ValueType >
+struct is_with_info< with_info<ValueType> > : ::boost::mpl::true_ {};
+
+/** \struct boost::bimaps::detail::manage_additional_parameters
+\brief Utility class to extract the additional parameters from the template parameters.
+
+\code
+template< class AP1, class AP2, class AP3 >
+struct manage_additional_parameters
+{
+ struct parameters
+ {
+ typedef -unspecified- set_type_of_relation;
+ typedef -unspecified- data_hook;
+ typedef -unspecified- allocator;
+ };
+
+ typedef parameters type;
+};
+\endcode
+
+See also bimap, bimap_core.
+ **/
+
+#ifndef BOOST_BIMAP_DOXYGEN_WILL_NOT_PROCESS_THE_FOLLOWING_LINES
+
+template< class AP1, class AP2, class AP3 >
+struct manage_additional_parameters
+{
+ // (1) manage_additional_parameters<
+ // not_specified,not_specified,not_specified>
+ //
+ // set_type_of_relation: based on the left key type
+ // info_hook: no additional info
+ // allocator: default allocator
+
+ struct case_NNN
+ {
+ typedef left_based set_type_of_relation;
+ typedef std::allocator<void> allocator;
+ typedef ::boost::mpl::na additional_info;
+ };
+
+ // (2) manage_additional_parameters<Allocator,not_specified,not_specified>
+ //
+ // set_type_of_relation: based on the left key type
+ // info_hook: no additional info
+ // allocator: Allocator
+
+ struct case_ANN
+ {
+ typedef left_based set_type_of_relation;
+ typedef AP1 allocator;
+ typedef ::boost::mpl::na additional_info;
+ };
+
+ // (3) manage_additional_parameters<
+ // SetOfRelationType,not_specified,not_specified>
+ //
+ // set_type_of_relation: SetTypeOfRelation
+ // info_hook: no additional info
+ // allocator: default allocator
+
+ struct case_SNN
+ {
+ typedef AP1 set_type_of_relation;
+ typedef std::allocator<void> allocator;
+ typedef ::boost::mpl::na additional_info;
+ };
+
+ // (4) manage_additional_parameters<
+ // SetTypeOfRelation,Allocator,not_specified>
+ //
+ // set_type_of_relation: SetTypeOfRelation
+ // info_hook: no additional info
+ // allocator: Allocator
+
+ struct case_SAN
+ {
+ typedef AP1 set_type_of_relation;
+ typedef AP2 allocator;
+ typedef ::boost::mpl::na additional_info;
+ };
+
+ // (5) manage_additional_parameters<InfoToHook,not_specified,not_specified>
+ //
+ // set_type_of_relation: based on the left key type
+ // info_hook: InfoToHook
+ // allocator: default allocator
+
+ struct case_HNN
+ {
+ typedef left_based set_type_of_relation;
+ typedef std::allocator<void> allocator;
+ typedef BOOST_DEDUCED_TYPENAME AP1::value_type additional_info;
+ };
+
+ // (6) manage_additional_parameters<
+ // SetTypeOfRelation,InfoToHook,not_specified>
+ //
+ // set_type_of_relation: SetTypeOfRelation
+ // info_hook: InfoToHook
+ // allocator: default allocator
+
+ struct case_SHN
+ {
+ typedef AP1 set_type_of_relation;
+ typedef std::allocator<void> allocator;
+ typedef BOOST_DEDUCED_TYPENAME AP2::value_type additional_info;
+ };
+
+ // (7) manage_additional_parameters<
+ // DataToHook,Allocator,not_specified>
+ //
+ // set_type_of_relation: SetTypeOfRelation
+ // info_hook: InfoToHook
+ // allocator: default allocator
+
+ struct case_HAN
+ {
+ typedef left_based set_type_of_relation;
+ typedef AP2 allocator;
+ typedef BOOST_DEDUCED_TYPENAME AP1::value_type additional_info;
+ };
+
+ // (8) manage_additional_parameters<
+ // SetTypeOfRelation,DataToHook,Allocator>
+ //
+ // set_type_of_relation: SetTypeOfRelation
+ // info_hook: InfoToHook
+ // allocator: Allocator
+
+ struct case_SHA
+ {
+ typedef AP1 set_type_of_relation;
+ typedef AP2 allocator;
+ typedef BOOST_DEDUCED_TYPENAME AP2::value_type additional_info;
+ };
+
+ // Some annidated mpl::if_ and we are done!
+
+ typedef BOOST_DEDUCED_TYPENAME mpl::if_
+ <
+ ::boost::mpl::is_na<AP1>,
+ case_NNN, // (1)
+ BOOST_DEDUCED_TYPENAME mpl::if_
+ <
+ ::boost::mpl::is_na<AP2>,
+ BOOST_DEDUCED_TYPENAME mpl::if_
+ <
+ is_set_type_of_relation<AP1>,
+ case_SNN, // (3)
+ BOOST_DEDUCED_TYPENAME mpl::if_
+ <
+ is_with_info<AP1>,
+ case_HNN, // (5)
+ case_ANN // (2)
+
+ >::type
+
+ >::type,
+ BOOST_DEDUCED_TYPENAME mpl::if_
+ <
+ ::boost::mpl::is_na<AP3>,
+ BOOST_DEDUCED_TYPENAME mpl::if_
+ <
+ is_with_info<AP1>,
+ case_HAN, // (7)
+ BOOST_DEDUCED_TYPENAME mpl::if_
+ <
+ is_with_info<AP2>,
+ case_SHN, // (6)
+ case_SAN // (4)
+
+ >::type
+
+ >::type,
+
+ case_SHA // (8)
+
+ >::type
+
+ >::type
+
+ >::type type;
+
+};
+
+#endif // BOOST_BIMAP_DOXYGEN_WILL_NOT_PROCESS_THE_FOLLOWING_LINES
+
+} // namespace detail
+} // namespace bimaps
+} // namespace boost
+
+
+#endif // BOOST_BIMAP_DETAIL_MANAGE_ADDITIONAL_PARAMETERS_HPP
+
diff --git a/boost/bimap/detail/manage_bimap_key.hpp b/boost/bimap/detail/manage_bimap_key.hpp
new file mode 100644
index 0000000..d485e50
--- /dev/null
+++ b/boost/bimap/detail/manage_bimap_key.hpp
@@ -0,0 +1,84 @@
+// 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 detail/manage_bimap_key.hpp
+/// \brief Utility class to manage the set types of a bimap.
+
+#ifndef BOOST_BIMAP_DETAIL_MANAGE_BIMAP_KEY_HPP
+#define BOOST_BIMAP_DETAIL_MANAGE_BIMAP_KEY_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER>=1200)
+#pragma once
+#endif
+
+#include <boost/config.hpp>
+
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/identity.hpp>
+
+#include <boost/bimap/detail/is_set_type_of.hpp>
+
+#include <boost/bimap/set_of.hpp>
+
+namespace boost {
+namespace bimaps {
+namespace detail {
+
+/** \struct boost::bimaps::detail::manage_bimap_key
+\brief Metafunction to manage the set types of a bimap.
+
+\code
+template< class Type >
+struct manage_bimap_key
+{
+ typedef -SetType- type;
+}
+\endcode
+
+See also bimap, bimap_core.
+ **/
+
+#ifndef BOOST_BIMAP_DOXYGEN_WILL_NOT_PROCESS_THE_FOLLOWING_LINES
+
+template< class Type >
+struct manage_bimap_key
+{
+
+typedef BOOST_DEDUCED_TYPENAME
+
+ mpl::eval_if< BOOST_DEDUCED_TYPENAME is_set_type_of< Type >::type,
+ // {
+ mpl::identity< Type >,
+ // }
+ // else
+ // {
+ // Default it to a set
+ mpl::identity< set_of< Type > >
+ // }
+
+ >::type set_type;
+
+ // Returns set_type and evaluate the concept_checked_type
+
+ typedef BOOST_DEDUCED_TYPENAME mpl::if_c< true, set_type,
+ BOOST_DEDUCED_TYPENAME set_type::lazy_concept_checked::type
+ >::type type;
+};
+
+
+
+#endif // BOOST_BIMAP_DOXYGEN_WILL_NOT_PROCESS_THE_FOLLOWING_LINES
+
+} // namespace detail
+} // namespace bimaps
+} // namespace boost
+
+
+#endif // BOOST_BIMAP_DETAIL_MANAGE_BIMAP_KEY_HPP
+
+
diff --git a/boost/bimap/detail/map_view_base.hpp b/boost/bimap/detail/map_view_base.hpp
new file mode 100644
index 0000000..7900901
--- /dev/null
+++ b/boost/bimap/detail/map_view_base.hpp
@@ -0,0 +1,553 @@
+// 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 detail/map_view_base.hpp
+/// \brief Helper base for the construction of the bimap views types.
+
+#ifndef BOOST_BIMAP_DETAIL_MAP_VIEW_BASE_HPP
+#define BOOST_BIMAP_DETAIL_MAP_VIEW_BASE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER>=1200)
+#pragma once
+#endif
+
+#include <boost/config.hpp>
+
+#include <stdexcept>
+#include <utility>
+
+#include <boost/throw_exception.hpp>
+#include <boost/type_traits/is_const.hpp>
+#include <boost/mpl/if.hpp>
+
+#include <boost/bimap/relation/support/get_pair_functor.hpp>
+#include <boost/bimap/relation/detail/to_mutable_relation_functor.hpp>
+#include <boost/bimap/container_adaptor/support/iterator_facade_converters.hpp>
+#include <boost/bimap/relation/support/data_extractor.hpp>
+#include <boost/bimap/relation/support/opposite_tag.hpp>
+#include <boost/bimap/relation/support/pair_type_by.hpp>
+#include <boost/bimap/support/iterator_type_by.hpp>
+#include <boost/bimap/support/key_type_by.hpp>
+#include <boost/bimap/support/data_type_by.hpp>
+#include <boost/bimap/support/value_type_by.hpp>
+#include <boost/bimap/detail/modifier_adaptor.hpp>
+#include <boost/bimap/detail/debug/static_error.hpp>
+
+namespace boost {
+namespace bimaps {
+
+namespace detail {
+
+
+// The next macro can be converted in a metafunctor to gain code robustness.
+/*===========================================================================*/
+#define BOOST_BIMAP_MAP_VIEW_CONTAINER_ADAPTOR( \
+ CONTAINER_ADAPTOR, TAG,BIMAP, OTHER_ITER, CONST_OTHER_ITER \
+) \
+::boost::bimaps::container_adaptor::CONTAINER_ADAPTOR \
+< \
+ BOOST_DEDUCED_TYPENAME BIMAP::core_type:: \
+ BOOST_NESTED_TEMPLATE index<TAG>::type, \
+ BOOST_DEDUCED_TYPENAME ::boost::bimaps::support:: \
+ iterator_type_by<TAG,BIMAP>::type, \
+ BOOST_DEDUCED_TYPENAME ::boost::bimaps::support:: \
+ const_iterator_type_by<TAG,BIMAP>::type, \
+ BOOST_DEDUCED_TYPENAME ::boost::bimaps::support:: \
+ OTHER_ITER<TAG,BIMAP>::type, \
+ BOOST_DEDUCED_TYPENAME ::boost::bimaps::support:: \
+ CONST_OTHER_ITER<TAG,BIMAP>::type, \
+ ::boost::bimaps::container_adaptor::support::iterator_facade_to_base \
+ < \
+ BOOST_DEDUCED_TYPENAME ::boost::bimaps::support:: \
+ iterator_type_by<TAG,BIMAP>::type, \
+ BOOST_DEDUCED_TYPENAME ::boost::bimaps::support:: \
+ const_iterator_type_by<TAG,BIMAP>::type \
+ \
+ >, \
+ ::boost::mpl::na, \
+ ::boost::mpl::na, \
+ ::boost::bimaps::relation::detail:: \
+ pair_to_relation_functor<TAG,BOOST_DEDUCED_TYPENAME BIMAP::relation>, \
+ ::boost::bimaps::relation::support:: \
+ get_pair_functor<TAG, BOOST_DEDUCED_TYPENAME BIMAP::relation > \
+>
+/*===========================================================================*/
+
+
+#if defined(BOOST_MSVC)
+/*===========================================================================*/
+#define BOOST_BIMAP_MAP_VIEW_BASE_FRIEND(TYPE,TAG,BIMAP) \
+ typedef ::boost::bimaps::detail::map_view_base< \
+ TYPE<TAG,BIMAP>,TAG,BIMAP > friend_map_view_base; \
+ friend class friend_map_view_base;
+/*===========================================================================*/
+#else
+/*===========================================================================*/
+#define BOOST_BIMAP_MAP_VIEW_BASE_FRIEND(TYPE,TAG,BIMAP) \
+ friend class ::boost::bimaps::detail::map_view_base< \
+ TYPE<TAG,BIMAP>,TAG,BIMAP >;
+/*===========================================================================*/
+#endif
+
+
+/// \brief Common base for map views.
+
+template< class Derived, class Tag, class BimapType>
+class map_view_base
+{
+ typedef ::boost::bimaps::container_adaptor::support::
+ iterator_facade_to_base<
+
+ BOOST_DEDUCED_TYPENAME ::boost::bimaps::support::
+ iterator_type_by<Tag,BimapType>::type,
+
+ BOOST_DEDUCED_TYPENAME ::boost::bimaps::support::
+ const_iterator_type_by<Tag,BimapType>::type
+
+ > iterator_to_base_;
+
+ typedef ::boost::bimaps::relation::detail::
+ pair_to_relation_functor<Tag,
+ BOOST_DEDUCED_TYPENAME BimapType::relation> value_to_base_;
+
+ typedef BOOST_DEDUCED_TYPENAME ::boost::bimaps::support::
+ key_type_by<Tag,BimapType>::type key_type_;
+
+ typedef BOOST_DEDUCED_TYPENAME ::boost::bimaps::support::
+ data_type_by<Tag,BimapType>::type data_type_;
+
+ typedef BOOST_DEDUCED_TYPENAME ::boost::bimaps::relation::support::
+ pair_type_by<Tag,
+ BOOST_DEDUCED_TYPENAME BimapType::relation>::type value_type_;
+
+ typedef BOOST_DEDUCED_TYPENAME ::boost::bimaps::support::
+ iterator_type_by<Tag,BimapType>::type iterator_;
+
+ public:
+
+ bool replace(iterator_ position, const value_type_ & x)
+ {
+ return derived().base().replace(
+ derived().template functor<iterator_to_base_>()(position),
+ derived().template functor<value_to_base_>()(x)
+ );
+ }
+
+ template< class CompatibleKey >
+ bool replace_key(iterator_ position, const CompatibleKey & k)
+ {
+ return derived().base().replace(
+ derived().template functor<iterator_to_base_>()(position),
+ derived().template functor<value_to_base_>()(
+ value_type_(k,position->second)
+ )
+ );
+ }
+
+ template< class CompatibleData >
+ bool replace_data(iterator_ position, const CompatibleData & d)
+ {
+ return derived().base().replace(
+ derived().template functor<iterator_to_base_>()(position),
+ derived().template functor<value_to_base_>()(
+ value_type_(position->first,d)
+ )
+ );
+ }
+
+ /* This function may be provided in the future
+
+ template< class Modifier >
+ bool modify(iterator_ position, Modifier mod)
+ {
+ return derived().base().modify(
+
+ derived().template functor<iterator_to_base_>()(position),
+
+ ::boost::bimaps::detail::relation_modifier_adaptor
+ <
+ Modifier,
+ BOOST_DEDUCED_TYPENAME BimapType::relation,
+ BOOST_DEDUCED_TYPENAME ::boost::bimaps::relation::support::
+ data_extractor
+ <
+ Tag, BOOST_DEDUCED_TYPENAME BimapType::relation
+
+ >::type,
+ BOOST_DEDUCED_TYPENAME ::boost::bimaps::relation::support::
+ data_extractor
+ <
+ BOOST_DEDUCED_TYPENAME ::boost::bimaps::relation::support::
+ opossite_tag<Tag,BimapType>::type,
+ BOOST_DEDUCED_TYPENAME BimapType::relation
+
+ >::type
+
+ >(mod)
+ );
+ }
+ */
+
+ template< class Modifier >
+ bool modify_key(iterator_ position, Modifier mod)
+ {
+ return derived().base().modify_key(
+ derived().template functor<iterator_to_base_>()(position), mod
+ );
+ }
+
+ template< class Modifier >
+ bool modify_data(iterator_ position, Modifier mod)
+ {
+ typedef BOOST_DEDUCED_TYPENAME ::boost::bimaps::relation::support::
+ data_extractor
+ <
+ BOOST_DEDUCED_TYPENAME ::boost::bimaps::relation::support::
+ opossite_tag<Tag,BimapType>::type,
+ BOOST_DEDUCED_TYPENAME BimapType::relation
+
+ >::type data_extractor_;
+
+ return derived().base().modify(
+
+ derived().template functor<iterator_to_base_>()(position),
+
+ // this may be replaced later by
+ // ::boost::bind( mod, ::boost::bind(data_extractor_(),_1) )
+
+ ::boost::bimaps::detail::unary_modifier_adaptor
+ <
+ Modifier,
+ BOOST_DEDUCED_TYPENAME BimapType::relation,
+ data_extractor_
+
+ >(mod)
+ );
+ }
+
+ protected:
+
+ typedef map_view_base map_view_base_;
+
+ private:
+
+ // Curiously Recurring Template interface.
+
+ Derived& derived()
+ {
+ return *static_cast<Derived*>(this);
+ }
+
+ Derived const& derived() const
+ {
+ return *static_cast<Derived const*>(this);
+ }
+};
+
+
+
+
+template< class Derived, class Tag, class BimapType>
+class mutable_data_unique_map_view_access
+{
+ typedef BOOST_DEDUCED_TYPENAME ::boost::bimaps::support::
+ data_type_by<Tag,BimapType>::type data_type_;
+
+ public:
+
+ template< class CompatibleKey >
+ data_type_ & at(const CompatibleKey& k)
+ {
+ typedef BOOST_DEDUCED_TYPENAME ::boost::bimaps::support::
+ iterator_type_by<Tag,BimapType>::type iterator;
+
+ iterator iter = derived().find(k);
+ if( iter == derived().end() )
+ {
+ ::boost::throw_exception(
+ std::out_of_range("bimap<>: invalid key")
+ );
+ }
+ return iter->second;
+ }
+
+ template< class CompatibleKey >
+ const data_type_ & at(const CompatibleKey& k) const
+ {
+ typedef BOOST_DEDUCED_TYPENAME ::boost::bimaps::support::
+ const_iterator_type_by<Tag,BimapType>::type const_iterator;
+
+ const_iterator iter = derived().find(k);
+ if( iter == derived().end() )
+ {
+ ::boost::throw_exception(
+ std::out_of_range("bimap<>: invalid key")
+ );
+ }
+ return iter->second;
+ }
+
+ template< class CompatibleKey >
+ data_type_ & operator[](const CompatibleKey& k)
+ {
+ typedef BOOST_DEDUCED_TYPENAME ::boost::bimaps::support::
+ iterator_type_by<Tag,BimapType>::type iterator;
+
+ typedef BOOST_DEDUCED_TYPENAME ::boost::bimaps::support::
+ value_type_by<Tag,BimapType>::type value_type;
+
+ iterator iter = derived().find(k);
+ if( iter == derived().end() )
+ {
+ iter = derived().insert( value_type(k,data_type_()) ).first;
+ }
+ return iter->second;
+ }
+
+ protected:
+
+ typedef mutable_data_unique_map_view_access
+ mutable_data_unique_map_view_access_;
+
+ private:
+
+ // Curiously Recurring Template interface.
+
+ Derived& derived()
+ {
+ return *static_cast<Derived*>(this);
+ }
+
+ Derived const& derived() const
+ {
+ return *static_cast<Derived const*>(this);
+ }
+};
+
+
+template< class Derived, class Tag, class BimapType>
+class non_mutable_data_unique_map_view_access
+{
+ typedef BOOST_DEDUCED_TYPENAME ::boost::bimaps::support::
+ data_type_by<Tag,BimapType>::type data_type_;
+
+ public:
+
+ template< class CompatibleKey >
+ const data_type_ & at(const CompatibleKey& k) const
+ {
+ typedef BOOST_DEDUCED_TYPENAME ::boost::bimaps::support::
+ const_iterator_type_by<Tag,BimapType>::type const_iterator;
+
+ const_iterator iter = derived().find(k);
+ if( iter == derived().end() )
+ {
+ ::boost::throw_exception(
+ std::out_of_range("bimap<>: invalid key")
+ );
+ }
+ return iter->second;
+ }
+
+ template< class CompatibleKey >
+ data_type_ & operator[](const CompatibleKey& k)
+ {
+ BOOST_BIMAP_STATIC_ERROR( OPERATOR_BRACKET_IS_NOT_SUPPORTED, (Derived));
+ }
+
+ protected:
+
+ typedef non_mutable_data_unique_map_view_access
+ non_mutable_data_unique_map_view_access_;
+
+ private:
+
+ // Curiously Recurring Template interface.
+
+ Derived& derived()
+ {
+ return *static_cast<Derived*>(this);
+ }
+
+ Derived const& derived() const
+ {
+ return *static_cast<Derived const*>(this);
+ }
+};
+
+
+template< class Derived, class Tag, class BimapType>
+struct unique_map_view_access
+{
+ private:
+ typedef BOOST_DEDUCED_TYPENAME ::boost::bimaps::support::
+ value_type_by<Tag,BimapType>::type value_type;
+
+ public:
+ typedef BOOST_DEDUCED_TYPENAME ::boost::mpl::if_
+ <
+ typename ::boost::is_const<
+ BOOST_DEDUCED_TYPENAME value_type::second_type >::type,
+
+ non_mutable_data_unique_map_view_access<Derived,Tag,BimapType>,
+ mutable_data_unique_map_view_access<Derived,Tag,BimapType>
+
+ >::type type;
+};
+
+// Map views specialize the following structs to provide to the bimap class
+// the extra side typedefs (i.e. left_local_iterator for unordered_maps,
+// right_range_type for maps)
+
+template< class MapView >
+struct left_map_view_extra_typedefs {};
+
+template< class MapView >
+struct right_map_view_extra_typedefs {};
+
+} // namespace detail
+
+// This function is already part of Boost.Lambda.
+// They may be moved to Boost.Utility.
+
+template <class T> inline const T& make_const(const T& t) { return t; }
+
+} // namespace bimaps
+} // namespace boost
+
+
+// The following macros avoids code duplication in map views
+// Maybe this can be changed in the future using a scheme similar to
+// the one used with map_view_base.
+
+/*===========================================================================*/
+#define BOOST_BIMAP_MAP_VIEW_RANGE_IMPLEMENTATION(BASE) \
+ \
+typedef std::pair< \
+ BOOST_DEDUCED_TYPENAME base_::iterator, \
+ BOOST_DEDUCED_TYPENAME base_::iterator> range_type; \
+ \
+typedef std::pair< \
+ BOOST_DEDUCED_TYPENAME base_::const_iterator, \
+ BOOST_DEDUCED_TYPENAME base_::const_iterator> const_range_type; \
+ \
+ \
+template< class LowerBounder, class UpperBounder> \
+range_type range(LowerBounder lower,UpperBounder upper) \
+{ \
+ std::pair< \
+ \
+ BOOST_DEDUCED_TYPENAME BASE::base_type::iterator, \
+ BOOST_DEDUCED_TYPENAME BASE::base_type::iterator \
+ \
+ > r( this->base().range(lower,upper) ); \
+ \
+ return range_type( \
+ this->template functor< \
+ BOOST_DEDUCED_TYPENAME BASE::iterator_from_base \
+ >() ( r.first ), \
+ this->template functor< \
+ BOOST_DEDUCED_TYPENAME BASE::iterator_from_base \
+ >() ( r.second ) \
+ ); \
+} \
+ \
+template< class LowerBounder, class UpperBounder> \
+const_range_type range(LowerBounder lower,UpperBounder upper) const \
+{ \
+ std::pair< \
+ \
+ BOOST_DEDUCED_TYPENAME BASE::base_type::const_iterator, \
+ BOOST_DEDUCED_TYPENAME BASE::base_type::const_iterator \
+ \
+ > r( this->base().range(lower,upper) ); \
+ \
+ return const_range_type( \
+ this->template functor< \
+ BOOST_DEDUCED_TYPENAME BASE::iterator_from_base \
+ >() ( r.first ), \
+ this->template functor< \
+ BOOST_DEDUCED_TYPENAME BASE::iterator_from_base \
+ >() ( r.second ) \
+ ); \
+}
+/*===========================================================================*/
+
+
+/*===========================================================================*/
+#define BOOST_BIMAP_VIEW_ASSIGN_IMPLEMENTATION(BASE) \
+ \
+template< class InputIterator > \
+void assign(InputIterator first,InputIterator last) \
+{ \
+ this->clear(); \
+ this->insert(this->end(),first,last); \
+} \
+ \
+void assign(BOOST_DEDUCED_TYPENAME BASE::size_type n, \
+ const BOOST_DEDUCED_TYPENAME BASE::value_type& v) \
+{ \
+ this->clear(); \
+ for(BOOST_DEDUCED_TYPENAME BASE::size_type i = 0 ; i < n ; ++n) \
+ { \
+ this->push_back(v); \
+ } \
+}
+/*===========================================================================*/
+
+
+/*===========================================================================*/
+#define BOOST_BIMAP_VIEW_FRONT_BACK_IMPLEMENTATION(BASE) \
+ \
+BOOST_DEDUCED_TYPENAME BASE::reference front() \
+{ \
+ return this->template functor< \
+ BOOST_DEDUCED_TYPENAME base_::value_from_base>() \
+ ( \
+ const_cast \
+ < \
+ BOOST_DEDUCED_TYPENAME BASE::base_type::value_type & \
+ \
+ > ( this->base().front() ) \
+ ); \
+} \
+ \
+BOOST_DEDUCED_TYPENAME BASE::reference back() \
+{ \
+ return this->template functor< \
+ BOOST_DEDUCED_TYPENAME base_::value_from_base>() \
+ ( \
+ const_cast \
+ < \
+ BOOST_DEDUCED_TYPENAME BASE::base_type::value_type & \
+ \
+ >( this->base().back() ) \
+ ); \
+} \
+ \
+BOOST_DEDUCED_TYPENAME BASE::const_reference front() const \
+{ \
+ return this->template functor< \
+ BOOST_DEDUCED_TYPENAME BASE::value_from_base>() \
+ ( \
+ this->base().front() \
+ ); \
+} \
+ \
+BOOST_DEDUCED_TYPENAME BASE::const_reference back() const \
+{ \
+ return this->template functor< \
+ BOOST_DEDUCED_TYPENAME BASE::value_from_base>() \
+ ( \
+ this->base().back() \
+ ); \
+}
+/*===========================================================================*/
+
+
+#endif // BOOST_BIMAP_DETAIL_MAP_VIEW_BASE_HPP
diff --git a/boost/bimap/detail/map_view_iterator.hpp b/boost/bimap/detail/map_view_iterator.hpp
new file mode 100644
index 0000000..adc8d7c
--- /dev/null
+++ b/boost/bimap/detail/map_view_iterator.hpp
@@ -0,0 +1,200 @@
+// 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 detail/map_view_iterator.hpp
+/// \brief Iterator adaptors from multi-index to bimap.
+
+#ifndef BOOST_BIMAP_DETAIL_MAP_VIEW_ITERATOR_HPP
+#define BOOST_BIMAP_DETAIL_MAP_VIEW_ITERATOR_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER>=1200)
+#pragma once
+#endif
+
+#include <boost/config.hpp>
+
+// Boost
+#include <boost/serialization/nvp.hpp>
+#include <boost/iterator/detail/enable_if.hpp>
+#include <boost/iterator/iterator_adaptor.hpp>
+#include <boost/bimap/relation/support/pair_by.hpp>
+
+namespace boost {
+namespace bimaps {
+namespace detail {
+
+#ifndef BOOST_BIMAP_DOXYGEN_WILL_NOT_PROCESS_THE_FOLLOWING_LINES
+
+template< class Tag, class Relation, class CoreIterator > struct map_view_iterator;
+
+template< class Tag, class Relation, class CoreIterator >
+struct map_view_iterator_base
+{
+ typedef iterator_adaptor
+ <
+ map_view_iterator< Tag, Relation, CoreIterator >,
+ CoreIterator,
+ BOOST_DEDUCED_TYPENAME ::boost::bimaps::relation::support::
+ pair_type_by<Tag,Relation>::type
+
+ > type;
+};
+
+#endif // BOOST_BIMAP_DOXYGEN_WILL_NOT_PROCESS_THE_FOLLOWING_LINES
+
+/** \brief Map View Iterator adaptor from multi index to bimap.
+
+This is class is based on transform iterator from Boost.Iterator that is
+modified to allow serialization. It has been specialized for this
+library, and EBO optimization was applied to the functor.
+
+ **/
+
+template< class Tag, class Relation, class CoreIterator >
+struct map_view_iterator : public map_view_iterator_base<Tag,Relation,CoreIterator>::type
+{
+ typedef BOOST_DEDUCED_TYPENAME
+ map_view_iterator_base<Tag,Relation,CoreIterator>::type base_;
+
+ public:
+
+ map_view_iterator() {}
+
+ map_view_iterator(CoreIterator const& iter)
+ : base_(iter) {}
+
+ map_view_iterator(map_view_iterator const & iter)
+ : base_(iter.base()) {}
+
+ BOOST_DEDUCED_TYPENAME base_::reference dereference() const
+ {
+ return ::boost::bimaps::relation::support::pair_by<Tag>(
+ *const_cast<BOOST_DEDUCED_TYPENAME base_::base_type::value_type*>(
+ &(*this->base())
+ )
+ );
+ }
+
+ private:
+
+ friend class iterator_core_access;
+
+ #ifndef BOOST_BIMAP_DISABLE_SERIALIZATION
+
+ // Serialization support
+
+ BOOST_SERIALIZATION_SPLIT_MEMBER()
+
+ friend class ::boost::serialization::access;
+
+ template< class Archive >
+ void save(Archive & ar, const unsigned int version) const
+ {
+ ar << ::boost::serialization::make_nvp("mi_iterator",this->base());
+ }
+
+ template< class Archive >
+ void load(Archive & ar, const unsigned int version)
+ {
+ CoreIterator iter;
+ ar >> ::boost::serialization::make_nvp("mi_iterator",iter);
+ this->base_reference() = iter;
+ }
+
+ #endif // BOOST_BIMAP_DISABLE_SERIALIZATION
+};
+
+
+#ifndef BOOST_BIMAP_DOXYGEN_WILL_NOT_PROCESS_THE_FOLLOWING_LINES
+
+template< class Tag, class Relation, class CoreIterator > struct const_map_view_iterator;
+
+template< class Tag, class Relation, class CoreIterator >
+struct const_map_view_iterator_base
+{
+ typedef iterator_adaptor
+ <
+ const_map_view_iterator< Tag, Relation, CoreIterator >,
+ CoreIterator,
+ const BOOST_DEDUCED_TYPENAME ::boost::bimaps::relation::support::
+ pair_type_by<Tag,Relation>::type
+
+ > type;
+};
+
+#endif // BOOST_BIMAP_DOXYGEN_WILL_NOT_PROCESS_THE_FOLLOWING_LINES
+
+
+/** \brief Const Map View Iterator adaptor from multi index to bimap.
+
+See also map_view_iterator.
+ **/
+
+template< class Tag, class Relation, class CoreIterator >
+struct const_map_view_iterator :
+
+ public const_map_view_iterator_base<Tag,Relation,CoreIterator>::type
+{
+ typedef BOOST_DEDUCED_TYPENAME
+ const_map_view_iterator_base<Tag,Relation,CoreIterator>::type base_;
+
+ public:
+
+ const_map_view_iterator() {}
+
+ const_map_view_iterator(CoreIterator const& iter)
+ : base_(iter) {}
+
+ const_map_view_iterator(const_map_view_iterator const & iter)
+ : base_(iter.base()) {}
+
+ const_map_view_iterator(map_view_iterator<Tag,Relation,CoreIterator> i)
+ : base_(i.base()) {}
+
+ BOOST_DEDUCED_TYPENAME base_::reference dereference() const
+ {
+ return ::boost::bimaps::relation::support::pair_by<Tag>(*this->base());
+ }
+
+ private:
+
+ friend class iterator_core_access;
+
+ #ifndef BOOST_BIMAP_DISABLE_SERIALIZATION
+
+ // Serialization support
+
+ BOOST_SERIALIZATION_SPLIT_MEMBER()
+
+ friend class ::boost::serialization::access;
+
+ template< class Archive >
+ void save(Archive & ar, const unsigned int version) const
+ {
+ ar << ::boost::serialization::make_nvp("mi_iterator",this->base());
+ }
+
+ template< class Archive >
+ void load(Archive & ar, const unsigned int version)
+ {
+ CoreIterator iter;
+ ar >> ::boost::serialization::make_nvp("mi_iterator",iter);
+ this->base_reference() = iter;
+ }
+
+ #endif // BOOST_BIMAP_DISABLE_SERIALIZATION
+};
+
+
+} // namespace detail
+} // namespace bimaps
+} // namespace boost
+
+#endif // BOOST_BIMAP_DETAIL_MAP_VIEW_ITERATOR_HPP
+
+
diff --git a/boost/bimap/detail/modifier_adaptor.hpp b/boost/bimap/detail/modifier_adaptor.hpp
new file mode 100644
index 0000000..b170549
--- /dev/null
+++ b/boost/bimap/detail/modifier_adaptor.hpp
@@ -0,0 +1,89 @@
+// 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 detail/modifier_adaptor.hpp
+/// \brief A binary to unary functor relation modifier adaptor.
+
+#ifndef BOOST_BIMAP_DETAIL_MODIFIER_ADAPTOR_HPP
+#define BOOST_BIMAP_DETAIL_MODIFIER_ADAPTOR_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER>=1200)
+#pragma once
+#endif
+
+#include <boost/config.hpp>
+
+#include <functional>
+
+namespace boost {
+namespace bimaps {
+namespace detail {
+
+/// \brief A binary to unary functor relation modifier adaptor.
+
+template
+<
+ class Modifier,
+ class NewArgument,
+ class FirstExtractor,
+ class SecondExtractor
+>
+struct relation_modifier_adaptor :
+ public std::unary_function<NewArgument,bool>,
+ Modifier,
+ FirstExtractor,
+ SecondExtractor
+{
+ relation_modifier_adaptor( const Modifier & m ) : Modifier(m) {}
+ relation_modifier_adaptor( const Modifier & m,
+ const FirstExtractor & fe,
+ const SecondExtractor & se ) :
+ Modifier(m), FirstExtractor(fe), SecondExtractor(se) {}
+
+ void operator()( NewArgument & x ) const
+ {
+ Modifier::operator()(
+ FirstExtractor ::operator()( x ),
+ SecondExtractor::operator()( x )
+ );
+ }
+};
+
+/// \brief A simple unary modifier adaptor.
+// This modifier is equivalent to bind( Modifier, bind( Extractor, _1 ) )
+// It may be a good idea to start using Boost.Bind instead of it.
+
+template
+<
+ class Modifier,
+ class NewArgument,
+ class Extractor
+>
+struct unary_modifier_adaptor :
+ public std::unary_function<NewArgument,bool>,
+ Modifier,
+ Extractor
+{
+ unary_modifier_adaptor( const Modifier & m ) : Modifier(m) {}
+ unary_modifier_adaptor( const Modifier & m,
+ const Extractor & fe) :
+ Modifier(m), Extractor(fe) {}
+
+ void operator()( NewArgument & x ) const
+ {
+ Modifier::operator()( Extractor::operator()( x ) );
+ }
+};
+
+
+} // namespace detail
+} // namespace bimap
+} // namespace boost
+
+
+#endif // BOOST_BIMAP_DETAIL_MODIFIER_ADAPTOR_HPP
diff --git a/boost/bimap/detail/non_unique_views_helper.hpp b/boost/bimap/detail/non_unique_views_helper.hpp
new file mode 100644
index 0000000..6801632
--- /dev/null
+++ b/boost/bimap/detail/non_unique_views_helper.hpp
@@ -0,0 +1,71 @@
+// 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 detail/non_unique_views_helper.hpp
+/// \brief Details for non unique views
+
+#ifndef BOOST_BIMAP_DETAIL_NON_UNIQUE_VIEWS_HELPER_HPP
+#define BOOST_BIMAP_DETAIL_NON_UNIQUE_VIEWS_HELPER_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER>=1200)
+#pragma once
+#endif
+
+#include <boost/config.hpp>
+
+/*===========================================================================*/
+#define BOOST_BIMAP_NON_UNIQUE_VIEW_INSERT_FUNCTIONS \
+ \
+template <class InputIterator> \
+void insert(InputIterator iterBegin, InputIterator iterEnd) \
+{ \
+ for( ; iterBegin != iterEnd ; ++iterBegin ) \
+ { \
+ this->base().insert( \
+ this->template functor< \
+ BOOST_DEDUCED_TYPENAME base_::value_to_base>()( \
+ BOOST_DEDUCED_TYPENAME base_::value_type(*iterBegin)) ); \
+ } \
+} \
+ \
+std::pair<BOOST_DEDUCED_TYPENAME base_::iterator, bool> insert( \
+ BOOST_DEDUCED_TYPENAME ::boost::call_traits< \
+ BOOST_DEDUCED_TYPENAME base_::value_type >::param_type x) \
+{ \
+ typedef BOOST_DEDUCED_TYPENAME base_::base_type::iterator base_iterator; \
+ \
+ std::pair< base_iterator, bool > r( \
+ this->base().insert( \
+ this->template functor< \
+ BOOST_DEDUCED_TYPENAME base_::value_to_base>()(x) ) \
+ ); \
+ \
+ return std::pair<typename base_::iterator, bool>( \
+ this->template functor< \
+ BOOST_DEDUCED_TYPENAME base_::iterator_from_base>()(r.first), \
+ r.second \
+ ); \
+} \
+ \
+BOOST_DEDUCED_TYPENAME base_::iterator insert( \
+ BOOST_DEDUCED_TYPENAME base_::iterator pos, \
+ BOOST_DEDUCED_TYPENAME ::boost::call_traits< \
+ BOOST_DEDUCED_TYPENAME base_::value_type >::param_type x) \
+{ \
+ return this->template functor< \
+ BOOST_DEDUCED_TYPENAME base_::iterator_from_base>()( \
+ this->base().insert( \
+ this->template functor< \
+ BOOST_DEDUCED_TYPENAME base_::iterator_to_base>()(pos), \
+ this->template functor< \
+ BOOST_DEDUCED_TYPENAME base_::value_to_base>()(x)) \
+ ); \
+}
+/*===========================================================================*/
+
+#endif // BOOST_BIMAP_DETAIL_NON_UNIQUE_VIEWS_HELPER_HPP
diff --git a/boost/bimap/detail/set_view_base.hpp b/boost/bimap/detail/set_view_base.hpp
new file mode 100644
index 0000000..7c7f0d0
--- /dev/null
+++ b/boost/bimap/detail/set_view_base.hpp
@@ -0,0 +1,331 @@
+// 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 detail/set_view_base.hpp
+/// \brief Helper base for the construction of the bimap views types.
+
+#ifndef BOOST_BIMAP_DETAIL_SET_VIEW_BASE_HPP
+#define BOOST_BIMAP_DETAIL_SET_VIEW_BASE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER>=1200)
+#pragma once
+#endif
+
+#include <boost/config.hpp>
+
+#include <boost/bimap/relation/member_at.hpp>
+#include <boost/bimap/relation/support/data_extractor.hpp>
+#include <boost/bimap/detail/modifier_adaptor.hpp>
+#include <boost/bimap/detail/set_view_iterator.hpp>
+#include <boost/bimap/relation/support/get_pair_functor.hpp>
+#include <boost/bimap/relation/detail/to_mutable_relation_functor.hpp>
+#include <boost/bimap/relation/mutant_relation.hpp>
+#include <boost/bimap/container_adaptor/support/iterator_facade_converters.hpp>
+
+namespace boost {
+namespace bimaps {
+namespace detail {
+
+template< class Key, class Value, class KeyToBase >
+class set_view_key_to_base
+{
+ public:
+ const Key operator()( const Value & v ) const
+ {
+ return keyToBase( v );
+ }
+ private:
+ KeyToBase keyToBase;
+};
+
+template< class MutantRelationStorage, class KeyToBase >
+class set_view_key_to_base<MutantRelationStorage,MutantRelationStorage,KeyToBase>
+{
+ typedef BOOST_DEDUCED_TYPENAME MutantRelationStorage::non_mutable_storage non_mutable_storage;
+ public:
+ const MutantRelationStorage & operator()( const non_mutable_storage & k ) const
+ {
+ return ::boost::bimaps::relation::detail::mutate<MutantRelationStorage>(k);
+ }
+ const MutantRelationStorage & operator()( const MutantRelationStorage & k ) const
+ {
+ return k;
+ }
+};
+
+
+// The next macro can be converted in a metafunctor to gain code robustness.
+/*===========================================================================*/
+#define BOOST_BIMAP_SET_VIEW_CONTAINER_ADAPTOR( \
+ CONTAINER_ADAPTOR, CORE_INDEX, OTHER_ITER, CONST_OTHER_ITER \
+) \
+::boost::bimaps::container_adaptor::CONTAINER_ADAPTOR \
+< \
+ CORE_INDEX, \
+ ::boost::bimaps::detail:: \
+ set_view_iterator< \
+ BOOST_DEDUCED_TYPENAME CORE_INDEX::iterator >, \
+ ::boost::bimaps::detail:: \
+ const_set_view_iterator< \
+ BOOST_DEDUCED_TYPENAME CORE_INDEX::const_iterator >, \
+ ::boost::bimaps::detail:: \
+ set_view_iterator< \
+ BOOST_DEDUCED_TYPENAME CORE_INDEX::OTHER_ITER >, \
+ ::boost::bimaps::detail:: \
+ const_set_view_iterator< \
+ BOOST_DEDUCED_TYPENAME CORE_INDEX::CONST_OTHER_ITER >, \
+ ::boost::bimaps::container_adaptor::support::iterator_facade_to_base \
+ < \
+ ::boost::bimaps::detail:: set_view_iterator< \
+ BOOST_DEDUCED_TYPENAME CORE_INDEX::iterator>, \
+ ::boost::bimaps::detail::const_set_view_iterator< \
+ BOOST_DEDUCED_TYPENAME CORE_INDEX::const_iterator> \
+ \
+ >, \
+ ::boost::mpl::na, \
+ ::boost::mpl::na, \
+ ::boost::bimaps::relation::detail:: \
+ get_mutable_relation_functor< \
+ BOOST_DEDUCED_TYPENAME CORE_INDEX::value_type >, \
+ ::boost::bimaps::relation::support:: \
+ get_above_view_functor< \
+ BOOST_DEDUCED_TYPENAME CORE_INDEX::value_type >, \
+ ::boost::bimaps::detail::set_view_key_to_base< \
+ BOOST_DEDUCED_TYPENAME CORE_INDEX::key_type, \
+ BOOST_DEDUCED_TYPENAME CORE_INDEX::value_type, \
+ BOOST_DEDUCED_TYPENAME CORE_INDEX::key_from_value \
+ > \
+>
+/*===========================================================================*/
+
+
+/*===========================================================================*/
+#define BOOST_BIMAP_SEQUENCED_SET_VIEW_CONTAINER_ADAPTOR( \
+ CONTAINER_ADAPTOR, CORE_INDEX, OTHER_ITER, CONST_OTHER_ITER \
+) \
+::boost::bimaps::container_adaptor::CONTAINER_ADAPTOR \
+< \
+ CORE_INDEX, \
+ ::boost::bimaps::detail:: \
+ set_view_iterator< \
+ BOOST_DEDUCED_TYPENAME CORE_INDEX::iterator >, \
+ ::boost::bimaps::detail:: \
+ const_set_view_iterator< \
+ BOOST_DEDUCED_TYPENAME CORE_INDEX::const_iterator >, \
+ ::boost::bimaps::detail:: \
+ set_view_iterator< \
+ BOOST_DEDUCED_TYPENAME CORE_INDEX::OTHER_ITER >, \
+ ::boost::bimaps::detail:: \
+ const_set_view_iterator< \
+ BOOST_DEDUCED_TYPENAME CORE_INDEX::CONST_OTHER_ITER >, \
+ ::boost::bimaps::container_adaptor::support::iterator_facade_to_base \
+ < \
+ ::boost::bimaps::detail:: set_view_iterator< \
+ BOOST_DEDUCED_TYPENAME CORE_INDEX::iterator>, \
+ ::boost::bimaps::detail::const_set_view_iterator< \
+ BOOST_DEDUCED_TYPENAME CORE_INDEX::const_iterator> \
+ \
+ >, \
+ ::boost::mpl::na, \
+ ::boost::mpl::na, \
+ ::boost::bimaps::relation::detail:: \
+ get_mutable_relation_functor< \
+ BOOST_DEDUCED_TYPENAME CORE_INDEX::value_type >, \
+ ::boost::bimaps::relation::support:: \
+ get_above_view_functor< \
+ BOOST_DEDUCED_TYPENAME CORE_INDEX::value_type > \
+>
+/*===========================================================================*/
+
+
+#if defined(BOOST_MSVC)
+/*===========================================================================*/
+#define BOOST_BIMAP_SET_VIEW_BASE_FRIEND(TYPE,INDEX_TYPE) \
+ typedef ::boost::bimaps::detail::set_view_base< \
+ TYPE< INDEX_TYPE >, INDEX_TYPE > template_class_friend; \
+ friend class template_class_friend;
+/*===========================================================================*/
+#else
+/*===========================================================================*/
+#define BOOST_BIMAP_SET_VIEW_BASE_FRIEND(TYPE,INDEX_TYPE) \
+ friend class ::boost::bimaps::detail::set_view_base< \
+ TYPE< INDEX_TYPE >, INDEX_TYPE >;
+/*===========================================================================*/
+#endif
+
+
+/// \brief Common base for set views.
+
+template< class Derived, class Index >
+class set_view_base
+{
+ typedef ::boost::bimaps::container_adaptor::support::
+ iterator_facade_to_base
+ <
+ ::boost::bimaps::detail::
+ set_view_iterator<BOOST_DEDUCED_TYPENAME Index:: iterator>,
+ ::boost::bimaps::detail::
+ const_set_view_iterator<BOOST_DEDUCED_TYPENAME Index::const_iterator>
+
+ > iterator_to_base_;
+
+ typedef BOOST_DEDUCED_TYPENAME Index::value_type::left_value_type left_type_;
+
+ typedef BOOST_DEDUCED_TYPENAME Index::value_type::right_value_type right_type_;
+
+ typedef BOOST_DEDUCED_TYPENAME Index::value_type value_type_;
+
+ typedef ::boost::bimaps::detail::
+ set_view_iterator<BOOST_DEDUCED_TYPENAME Index::iterator> iterator_;
+
+ public:
+
+ bool replace(iterator_ position,
+ const value_type_ & x)
+ {
+ return derived().base().replace(
+ derived().template functor<iterator_to_base_>()(position),x
+ );
+ }
+
+ template< class CompatibleLeftType >
+ bool replace_left(iterator_ position,
+ const CompatibleLeftType & l)
+ {
+ return derived().base().replace(
+ derived().template functor<iterator_to_base_>()(position),
+ value_type_(l,position->right)
+ );
+ }
+
+ template< class CompatibleRightType >
+ bool replace_right(iterator_ position,
+ const CompatibleRightType & r)
+ {
+ return derived().base().replace(
+ derived().template functor<iterator_to_base_>()(position),
+ value_type_(position->left,r)
+ );
+ }
+
+ /* This function may be provided in the future
+
+ template< class Modifier >
+ bool modify(iterator_ position,
+ Modifier mod)
+ {
+ return derived().base().modify(
+
+ derived().template functor<iterator_to_base_>()(position),
+
+ ::boost::bimaps::detail::relation_modifier_adaptor
+ <
+ Modifier,
+ BOOST_DEDUCED_TYPENAME Index::value_type,
+ BOOST_DEDUCED_TYPENAME ::boost::bimaps::relation::support::
+ data_extractor
+ <
+ ::boost::bimaps::relation::member_at::left,
+ BOOST_DEDUCED_TYPENAME Index::value_type
+
+ >::type,
+ BOOST_DEDUCED_TYPENAME ::boost::bimaps::relation::support::
+ data_extractor
+ <
+ ::boost::bimaps::relation::member_at::right,
+ BOOST_DEDUCED_TYPENAME Index::value_type
+
+ >::type
+
+ >(mod)
+ );
+ }
+ */
+ /*
+ template< class Modifier >
+ bool modify_left(iterator_ position, Modifier mod)
+ {
+ typedef BOOST_DEDUCED_TYPENAME ::boost::bimaps::relation::support::
+ data_extractor
+ <
+ BOOST_DEDUCED_TYPENAME ::boost::bimaps::relation::member_at::right,
+ BOOST_DEDUCED_TYPENAME Index::value_type
+
+ >::type left_data_extractor_;
+
+ return derived().base().modify(
+
+ derived().template functor<iterator_to_base_>()(position),
+
+ // this may be replaced later by
+ // ::boost::bind( mod, ::boost::bind(data_extractor_(),_1) )
+
+ ::boost::bimaps::detail::unary_modifier_adaptor
+ <
+ Modifier,
+ BOOST_DEDUCED_TYPENAME Index::value_type,
+ left_data_extractor_
+
+ >(mod)
+ );
+ }
+
+ template< class Modifier >
+ bool modify_right(iterator_ position, Modifier mod)
+ {
+ typedef BOOST_DEDUCED_TYPENAME ::boost::bimaps::relation::support::
+ data_extractor
+ <
+ BOOST_DEDUCED_TYPENAME ::boost::bimaps::relation::member_at::right,
+ BOOST_DEDUCED_TYPENAME Index::value_type
+
+ >::type right_data_extractor_;
+
+ return derived().base().modify(
+
+ derived().template functor<iterator_to_base_>()(position),
+
+ // this may be replaced later by
+ // ::boost::bind( mod, ::boost::bind(data_extractor_(),_1) )
+
+ ::boost::bimaps::detail::unary_modifier_adaptor
+ <
+ Modifier,
+ BOOST_DEDUCED_TYPENAME Index::value_type,
+ right_data_extractor_
+
+ >(mod)
+ );
+ }
+ */
+ protected:
+
+ typedef set_view_base set_view_base_;
+
+ private:
+
+ // Curiously Recurring Template interface.
+
+ Derived& derived()
+ {
+ return *static_cast<Derived*>(this);
+ }
+
+ Derived const& derived() const
+ {
+ return *static_cast<Derived const*>(this);
+ }
+};
+
+
+
+} // namespace detail
+} // namespace bimaps
+} // namespace boost
+
+#endif // BOOST_BIMAP_DETAIL_SET_VIEW_BASE_HPP
diff --git a/boost/bimap/detail/set_view_iterator.hpp b/boost/bimap/detail/set_view_iterator.hpp
new file mode 100644
index 0000000..57e6ae3
--- /dev/null
+++ b/boost/bimap/detail/set_view_iterator.hpp
@@ -0,0 +1,193 @@
+// 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 detail/set_view_iterator.hpp
+/// \brief Iterator adaptors from multi-index to bimap.
+
+#ifndef BOOST_BIMAP_DETAIL_SET_VIEW_ITERATOR_HPP
+#define BOOST_BIMAP_DETAIL_SET_VIEW_ITERATOR_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER>=1200)
+#pragma once
+#endif
+
+#include <boost/config.hpp>
+
+// Boost
+#include <boost/serialization/nvp.hpp>
+#include <boost/iterator/detail/enable_if.hpp>
+#include <boost/iterator/iterator_adaptor.hpp>
+#include <boost/bimap/relation/support/get_pair_functor.hpp>
+
+namespace boost {
+namespace bimaps {
+namespace detail {
+
+
+/** \brief Set View Iterator adaptor from multi index to bimap.
+
+This is class is based on transform iterator from Boost.Iterator that is
+modified to allow serialization. It has been specialized for this
+library, and EBO optimization was applied to the functor.
+
+ **/
+
+#ifndef BOOST_BIMAP_DOXYGEN_WILL_NOT_PROCESS_THE_FOLLOWING_LINES
+
+template< class CoreIterator > struct set_view_iterator;
+
+template< class CoreIterator >
+struct set_view_iterator_base
+{
+ typedef iterator_adaptor
+ <
+ set_view_iterator< CoreIterator >,
+ CoreIterator,
+ BOOST_DEDUCED_TYPENAME CoreIterator::value_type::above_view
+
+ > type;
+};
+
+#endif // BOOST_BIMAP_DOXYGEN_WILL_NOT_PROCESS_THE_FOLLOWING_LINES
+
+template< class CoreIterator >
+struct set_view_iterator : public set_view_iterator_base<CoreIterator>::type
+{
+ typedef BOOST_DEDUCED_TYPENAME set_view_iterator_base<CoreIterator>::type base_;
+
+ public:
+
+ set_view_iterator() {}
+
+ set_view_iterator(CoreIterator const& iter)
+ : base_(iter) {}
+
+ set_view_iterator(set_view_iterator const & iter)
+ : base_(iter.base()) {}
+
+ typename base_::reference dereference() const
+ {
+ return const_cast<
+ BOOST_DEDUCED_TYPENAME base_::base_type::value_type*>(
+ &(*this->base())
+ )->get_view();
+ }
+
+ private:
+
+ friend class iterator_core_access;
+
+ #ifndef BOOST_BIMAP_DISABLE_SERIALIZATION
+
+ // Serialization support
+
+ BOOST_SERIALIZATION_SPLIT_MEMBER()
+
+ friend class ::boost::serialization::access;
+
+ template< class Archive >
+ void save(Archive & ar, const unsigned int version) const
+ {
+ ar << ::boost::serialization::make_nvp("mi_iterator",this->base());
+ }
+
+ template< class Archive >
+ void load(Archive & ar, const unsigned int version)
+ {
+ CoreIterator iter;
+ ar >> ::boost::serialization::make_nvp("mi_iterator",iter);
+ this->base_reference() = iter;
+ }
+
+ #endif // BOOST_BIMAP_DISABLE_SERIALIZATION
+};
+
+#ifndef BOOST_BIMAP_DOXYGEN_WILL_NOT_PROCESS_THE_FOLLOWING_LINES
+
+template< class CoreIterator > struct const_set_view_iterator;
+
+template< class CoreIterator >
+struct const_set_view_iterator_base
+{
+ typedef iterator_adaptor
+ <
+ const_set_view_iterator< CoreIterator >,
+ CoreIterator,
+ const BOOST_DEDUCED_TYPENAME CoreIterator::value_type::above_view
+
+ > type;
+};
+
+#endif // BOOST_BIMAP_DOXYGEN_WILL_NOT_PROCESS_THE_FOLLOWING_LINES
+
+
+/** \brief Const Set View Iterator adaptor from multi index to bimap.
+
+See also set_view_iterator.
+ **/
+
+template< class CoreIterator >
+struct const_set_view_iterator : public const_set_view_iterator_base<CoreIterator>::type
+{
+ typedef BOOST_DEDUCED_TYPENAME const_set_view_iterator_base<CoreIterator>::type base_;
+
+ public:
+
+ const_set_view_iterator() {}
+
+ const_set_view_iterator(CoreIterator const& iter)
+ : base_(iter) {}
+
+ const_set_view_iterator(const_set_view_iterator const & iter)
+ : base_(iter.base()) {}
+
+ const_set_view_iterator(set_view_iterator<CoreIterator> i)
+ : base_(i.base()) {}
+
+ BOOST_DEDUCED_TYPENAME base_::reference dereference() const
+ {
+ return this->base()->get_view();
+ }
+
+ private:
+
+ friend class iterator_core_access;
+
+ #ifndef BOOST_BIMAP_DISABLE_SERIALIZATION
+
+ // Serialization support
+
+ BOOST_SERIALIZATION_SPLIT_MEMBER()
+
+ friend class ::boost::serialization::access;
+
+ template< class Archive >
+ void save(Archive & ar, const unsigned int version) const
+ {
+ ar << ::boost::serialization::make_nvp("mi_iterator",this->base());
+ }
+
+ template< class Archive >
+ void load(Archive & ar, const unsigned int version)
+ {
+ CoreIterator iter;
+ ar >> ::boost::serialization::make_nvp("mi_iterator",iter);
+ this->base_reference() = iter;
+ }
+
+ #endif // BOOST_BIMAP_DISABLE_SERIALIZATION
+};
+
+
+} // namespace detail
+} // namespace bimaps
+} // namespace boost
+
+#endif // BOOST_BIMAP_DETAIL_MAP_VIEW_ITERATOR_HPP
+
+
diff --git a/boost/bimap/detail/test/check_metadata.hpp b/boost/bimap/detail/test/check_metadata.hpp
new file mode 100644
index 0000000..b669ee0
--- /dev/null
+++ b/boost/bimap/detail/test/check_metadata.hpp
@@ -0,0 +1,113 @@
+// 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)
+
+#ifndef BOOST_BIMAP_DETAIL_CHECK_METADATA_HPP
+#define BOOST_BIMAP_DETAIL_CHECK_METADATA_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER>=1200)
+#pragma once
+#endif
+
+#include <boost/config.hpp>
+
+#include <boost/mpl/assert.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/preprocessor/cat.hpp>
+
+
+// Easier way to call BOOST_MPL_ASSERT_MSG in class scope
+/*===========================================================================*/
+#define BOOST_BIMAP_MPL_ASSERT_MSG_ACS(p1,p2,p3) \
+ \
+ struct p2 {}; \
+ BOOST_MPL_ASSERT_MSG(p1,p2,p3); \
+/*===========================================================================*/
+
+
+// Build a descriptive name.
+/*===========================================================================*/
+#define BOOST_BIMAP_WRONG_METADATA_MESSAGE( \
+ \
+ P_CLASS, \
+ P_NAME, \
+ P_CORRECT_TYPE \
+ \
+ ) \
+ \
+ BOOST_PP_CAT \
+ ( \
+ WRONG_METADATA__, \
+ BOOST_PP_CAT \
+ ( \
+ P_CLASS, \
+ BOOST_PP_CAT \
+ ( \
+ __AT__, \
+ BOOST_PP_CAT \
+ ( \
+ P_NAME, \
+ BOOST_PP_CAT \
+ ( \
+ __IS_DIFERENT_TO__, \
+ P_CORRECT_TYPE \
+ ) \
+ ) \
+ ) \
+ ) \
+ )
+/*===========================================================================*/
+
+
+// Check if the metadata have the correct type, and if not inform
+// it with a useful compile time message.
+/*===========================================================================*/
+#define BOOST_BIMAP_CHECK_METADATA( \
+ \
+ P_CLASS, \
+ P_NAME, \
+ P_CORRECT_TYPE \
+ \
+ ) \
+ \
+ BOOST_BIMAP_MPL_ASSERT_MSG_ACS \
+ ( \
+ ( \
+ ::boost::is_same \
+ < \
+ P_CLASS::P_NAME, \
+ P_CORRECT_TYPE \
+ \
+ >::value \
+ ), \
+ BOOST_BIMAP_WRONG_METADATA_MESSAGE \
+ ( \
+ P_CLASS, \
+ P_NAME, \
+ P_CORRECT_TYPE \
+ ), \
+ (P_CLASS::P_NAME,P_CORRECT_TYPE) \
+ )
+/*===========================================================================*/
+
+
+// Just for autodocumment the test code
+/*===========================================================================*/
+#define BOOST_BIMAP_TEST_STATIC_FUNCTION(NAME) \
+ namespace NAME
+/*===========================================================================*/
+
+
+// Just for autodocument the test code
+/*===========================================================================*/
+#define BOOST_BIMAP_CALL_TEST_STATIC_FUNCTION(NAME)
+/*===========================================================================*/
+
+
+
+#endif // BOOST_BIMAP_DETAIL_CHECK_METADATA_HPP
+
diff --git a/boost/bimap/detail/user_interface_config.hpp b/boost/bimap/detail/user_interface_config.hpp
new file mode 100644
index 0000000..1d9a8e8
--- /dev/null
+++ b/boost/bimap/detail/user_interface_config.hpp
@@ -0,0 +1,24 @@
+// 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 detail/user_interface_config.hpp
+/// \brief General configuration directives
+
+
+#ifndef BOOST_BIMAP_DETAIL_USER_INTERFACE_CONFIG_HPP
+#define BOOST_BIMAP_DETAIL_USER_INTERFACE_CONFIG_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER>=1200)
+#pragma once
+#endif
+
+#ifdef BOOST_BIMAP_DISABLE_SERIALIZATION
+ #define BOOST_MULTI_INDEX_DISABLE_SERIALIZATION
+#endif
+
+#endif // BOOST_BIMAP_DETAIL_USER_INTERFACE_CONFIG_HPP
diff --git a/boost/bimap/list_of.hpp b/boost/bimap/list_of.hpp
new file mode 100644
index 0000000..5865dd6
--- /dev/null
+++ b/boost/bimap/list_of.hpp
@@ -0,0 +1,181 @@
+// 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 list_of.hpp
+/// \brief Include support for list constrains for the bimap container
+
+#ifndef BOOST_BIMAP_LIST_OF_HPP
+#define BOOST_BIMAP_LIST_OF_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER>=1200)
+#pragma once
+#endif
+
+#include <boost/config.hpp>
+
+#include <boost/bimap/detail/user_interface_config.hpp>
+
+#include <boost/mpl/bool.hpp>
+
+#include <boost/concept_check.hpp>
+
+#include <boost/bimap/detail/concept_tags.hpp>
+
+#include <boost/bimap/tags/support/value_type_of.hpp>
+
+#include <boost/bimap/detail/generate_index_binder.hpp>
+#include <boost/bimap/detail/generate_view_binder.hpp>
+#include <boost/bimap/detail/generate_relation_binder.hpp>
+
+#include <boost/multi_index/sequenced_index.hpp>
+
+#include <boost/bimap/views/list_map_view.hpp>
+#include <boost/bimap/views/list_set_view.hpp>
+
+namespace boost {
+namespace bimaps {
+
+
+/// \brief Set Type Specification
+/**
+This struct is used to specify a set specification.
+It is not a container, it is just a metaprogramming facility to
+express the type of a set. Generally, this specification will
+be used in other place to create a container.
+It has the same syntax that an std::list instantiation, except
+that the allocator cannot be specified. The rationale behind
+this difference is that the allocator is not part of the set
+type specification, rather it is a container configuration
+parameter.
+
+\code
+using namespace support;
+
+BOOST_STATIC_ASSERT( is_set_type_of< list_of<Type> >::value )
+
+BOOST_STATIC_ASSERT
+(
+ is_same
+ <
+ list_of<Type>::index_bind
+ <
+ KeyExtractor,
+ Tag
+
+ >::type,
+
+ sequenced< tag<Tag>, KeyExtractor >
+
+ >::value
+)
+
+typedef bimap
+<
+ list_of<Type>, RightKeyType
+
+> bimap_with_left_type_as_list;
+
+BOOST_STATIC_ASSERT
+(
+ is_same
+ <
+ list_of<Type>::map_view_bind
+ <
+ member_at::left,
+ bimap_with_left_type_as_list
+
+ >::type,
+ list_map_view< member_at::left, bimap_with_left_type_as_list >
+
+ >::value
+)
+
+\endcode
+
+See also list_of_relation.
+ **/
+
+template< class Type >
+struct list_of : public ::boost::bimaps::detail::set_type_of_tag
+{
+ /// User type, can be tagged
+ typedef Type user_type;
+
+ /// Type of the object that will be stored in the list
+ typedef BOOST_DEDUCED_TYPENAME ::boost::bimaps::tags::support::
+ value_type_of<user_type>::type value_type;
+
+
+ struct lazy_concept_checked
+ {
+ BOOST_CLASS_REQUIRE ( value_type,
+ boost, AssignableConcept );
+
+ typedef list_of type;
+ };
+
+ BOOST_BIMAP_GENERATE_INDEX_BINDER_0CP_NO_EXTRACTOR(
+
+ // binds to
+ multi_index::sequenced
+ )
+
+ BOOST_BIMAP_GENERATE_MAP_VIEW_BINDER(
+
+ // binds to
+ views::list_map_view
+ )
+
+ BOOST_BIMAP_GENERATE_SET_VIEW_BINDER(
+
+ // binds to
+ views::list_set_view
+ )
+
+ typedef mpl::bool_<true> mutable_key;
+};
+
+
+/// \brief List Of Relation Specification
+/**
+This struct is similar to list_of but it is bind logically to a
+relation. It is used in the bimap instantiation to specify the
+desired type of the main view. This struct implements internally
+a metafunction named bind_to that manages the quite complicated
+task of finding the right type of the set for the relation.
+
+\code
+template<class Relation>
+struct bind_to
+{
+ typedef -unspecified- type;
+};
+\endcode
+
+See also list_of, is_set_type_of_relation.
+ **/
+
+struct list_of_relation : public ::boost::bimaps::detail::set_type_of_relation_tag
+{
+ BOOST_BIMAP_GENERATE_RELATION_BINDER_0CP(
+
+ // binds to
+ list_of
+ )
+
+ typedef mpl::bool_<true> left_mutable_key;
+ typedef mpl::bool_<true> right_mutable_key;
+};
+
+
+} // namespace bimaps
+} // namespace boost
+
+
+#endif // BOOST_BIMAP_LIST_OF_HPP
+
diff --git a/boost/bimap/multiset_of.hpp b/boost/bimap/multiset_of.hpp
new file mode 100644
index 0000000..656cf48
--- /dev/null
+++ b/boost/bimap/multiset_of.hpp
@@ -0,0 +1,205 @@
+// 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 multiset_of.hpp
+/// \brief Include support for multiset constrains for the bimap container
+
+#ifndef BOOST_BIMAP_MULTISET_OF_HPP
+#define BOOST_BIMAP_MULTISET_OF_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER>=1200)
+#pragma once
+#endif
+
+#include <boost/config.hpp>
+
+#include <boost/bimap/detail/user_interface_config.hpp>
+
+#include <functional>
+#include <boost/mpl/bool.hpp>
+
+#include <boost/concept_check.hpp>
+
+#include <boost/bimap/detail/concept_tags.hpp>
+
+#include <boost/bimap/tags/support/value_type_of.hpp>
+
+#include <boost/bimap/detail/generate_index_binder.hpp>
+#include <boost/bimap/detail/generate_view_binder.hpp>
+#include <boost/bimap/detail/generate_relation_binder.hpp>
+
+#include <boost/multi_index/ordered_index.hpp>
+
+#include <boost/bimap/views/multimap_view.hpp>
+#include <boost/bimap/views/multiset_view.hpp>
+
+namespace boost {
+namespace bimaps {
+
+/// \brief Set Type Specification
+/**
+This struct is used to specify a multiset specification.
+It is not a container, it is just a metaprogramming facility to
+express the type of a set. Generally, this specification will
+be used in other place to create a container.
+It has the same syntax that an std::set instantiation, except
+that the allocator cannot be specified. The rationale behind
+this difference is that the allocator is not part of the set
+type specification, rather it is a container configuration
+parameter.
+The first parameter is the type of the objects in the multiset,
+and the second one is a Functor that compares them.
+Bimap binding metafunctions can be used with this class in
+the following way:
+
+\code
+using namespace support;
+
+BOOST_STATIC_ASSERT( is_set_type_of< multiset_of<Type> >::value )
+
+BOOST_STATIC_ASSERT
+(
+ is_same
+ <
+ compute_index_type
+ <
+ multiset_of<Type,KeyCompare>,
+ KeyExtractor,
+ Tag
+
+ >::type
+ ,
+ ordered_nonunique< tag<Tag>, KeyExtractor, KeyCompare >
+
+ >::value
+)
+
+typedef bimap
+<
+ multiset_of<Type>, RightKeyType
+
+> bimap_with_left_type_as_multiset;
+
+BOOST_STATIC_ASSERT
+(
+ is_same
+ <
+ compute_map_view_type
+ <
+ member_at::left,
+ bimap_with_left_type_as_multiset
+
+ >::type,
+ multimap_view< member_at::left, bimap_with_left_type_as_multiset >
+
+ >::value
+)
+
+\endcode
+
+See also multiset_of_relation.
+ **/
+
+template
+<
+ class KeyType,
+ class KeyCompare = std::less< BOOST_DEDUCED_TYPENAME
+ ::boost::bimaps::tags::support::value_type_of<KeyType>::type >
+>
+struct multiset_of : public ::boost::bimaps::detail::set_type_of_tag
+{
+ /// User type, can be tagged
+ typedef KeyType user_type;
+
+ /// Type of the object that will be stored in the multiset
+ typedef BOOST_DEDUCED_TYPENAME ::boost::bimaps::tags::support::
+ value_type_of<user_type>::type value_type;
+
+ /// Functor that compare two keys
+ typedef KeyCompare key_compare;
+
+ struct lazy_concept_checked
+ {
+ BOOST_CLASS_REQUIRE ( value_type,
+ boost, AssignableConcept );
+
+ BOOST_CLASS_REQUIRE4( key_compare, bool, value_type, value_type,
+ boost, BinaryFunctionConcept );
+
+ typedef multiset_of type;
+ };
+
+ BOOST_BIMAP_GENERATE_INDEX_BINDER_1CP(
+
+ // binds to
+ multi_index::ordered_non_unique,
+
+ // with
+ key_compare
+ )
+
+ BOOST_BIMAP_GENERATE_MAP_VIEW_BINDER(
+
+ // binds to
+ views::multimap_view
+ )
+
+ BOOST_BIMAP_GENERATE_SET_VIEW_BINDER(
+
+ // binds to
+ views::multiset_view
+ )
+
+ typedef mpl::bool_<false> mutable_key;
+};
+
+
+/// \brief Set Of Relation Specification
+/**
+This struct is similar to multiset_of but it is bind logically to a
+relation. It is used in the bimap instantiation to specify the
+desired type of the main view. This struct implements internally
+a metafunction named bind_to that manages the quite complicated
+task of finding the right type of the set for the relation.
+
+\code
+template<class Relation>
+struct bind_to
+{
+ typedef -unspecified- type;
+};
+\endcode
+
+See also multiset_of, is_set_type_of_relation.
+ **/
+
+template< class KeyCompare = std::less< _relation > >
+struct multiset_of_relation : public ::boost::bimaps::detail::set_type_of_relation_tag
+{
+ /// Functor that compare two keys
+ typedef KeyCompare key_compare;
+
+
+ BOOST_BIMAP_GENERATE_RELATION_BINDER_1CP(
+
+ // binds to
+ multiset_of,
+
+ // with
+ key_compare
+ )
+
+ typedef mpl::bool_<false> left_mutable_key;
+ typedef mpl::bool_<false> right_mutable_key;
+};
+
+} // namespace bimaps
+} // namespace boost
+
+
+#endif // BOOST_BIMAP_MULTISET_OF_HPP
diff --git a/boost/bimap/property_map/set_support.hpp b/boost/bimap/property_map/set_support.hpp
new file mode 100644
index 0000000..fec669e
--- /dev/null
+++ b/boost/bimap/property_map/set_support.hpp
@@ -0,0 +1,55 @@
+// 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 property_map/set_support.hpp
+/// \brief Support for the property map concept.
+
+#ifndef BOOST_BIMAP_PROPERTY_MAP_SET_SUPPORT_HPP
+#define BOOST_BIMAP_PROPERTY_MAP_SET_SUPPORT_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER>=1200)
+#pragma once
+#endif
+
+#include <boost/config.hpp>
+
+#include <boost/property_map/property_map.hpp>
+#include <boost/bimap/set_of.hpp>
+#include <boost/bimap/support/data_type_by.hpp>
+#include <boost/bimap/support/key_type_by.hpp>
+
+#ifndef BOOST_BIMAP_DOXYGEN_WILL_NOT_PROCESS_THE_FOLLOWING_LINES
+
+namespace boost {
+
+template< class Tag, class Bimap >
+struct property_traits< ::boost::bimaps::views::map_view<Tag,Bimap> >
+{
+ typedef BOOST_DEDUCED_TYPENAME
+ ::boost::bimaps::support::data_type_by<Tag,Bimap>::type value_type;
+ typedef BOOST_DEDUCED_TYPENAME
+ ::boost::bimaps::support:: key_type_by<Tag,Bimap>::type key_type;
+
+ typedef readable_property_map_tag category;
+};
+
+
+template< class Tag, class Bimap >
+const BOOST_DEDUCED_TYPENAME ::boost::bimaps::support::data_type_by<Tag,Bimap>::type &
+ get(const ::boost::bimaps::views::map_view<Tag,Bimap> & m,
+ const BOOST_DEDUCED_TYPENAME
+ ::boost::bimaps::support::key_type_by<Tag,Bimap>::type & key)
+{
+ return m.at(key);
+}
+
+} // namespace boost
+
+#endif // BOOST_BIMAP_DOXYGEN_WILL_NOT_PROCESS_THE_FOLLOWING_LINES
+
+#endif // BOOST_BIMAP_PROPERTY_MAP_SET_SUPPORT_HPP
diff --git a/boost/bimap/property_map/unordered_set_support.hpp b/boost/bimap/property_map/unordered_set_support.hpp
new file mode 100644
index 0000000..b656e30
--- /dev/null
+++ b/boost/bimap/property_map/unordered_set_support.hpp
@@ -0,0 +1,55 @@
+// 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 property_map/unordered_set_support.hpp
+/// \brief Support for the property map concept.
+
+#ifndef BOOST_BIMAP_PROPERTY_MAP_UNORDERED_SET_SUPPORT_HPP
+#define BOOST_BIMAP_PROPERTY_MAP_UNORDERED_SET_SUPPORT_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER>=1200)
+#pragma once
+#endif
+
+#include <boost/config.hpp>
+
+#include <boost/property_map/property_map.hpp>
+#include <boost/bimap/unordered_set_of.hpp>
+#include <boost/bimap/support/data_type_by.hpp>
+#include <boost/bimap/support/key_type_by.hpp>
+
+#ifndef BOOST_BIMAP_DOXYGEN_WILL_NOT_PROCESS_THE_FOLLOWING_LINES
+
+namespace boost {
+
+template< class Tag, class Bimap >
+struct property_traits< ::boost::bimaps::views::unordered_map_view<Tag,Bimap> >
+{
+ typedef BOOST_DEDUCED_TYPENAME
+ ::boost::bimaps::support::data_type_by<Tag,Bimap>::type value_type;
+ typedef BOOST_DEDUCED_TYPENAME
+ ::boost::bimaps::support:: key_type_by<Tag,Bimap>::type key_type;
+
+ typedef readable_property_map_tag category;
+};
+
+
+template< class Tag, class Bimap >
+const BOOST_DEDUCED_TYPENAME ::boost::bimaps::support::data_type_by<Tag,Bimap>::type &
+ get(const ::boost::bimaps::views::unordered_map_view<Tag,Bimap> & m,
+ const BOOST_DEDUCED_TYPENAME
+ ::boost::bimaps::support::key_type_by<Tag,Bimap>::type & key)
+{
+ return m.at(key);
+}
+
+} // namespace boost
+
+#endif // BOOST_BIMAP_DOXYGEN_WILL_NOT_PROCESS_THE_FOLLOWING_LINES
+
+#endif // BOOST_BIMAP_PROPERTY_MAP_UNORDERED_SET_SUPPORT_HPP
diff --git a/boost/bimap/relation/detail/access_builder.hpp b/boost/bimap/relation/detail/access_builder.hpp
new file mode 100644
index 0000000..a1e939f
--- /dev/null
+++ b/boost/bimap/relation/detail/access_builder.hpp
@@ -0,0 +1,170 @@
+// 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 relation/detail/access_builder.hpp
+/// \brief Define macros to help building metafunctions
+
+#ifndef BOOST_BIMAP_RELATION_ACCESS_BUILDER_HPP
+#define BOOST_BIMAP_RELATION_ACCESS_BUILDER_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER>=1200)
+#pragma once
+#endif
+
+#include <boost/config.hpp>
+
+#include <boost/bimap/relation/support/member_with_tag.hpp>
+#include <boost/bimap/relation/member_at.hpp>
+#include <boost/call_traits.hpp>
+#include <boost/type_traits/is_const.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/mpl/not.hpp>
+#include <boost/utility/enable_if.hpp>
+
+
+/******************************************************************************
+ BIMAP SYMMETRIC ACCESS RESULT OF
+*******************************************************************************
+
+namespace result_of {
+
+template< class Tag, class SymmetricType >
+struct NAME
+{
+ typedef -unspecified- type;
+};
+
+} // namespace result_of
+
+******************************************************************************/
+
+/*===========================================================================*/
+#define BOOST_BIMAP_SYMMETRIC_ACCESS_RESULT_OF_BUILDER( \
+ \
+ NAME, \
+ METAFUNCTION_BASE \
+ ) \
+ \
+ namespace result_of { \
+ \
+ template< class Tag, class SymmetricType > \
+ struct NAME \
+ { \
+ typedef BOOST_DEDUCED_TYPENAME METAFUNCTION_BASE \
+ < \
+ Tag,SymmetricType \
+ \
+ >::type value_type; \
+ \
+ typedef BOOST_DEDUCED_TYPENAME mpl::if_< is_const<SymmetricType>, \
+ \
+ BOOST_DEDUCED_TYPENAME call_traits<value_type>::const_reference, \
+ \
+ BOOST_DEDUCED_TYPENAME call_traits<value_type>::reference \
+ \
+ >::type type; \
+ }; \
+ \
+ }
+/*===========================================================================*/
+
+
+
+/******************************************************************************
+ BIMAP SYMMETRIC ACCESS IMPLEMENTATION
+*******************************************************************************
+
+namespace detail {
+
+template< class Tag, class SymmetricType >
+typename result_of::NAME<Tag,SymmetricType>::type
+ NAME( Tag , const Relation & );
+
+} // namespace detail
+
+******************************************************************************/
+
+
+/*===========================================================================*/
+#define BOOST_BIMAP_SYMMETRIC_ACCESS_IMPLEMENTATION_BUILDER( \
+ \
+ NAME, \
+ TP_SYMMETRIC, \
+ PARAMETER_NAME, \
+ LEFT_BODY, \
+ RIGHT_BODY \
+ ) \
+ \
+ namespace detail { \
+ \
+ \
+ \
+ template< class TP_SYMMETRIC > \
+ BOOST_DEDUCED_TYPENAME result_of::NAME \
+ < \
+ ::boost::bimaps::relation::member_at::left,TP_SYMMETRIC \
+ \
+ >::type \
+ \
+ NAME( ::boost::bimaps::relation::member_at::left, \
+ TP_SYMMETRIC & PARAMETER_NAME ) \
+ { \
+ LEFT_BODY; \
+ } \
+ \
+ template< class TP_SYMMETRIC > \
+ BOOST_DEDUCED_TYPENAME result_of::NAME \
+ < \
+ ::boost::bimaps::relation::member_at::right,TP_SYMMETRIC \
+ \
+ >::type \
+ \
+ NAME( ::boost::bimaps::relation::member_at::right, \
+ TP_SYMMETRIC & PARAMETER_NAME ) \
+ { \
+ RIGHT_BODY; \
+ } \
+ \
+ }
+/*===========================================================================*/
+
+
+/******************************************************************************
+ BIMAP RELATION ACCESS INTERFACE
+*******************************************************************************
+
+template< class Tag, class SymmetricType >
+typename result_of::NAME<Tag,SymmetricType>::type
+ NAME( const SymmetricType & );
+
+******************************************************************************/
+
+/*===========================================================================*/
+#define BOOST_BIMAP_SYMMETRIC_ACCESS_INTERFACE_BUILDER( \
+ \
+ NAME \
+ ) \
+ \
+ template< class Tag, class SymmetricType > \
+ BOOST_DEDUCED_TYPENAME result_of::NAME<Tag,SymmetricType>::type \
+ NAME( SymmetricType & s ) \
+ { \
+ typedef BOOST_DEDUCED_TYPENAME ::boost::bimaps::relation::support:: \
+ member_with_tag \
+ < \
+ Tag,SymmetricType \
+ \
+ >::type member_at_tag; \
+ \
+ return detail::NAME(member_at_tag(),s); \
+ }
+/*===========================================================================*/
+
+
+#endif // BOOST_BIMAP_RELATION_ACCESS_BUILDER_HPP
+
diff --git a/boost/bimap/relation/detail/metadata_access_builder.hpp b/boost/bimap/relation/detail/metadata_access_builder.hpp
new file mode 100644
index 0000000..4ef6cae
--- /dev/null
+++ b/boost/bimap/relation/detail/metadata_access_builder.hpp
@@ -0,0 +1,103 @@
+// 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 relation/detail/metadata_access_builder.hpp
+/// \brief Define macros to help building metafunctions
+
+#ifndef BOOST_BIMAP_RELATION_DETAIL_METADATA_ACCESS_BUILDER_HPP
+#define BOOST_BIMAP_RELATION_DETAIL_METADATA_ACCESS_BUILDER_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER>=1200)
+#pragma once
+#endif
+
+#include <boost/config.hpp>
+
+#include <boost/bimap/relation/support/is_tag_of_member_at.hpp>
+#include <boost/bimap/detail/debug/static_error.hpp>
+#include <boost/utility/enable_if.hpp>
+#include <boost/preprocessor/cat.hpp>
+
+
+
+/******************************************************************************
+ BIMAP SYMMETRIC METADATA ACCESS INTERFACE
+*******************************************************************************
+
+template< class Tag, class SymmetricType >
+struct NAME
+{
+ typedef -unspecified- type;
+};
+
+******************************************************************************/
+
+
+/*===========================================================================*/
+#define BOOST_BIMAP_SYMMETRIC_METADATA_ACCESS_BUILDER( \
+ \
+ NAME, \
+ METADATA_BY_LEFT, \
+ METADATA_BY_RIGHT \
+ ) \
+ \
+ template \
+ < \
+ class Tag, \
+ class SymmetricType, \
+ class Enable = void \
+ > \
+ struct NAME \
+ { \
+ BOOST_BIMAP_STATIC_ERROR( \
+ BOOST_PP_CAT(NAME,_FAILURE), \
+ (SymmetricType,Tag) \
+ ); \
+ }; \
+ \
+ template< class Tag, class SymmetricType > \
+ struct NAME \
+ < \
+ Tag, SymmetricType, \
+ BOOST_DEDUCED_TYPENAME enable_if \
+ < \
+ ::boost::bimaps::relation::support::is_tag_of_member_at_left \
+ < \
+ Tag, \
+ SymmetricType \
+ > \
+ \
+ >::type \
+ > \
+ { \
+ typedef BOOST_DEDUCED_TYPENAME SymmetricType::METADATA_BY_LEFT type; \
+ }; \
+ \
+ template< class Tag, class SymmetricType > \
+ struct NAME \
+ < \
+ Tag, SymmetricType, \
+ BOOST_DEDUCED_TYPENAME enable_if \
+ < \
+ ::boost::bimaps::relation::support::is_tag_of_member_at_right \
+ < \
+ Tag, \
+ SymmetricType \
+ > \
+ \
+ >::type \
+ > \
+ { \
+ typedef BOOST_DEDUCED_TYPENAME SymmetricType::METADATA_BY_RIGHT type; \
+ };
+/*===========================================================================*/
+
+
+#endif // BOOST_BIMAP_RELATION_DETAIL_METADATA_ACCES_BUILDER_HPP
+
+
diff --git a/boost/bimap/relation/detail/mutant.hpp b/boost/bimap/relation/detail/mutant.hpp
new file mode 100644
index 0000000..62b3843
--- /dev/null
+++ b/boost/bimap/relation/detail/mutant.hpp
@@ -0,0 +1,83 @@
+// 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 relation/detail/mutant.hpp
+/// \brief Mutate functions to extract views of mutant classes.
+
+#ifndef BOOST_BIMAP_RELATION_DETAIL_MUTANT_HPP
+#define BOOST_BIMAP_RELATION_DETAIL_MUTANT_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER>=1200)
+#pragma once
+#endif
+
+#include <boost/config.hpp>
+
+#include <boost/bimap/detail/debug/static_error.hpp>
+#include <boost/mpl/contains.hpp>
+#include <boost/mpl/assert.hpp>
+#include <boost/utility.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/type_traits/is_const.hpp>
+#include <boost/mpl/not.hpp>
+#include <boost/utility/enable_if.hpp>
+
+namespace boost {
+namespace bimaps {
+namespace relation {
+
+/// \brief Relation details, mutant idiom and symmetrical metafunctions builders.
+
+namespace detail {
+
+//@{
+/// \brief Converts a mutant class to a view with zero overhead.
+/**
+
+This function is a safe wrapper around reinterpret_cast. It checks at
+compile time that the desired view is supported by the mutant class.
+See also mutant, can_mutate_in.
+\ingroup mutant_group
+ **/
+
+
+template< class View, class Type >
+BOOST_DEDUCED_TYPENAME enable_if< mpl::not_< is_const< Type > >,
+
+View&
+
+>::type mutate( Type & m )
+{
+ BOOST_MPL_ASSERT((
+ ::boost::mpl::contains<BOOST_DEDUCED_TYPENAME Type::mutant_views,View>
+ ));
+ return *reinterpret_cast< View* >(boost::addressof(m));
+}
+
+template< class View, class Type >
+BOOST_DEDUCED_TYPENAME enable_if< is_const< Type >,
+
+const View&
+
+>::type mutate( Type & m )
+{
+ BOOST_MPL_ASSERT((
+ ::boost::mpl::contains<BOOST_DEDUCED_TYPENAME Type::mutant_views,View>
+ ));
+ return *reinterpret_cast< const View* >(boost::addressof(m));
+}
+
+//@}
+
+} // namespace detail
+} // namespace relation
+} // namespace bimaps
+} // namespace boost
+
+#endif // BOOST_BIMAP_RELATION_DETAIL_MUTANT_HPP
+
diff --git a/boost/bimap/relation/detail/static_access_builder.hpp b/boost/bimap/relation/detail/static_access_builder.hpp
new file mode 100644
index 0000000..72f9925
--- /dev/null
+++ b/boost/bimap/relation/detail/static_access_builder.hpp
@@ -0,0 +1,105 @@
+// 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 relation/detail/static_access_builder.hpp
+/// \brief Define macros to help building metafunctions
+
+#ifndef BOOST_BIMAP_RELATION_DETAIL_STATIC_ACCESS_BUILDER_HPP
+#define BOOST_BIMAP_RELATION_DETAIL_STATIC_ACCESS_BUILDER_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER>=1200)
+#pragma once
+#endif
+
+#include <boost/config.hpp>
+
+#include <boost/bimap/relation/support/is_tag_of_member_at.hpp>
+#include <boost/bimap/detail/debug/static_error.hpp>
+#include <boost/utility/enable_if.hpp>
+#include <boost/preprocessor/cat.hpp>
+
+
+
+/******************************************************************************
+ BIMAP SYMMETRIC STATIC ACCESS INTERFACE
+*******************************************************************************
+
+template< class Tag, class SYMETRIC_TYPE >
+struct NAME
+{
+ -UNDEFINED BODY-;
+};
+
+******************************************************************************/
+
+
+/*===========================================================================*/
+#define BOOST_BIMAP_SYMMETRIC_STATIC_ACCESS_BUILDER( \
+ \
+ NAME, \
+ SYMMETRIC_TYPE, \
+ LEFT_BODY, \
+ RIGHT_BODY \
+ ) \
+ \
+ template \
+ < \
+ class Tag, \
+ class SYMMETRIC_TYPE, \
+ class Enable = void \
+ > \
+ struct NAME \
+ { \
+ BOOST_BIMAP_STATIC_ERROR( \
+ BOOST_PP_CAT(NAME,_FAILURE), \
+ (SYMMETRIC_TYPE,Tag) \
+ ); \
+ }; \
+ \
+ template< class Tag, class SYMMETRIC_TYPE > \
+ struct NAME \
+ < \
+ Tag, SYMMETRIC_TYPE, \
+ BOOST_DEDUCED_TYPENAME enable_if \
+ < \
+ ::boost::bimaps::relation::support::is_tag_of_member_at_left \
+ < \
+ Tag, \
+ SYMMETRIC_TYPE \
+ > \
+ \
+ >::type \
+ > \
+ { \
+ LEFT_BODY; \
+ }; \
+ \
+ template< class Tag, class SYMMETRIC_TYPE > \
+ struct NAME \
+ < \
+ Tag, SYMMETRIC_TYPE, \
+ BOOST_DEDUCED_TYPENAME enable_if \
+ < \
+ ::boost::bimaps::relation::support::is_tag_of_member_at_right \
+ < \
+ Tag, \
+ SYMMETRIC_TYPE \
+ > \
+ \
+ >::type \
+ > \
+ { \
+ RIGHT_BODY; \
+ };
+/*===========================================================================*/
+
+
+#endif // BOOST_BIMAP_RELATION_DETAIL_STATIC_ACCES_BUILDER_HPP
+
+
diff --git a/boost/bimap/relation/detail/to_mutable_relation_functor.hpp b/boost/bimap/relation/detail/to_mutable_relation_functor.hpp
new file mode 100644
index 0000000..1e8b521
--- /dev/null
+++ b/boost/bimap/relation/detail/to_mutable_relation_functor.hpp
@@ -0,0 +1,102 @@
+// 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 relation/detail/to_mutable_relation_functor.hpp
+/// \brief functors to convert types to mutable relations
+
+#ifndef BOOST_BIMAP_RELATION_DETAIL_TO_MUTABLE_RELATION_FUNCTOR_HPP
+#define BOOST_BIMAP_RELATION_DETAIL_TO_MUTABLE_RELATION_FUNCTOR_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER>=1200)
+#pragma once
+#endif
+
+#include <boost/config.hpp>
+
+#include <boost/bimap/relation/support/pair_type_by.hpp>
+#include <boost/bimap/relation/detail/mutant.hpp>
+#include <boost/bimap/relation/mutant_relation.hpp>
+
+namespace boost {
+namespace bimaps {
+namespace relation {
+namespace detail {
+
+/// \brief Functor used in map views
+
+template< class Tag, class Relation >
+struct pair_to_relation_functor
+{
+ const Relation
+ operator()(const BOOST_DEDUCED_TYPENAME ::boost::bimaps::relation::support::
+ pair_type_by<Tag,Relation>::type & p) const
+ {
+ return Relation(p);
+ }
+};
+
+template< class Tag, class TA, class TB, class Info >
+struct pair_to_relation_functor<
+ Tag,::boost::bimaps::relation::mutant_relation<TA,TB,Info,true> >
+{
+ typedef ::boost::bimaps::relation::mutant_relation<TA,TB,Info,true> Relation;
+
+ Relation &
+ operator()( BOOST_DEDUCED_TYPENAME ::boost::bimaps::relation::support::
+ pair_type_by<Tag,Relation>::type & p ) const
+ {
+ return ::boost::bimaps::relation::detail::mutate<Relation>(p);
+ }
+
+ const Relation &
+ operator()( const BOOST_DEDUCED_TYPENAME ::boost::bimaps::relation::support::
+ pair_type_by<Tag,Relation>::type & p) const
+ {
+ return ::boost::bimaps::relation::detail::mutate<Relation>(p);
+ }
+};
+
+
+/// \brief Used in set views
+
+template< class Relation >
+struct get_mutable_relation_functor
+{
+ const Relation
+ operator()( const BOOST_DEDUCED_TYPENAME Relation::above_view & r ) const
+ {
+ return Relation(r);
+ }
+};
+
+template< class TA, class TB, class Info >
+struct get_mutable_relation_functor< ::boost::bimaps::relation::mutant_relation<TA,TB,Info,true> >
+{
+ typedef ::boost::bimaps::relation::mutant_relation<TA,TB,Info,true> Relation;
+
+ Relation &
+ operator()( BOOST_DEDUCED_TYPENAME Relation::above_view & r ) const
+ {
+ return ::boost::bimaps::relation::detail::mutate<Relation>(r);
+ }
+
+ const Relation &
+ operator()( const BOOST_DEDUCED_TYPENAME Relation::above_view & r ) const
+ {
+ return ::boost::bimaps::relation::detail::mutate<Relation>(r);
+ }
+};
+
+} // namespace detail
+} // namespace relation
+} // namespace bimaps
+} // namespace boost
+
+
+#endif // BOOST_BIMAP_RELATION_DETAIL_TO_MUTABLE_RELATION_FUNCTOR_HPP
+
diff --git a/boost/bimap/relation/member_at.hpp b/boost/bimap/relation/member_at.hpp
new file mode 100644
index 0000000..c39738f
--- /dev/null
+++ b/boost/bimap/relation/member_at.hpp
@@ -0,0 +1,72 @@
+// 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 relation/member_at.hpp
+/// \brief Defines the tags for the member_at::side idiom
+
+#ifndef BOOST_BIMAP_RELATION_MEMBER_AT_HPP
+#define BOOST_BIMAP_RELATION_MEMBER_AT_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER>=1200)
+#pragma once
+#endif
+
+#include <boost/config.hpp>
+
+namespace boost {
+namespace bimaps {
+namespace relation {
+
+/// \brief member_at::side idiom to access relation values and types using metaprogramming.
+/**
+
+This tags are used to specify which member you want to acces when using a metafunction over
+a symmetrical type. The idea is to be able to write code like:
+
+\code
+result_of::get<member_at::left,relation>::type data = get<member_at::left>(rel);
+\endcode
+
+The relation class supports this idiom even when the elements are tagged. This is useful
+because a user can decide to start tagging in any moment of the development.
+
+See also member_with_tag, is_tag_of_member_at_left, is_tag_of_member_at_right, get
+value_type_of, pair_by, pair_type_by.
+
+\ingroup relation_group
+ **/
+namespace member_at {
+
+ /// \brief Member at left tag
+ /**
+ See also member_at, rigth.
+ **/
+
+ struct left {};
+
+ /// \brief Member at right tag
+ /**
+ See also member_at, left.
+ **/
+
+ struct right {};
+
+ /// \brief Member info tag
+ /**
+ See also member_at, left, right.
+ **/
+
+ struct info {};
+
+}
+
+} // namespace relation
+} // namespace bimaps
+} // namespace boost
+
+#endif // BOOST_BIMAP_RELATION_MEMBER_AT_HPP
diff --git a/boost/bimap/relation/mutant_relation.hpp b/boost/bimap/relation/mutant_relation.hpp
new file mode 100644
index 0000000..c46ab79
--- /dev/null
+++ b/boost/bimap/relation/mutant_relation.hpp
@@ -0,0 +1,430 @@
+// 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 relation/mutant_relation.hpp
+/// \brief Defines the mutant_relation class
+
+#ifndef BOOST_BIMAP_RELATION_MUTANT_RELATION_HPP
+#define BOOST_BIMAP_RELATION_MUTANT_RELATION_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER>=1200)
+#pragma once
+#endif
+
+#include <boost/config.hpp>
+
+#include <boost/mpl/vector.hpp>
+#include <boost/operators.hpp>
+#include <boost/call_traits.hpp>
+#include <boost/serialization/nvp.hpp>
+
+#include <boost/functional/hash/hash.hpp>
+
+#include <boost/mpl/aux_/na.hpp>
+
+// Boost.Bimap
+#include <boost/bimap/tags/tagged.hpp>
+#include <boost/bimap/tags/support/default_tagged.hpp>
+#include <boost/bimap/tags/support/tag_of.hpp>
+#include <boost/bimap/tags/support/value_type_of.hpp>
+
+#include <boost/bimap/relation/member_at.hpp>
+#include <boost/bimap/relation/detail/mutant.hpp>
+#include <boost/bimap/relation/structured_pair.hpp>
+#include <boost/bimap/relation/symmetrical_base.hpp>
+#include <boost/bimap/relation/support/get.hpp>
+
+namespace boost {
+namespace bimaps {
+namespace relation {
+
+namespace detail {
+
+// This class is included so structured_pair and mutant_relation share
+// exactly the same class layout
+
+template< class LeftType, class RightType, bool force_mutable >
+class relation_storage :
+ public symmetrical_base<LeftType,RightType,force_mutable>
+{
+ typedef symmetrical_base<LeftType,RightType,force_mutable> base_;
+
+ typedef relation_storage storage_;
+
+ public:
+
+ typedef relation_storage<LeftType,RightType,false> non_mutable_storage;
+
+ typedef ::boost::mpl::vector2
+ <
+ relation_storage< LeftType, RightType, true >,
+ relation_storage< LeftType, RightType, false >
+
+ > mutant_views;
+
+ //@{
+ /// data
+ BOOST_DEDUCED_TYPENAME base_::left_value_type left;
+ BOOST_DEDUCED_TYPENAME base_::right_value_type right;
+ //@}
+
+ relation_storage() {}
+
+ relation_storage(BOOST_DEDUCED_TYPENAME ::boost::call_traits<
+ BOOST_DEDUCED_TYPENAME base_::left_value_type
+ >::param_type l,
+ BOOST_DEDUCED_TYPENAME ::boost::call_traits<
+ BOOST_DEDUCED_TYPENAME base_::right_value_type
+ >::param_type r)
+
+ : left(l), right(r) {}
+
+ BOOST_DEDUCED_TYPENAME base_:: left_value_type & get_left() { return left; }
+ const BOOST_DEDUCED_TYPENAME base_:: left_value_type & get_left()const { return left; }
+ BOOST_DEDUCED_TYPENAME base_::right_value_type & get_right() { return right; }
+ const BOOST_DEDUCED_TYPENAME base_::right_value_type & get_right()const { return right; }
+};
+
+
+
+template< class TA, class TB, class Info, bool force_mutable >
+class relation_info_hook : public
+ ::boost::bimaps::relation::detail::relation_storage<TA,TB,force_mutable>
+{
+ typedef ::boost::bimaps::relation::detail::
+ relation_storage<TA,TB,force_mutable> base_;
+
+ typedef BOOST_DEDUCED_TYPENAME ::boost::bimaps::tags::support::
+ default_tagged<Info,member_at::info>::type tagged_info_type;
+
+ public:
+ typedef BOOST_DEDUCED_TYPENAME tagged_info_type::value_type info_type;
+ typedef BOOST_DEDUCED_TYPENAME tagged_info_type::tag info_tag;
+
+ info_type info;
+
+ protected:
+
+ relation_info_hook() {}
+
+ relation_info_hook( BOOST_DEDUCED_TYPENAME ::boost::call_traits<
+ BOOST_DEDUCED_TYPENAME base_::left_value_type
+ >::param_type l,
+ BOOST_DEDUCED_TYPENAME ::boost::call_traits<
+ BOOST_DEDUCED_TYPENAME base_::right_value_type
+ >::param_type r,
+ BOOST_DEDUCED_TYPENAME ::boost::call_traits<
+ info_type
+ >::param_type i = info_type() )
+
+ : base_(l,r), info(i) {}
+
+ template< class Relation >
+ relation_info_hook( const Relation & rel ) :
+ base_(rel.left,rel.right),
+ info(rel.info) {}
+
+ template< class Relation >
+ void change_to( const Relation & rel )
+ {
+ base_::left = rel.left ;
+ base_::right = rel.right;
+ info = rel.info ;
+ }
+
+ #ifndef BOOST_BIMAP_DISABLE_SERIALIZATION
+ template< class Archive >
+ void serialize(Archive & ar, const unsigned int version)
+ {
+ ar & ::boost::serialization::make_nvp("left" , base_::left );
+ ar & ::boost::serialization::make_nvp("right", base_::right);
+ ar & ::boost::serialization::make_nvp("info" , info );
+ }
+ #endif // BOOST_BIMAP_DISABLE_SERIALIZATION
+};
+
+template< class TA, class TB, bool force_mutable>
+class relation_info_hook<TA,TB,::boost::mpl::na,force_mutable> :
+ public ::boost::bimaps::relation::detail::relation_storage<TA,TB,force_mutable>
+{
+ typedef ::boost::bimaps::relation::detail::
+ relation_storage<TA,TB,force_mutable> base_;
+
+ public:
+ typedef ::boost::mpl::na info_type;
+ typedef member_at::info info_tag;
+
+ protected:
+
+ relation_info_hook() {}
+
+ relation_info_hook( BOOST_DEDUCED_TYPENAME ::boost::call_traits<
+ BOOST_DEDUCED_TYPENAME base_::left_value_type
+ >::param_type l,
+ BOOST_DEDUCED_TYPENAME ::boost::call_traits<
+ BOOST_DEDUCED_TYPENAME base_::right_value_type
+ >::param_type r)
+
+ : base_(l,r) {}
+
+ template< class Relation >
+ relation_info_hook( const Relation & rel ) :
+ base_(rel.left,rel.right) {}
+
+ template< class Relation >
+ void change_to( const Relation & rel )
+ {
+ base_::left = rel.left ;
+ base_::right = rel.right;
+ }
+
+ #ifndef BOOST_BIMAP_DISABLE_SERIALIZATION
+ template< class Archive >
+ void serialize(Archive & ar, const unsigned int version)
+ {
+ ar & ::boost::serialization::make_nvp("left" , base_::left );
+ ar & ::boost::serialization::make_nvp("right", base_::right);
+ }
+ #endif // BOOST_BIMAP_DISABLE_SERIALIZATION
+};
+
+
+} // namespace detail
+
+/// \brief Abstraction of a related pair of values, that extends the std::pair class.
+/**
+The mutant_relation is a mutant class. A mutant class can mutate
+with zero overhead in other classes that are called views.
+Each view has to be StorageCompatible with the base class
+of the mutant. Note that all the views have the following
+storage structure:
+
+\verbatim
+ __________
+ | |
+ | TA |
+ |__________|
+ | |
+ | TB |
+ |__________|
+
+\endverbatim
+
+See also select_relation, standard_relation.
+\ingroup relation_group
+ **/
+
+
+template< class TA, class TB, class Info = ::boost::mpl::na, bool force_mutable = false >
+class mutant_relation : public
+ ::boost::bimaps::relation::detail::
+ relation_info_hook<TA,TB,Info,force_mutable>
+{
+ typedef ::boost::bimaps::relation::detail::
+ relation_info_hook<TA,TB,Info,force_mutable> base_;
+
+ public:
+
+ // We have to know the type of the base where the types are
+ // defined because Boost.MultiIndex requires it.
+
+ typedef ::boost::bimaps::relation::detail::
+ relation_storage<TA,TB,force_mutable> storage_base;
+
+ /// Above view, non mutable view of the relation
+
+ typedef mutant_relation<TA,TB,Info,false> above_view;
+
+ //@{
+ /// A signature compatible std::pair that is a view of the relation.
+
+ typedef structured_pair< TA, TB, Info, normal_layout > left_pair;
+ typedef structured_pair< TB, TA, Info, mirror_layout > right_pair;
+ //@}
+
+ typedef ::boost::mpl::vector4
+ <
+ left_pair,
+ right_pair,
+
+ mutant_relation< TA, TB, Info, true >,
+ mutant_relation< TA, TB, Info, false >
+
+ > mutant_views;
+
+ mutant_relation() {}
+
+ mutant_relation(BOOST_DEDUCED_TYPENAME ::boost::call_traits<
+ BOOST_DEDUCED_TYPENAME base_:: left_value_type
+ >::param_type l,
+ BOOST_DEDUCED_TYPENAME ::boost::call_traits<
+ BOOST_DEDUCED_TYPENAME base_::right_value_type
+ >::param_type r) :
+ base_(l,r) {}
+
+ mutant_relation(BOOST_DEDUCED_TYPENAME ::boost::call_traits<
+ BOOST_DEDUCED_TYPENAME base_:: left_value_type
+ >::param_type l,
+ BOOST_DEDUCED_TYPENAME ::boost::call_traits<
+ BOOST_DEDUCED_TYPENAME base_::right_value_type
+ >::param_type r,
+ BOOST_DEDUCED_TYPENAME ::boost::call_traits<
+ BOOST_DEDUCED_TYPENAME base_::info_type
+ >::param_type i) :
+ base_(l,r,i) {}
+
+ mutant_relation(const mutant_relation<TA,TB,Info,false> & rel) :
+ base_(rel) {}
+
+ mutant_relation(const mutant_relation<TA,TB,Info,true> & rel) :
+ base_(rel) {}
+
+ // Operators
+
+ template< bool FM >
+ mutant_relation& operator=(const mutant_relation<TA,TB,Info,FM> & rel)
+ {
+ base_::change_to(rel);
+ return *this;
+ }
+
+ // The following functions are redundant if you only consider this class.
+ // They are included to make easier the construction of the get and the
+ // pair_by metafunction. Remember that not all compiler supports the mutant
+ // idiom.
+
+ left_pair & get_left_pair()
+ {
+ return ::boost::bimaps::relation::detail::mutate<left_pair>(*this);
+ }
+
+ const left_pair & get_left_pair() const
+ {
+ return ::boost::bimaps::relation::detail::mutate<left_pair>(*this);
+ }
+
+ right_pair & get_right_pair()
+ {
+ return ::boost::bimaps::relation::detail::mutate<right_pair>(*this);
+ }
+
+ const right_pair & get_right_pair() const
+ {
+ return ::boost::bimaps::relation::detail::mutate<right_pair>(*this);
+ }
+
+ above_view & get_view()
+ {
+ return ::boost::bimaps::relation::detail::mutate<above_view>(*this);
+ }
+
+ const above_view & get_view() const
+ {
+ return ::boost::bimaps::relation::detail::mutate<above_view>(*this);
+ }
+
+ template< class Tag >
+ const BOOST_DEDUCED_TYPENAME ::boost::bimaps::relation::support::
+ result_of::get<Tag,const mutant_relation>::type
+ get(BOOST_EXPLICIT_TEMPLATE_TYPE(Tag)) const
+ {
+ return ::boost::bimaps::relation::support::get<Tag>(*this);
+ }
+
+ template< class Tag >
+ BOOST_DEDUCED_TYPENAME ::boost::bimaps::relation::support::
+ result_of::get<Tag,mutant_relation>::type
+ get(BOOST_EXPLICIT_TEMPLATE_TYPE(Tag))
+ {
+ return ::boost::bimaps::relation::support::get<Tag>(*this);
+ }
+
+ #ifndef BOOST_BIMAP_DISABLE_SERIALIZATION
+
+ private:
+ friend class ::boost::serialization::access;
+
+ template<class Archive>
+ void serialize(Archive & ar, const unsigned int version)
+ {
+ base_::serialize(ar,version);
+ }
+
+ #endif // BOOST_BIMAP_DISABLE_SERIALIZATION
+};
+
+// hash value
+
+template< class FirstType, class SecondType, bool FM >
+std::size_t hash_value(const detail::relation_storage<FirstType,SecondType,FM> & r)
+{
+ std::size_t seed = 0;
+ ::boost::hash_combine(seed, r. left );
+ ::boost::hash_combine(seed, r.right );
+
+ return seed;
+}
+
+// mutant_relation - mutant_relation
+
+template< class FirstType, class SecondType, bool FM1, bool FM2 >
+bool operator==(const detail::relation_storage<FirstType,SecondType,FM1> & a,
+ const detail::relation_storage<FirstType,SecondType,FM2> & b)
+{
+ return ( ( a.left == b.left ) &&
+ ( a.right == b.right ) );
+}
+
+template< class FirstType, class SecondType, bool FM1, bool FM2 >
+bool operator!=(const detail::relation_storage<FirstType,SecondType,FM1> & a,
+ const detail::relation_storage<FirstType,SecondType,FM2> & b)
+{
+ return ! ( a == b );
+}
+
+template< class FirstType, class SecondType, bool FM1, bool FM2 >
+bool operator<(const detail::relation_storage<FirstType,SecondType,FM1> & a,
+ const detail::relation_storage<FirstType,SecondType,FM2> & b)
+{
+ return ( ( a.left < b.left ) ||
+ (( a.left == b.left ) && ( a.right < b.right )));
+}
+
+template< class FirstType, class SecondType, bool FM1, bool FM2 >
+bool operator<=(const detail::relation_storage<FirstType,SecondType,FM1> & a,
+ const detail::relation_storage<FirstType,SecondType,FM2> & b)
+{
+ return ( ( a.left < b.left ) ||
+ (( a.left == b.left ) && ( a.right <= b.right )));
+}
+
+template< class FirstType, class SecondType, bool FM1, bool FM2 >
+bool operator>(const detail::relation_storage<FirstType,SecondType,FM1> & a,
+ const detail::relation_storage<FirstType,SecondType,FM2> & b)
+{
+ return ( ( a.left > b.left ) ||
+ (( a.left == b.left ) && ( a.right > b.right )));
+}
+
+template< class FirstType, class SecondType, bool FM1, bool FM2 >
+bool operator>=(const detail::relation_storage<FirstType,SecondType,FM1> & a,
+ const detail::relation_storage<FirstType,SecondType,FM2> & b)
+{
+ return ( ( a.left > b.left ) ||
+ (( a.left == b.left ) && ( a.right >= b.right )));
+}
+
+} // namespace relation
+} // namespace bimaps
+} // namespace boost
+
+
+#endif // BOOST_BIMAP_RELATION_MUTANT_RELATION_HPP
+
+
+
diff --git a/boost/bimap/relation/pair_layout.hpp b/boost/bimap/relation/pair_layout.hpp
new file mode 100644
index 0000000..24368db
--- /dev/null
+++ b/boost/bimap/relation/pair_layout.hpp
@@ -0,0 +1,72 @@
+// 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 relation/pair_layout.hpp
+/// \brief Tags for pair layouts
+
+#ifndef BOOST_BIMAP_RELATION_PAIR_LAYOUT_HPP
+#define BOOST_BIMAP_RELATION_PAIR_LAYOUT_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER>=1200)
+#pragma once
+#endif
+
+#include <boost/config.hpp>
+
+namespace boost {
+namespace bimaps {
+namespace relation {
+
+//@{
+
+/// \brief Tag for normal layout. ( A,B -> A,B )
+
+struct normal_layout {};
+
+/// \brief Tag for mirror layout. ( A,B -> B,A )
+
+struct mirror_layout {};
+
+//@}
+
+/** \struct boost::bimaps::relation::inverse_layout
+\brief Metafunction to obtain the inverse of a layout.
+
+\code
+template< class Layout >
+struct inverse_layout
+{
+ typedef {InverseLayout} type;
+};
+\endcode
+
+See also normal_layout, mirror_layout.
+ **/
+
+#ifndef BOOST_BIMAP_DOXYGEN_WILL_NOT_PROCESS_THE_FOLLOWING_LINES
+
+template< class Layout >
+struct inverse_layout
+{
+ typedef normal_layout type;
+};
+
+template<>
+struct inverse_layout< normal_layout >
+{
+ typedef mirror_layout type;
+};
+
+#endif // BOOST_BIMAP_DOXYGEN_WILL_NOT_PROCESS_THE_FOLLOWING_LINES
+
+} // namespace relation
+} // namespace bimaps
+} // namespace boost
+
+#endif // BOOST_BIMAP_RELATION_DETAIL_PAIR_LAYOUT_HPP
+
diff --git a/boost/bimap/relation/structured_pair.hpp b/boost/bimap/relation/structured_pair.hpp
new file mode 100644
index 0000000..2325b3d
--- /dev/null
+++ b/boost/bimap/relation/structured_pair.hpp
@@ -0,0 +1,508 @@
+// 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 relation/structured_pair.hpp
+/// \brief Defines the structured_pair class.
+
+#ifndef BOOST_BIMAP_RELATION_STRUCTURED_PAIR_HPP
+#define BOOST_BIMAP_RELATION_STRUCTURED_PAIR_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER>=1200)
+#pragma once
+#endif
+
+#include <boost/config.hpp>
+
+#include <utility>
+
+#include <boost/type_traits/remove_const.hpp>
+
+#include <boost/mpl/aux_/na.hpp>
+
+#include <boost/call_traits.hpp>
+
+#include <boost/utility/enable_if.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/mpl/vector.hpp>
+
+#include <boost/bimap/detail/debug/static_error.hpp>
+#include <boost/bimap/relation/pair_layout.hpp>
+#include <boost/bimap/relation/symmetrical_base.hpp>
+#include <boost/bimap/relation/support/get.hpp>
+#include <boost/bimap/tags/support/value_type_of.hpp>
+
+
+
+namespace boost {
+namespace bimaps {
+namespace relation {
+
+namespace detail {
+
+/// \brief Storage definition of the left view of a mutant relation.
+/**
+
+See also storage_finder, mirror_storage.
+ **/
+
+template< class FirstType, class SecondType >
+class normal_storage :
+ public symmetrical_base<FirstType,SecondType>
+{
+ typedef symmetrical_base<FirstType,SecondType> base_;
+
+ public:
+
+ typedef normal_storage storage_;
+
+ typedef BOOST_DEDUCED_TYPENAME base_::left_value_type first_type;
+ typedef BOOST_DEDUCED_TYPENAME base_::right_value_type second_type;
+
+ first_type first;
+ second_type second;
+
+ normal_storage() {}
+
+ normal_storage(BOOST_DEDUCED_TYPENAME ::boost::call_traits<
+ first_type >::param_type f,
+ BOOST_DEDUCED_TYPENAME ::boost::call_traits<
+ second_type>::param_type s)
+
+ : first(f), second(s) {}
+
+ BOOST_DEDUCED_TYPENAME base_:: left_value_type & get_left() { return first; }
+ const BOOST_DEDUCED_TYPENAME base_:: left_value_type & get_left()const { return first; }
+ BOOST_DEDUCED_TYPENAME base_::right_value_type & get_right() { return second; }
+ const BOOST_DEDUCED_TYPENAME base_::right_value_type & get_right()const { return second; }
+};
+
+/// \brief Storage definition of the right view of a mutant relation.
+/**
+
+See also storage_finder, normal_storage.
+ **/
+
+template< class FirstType, class SecondType >
+class mirror_storage :
+ public symmetrical_base<SecondType,FirstType>
+{
+ typedef symmetrical_base<SecondType,FirstType> base_;
+
+ public:
+
+ typedef mirror_storage storage_;
+
+ typedef BOOST_DEDUCED_TYPENAME base_::left_value_type second_type;
+ typedef BOOST_DEDUCED_TYPENAME base_::right_value_type first_type;
+
+ second_type second;
+ first_type first;
+
+ mirror_storage() {}
+
+ mirror_storage(BOOST_DEDUCED_TYPENAME ::boost::call_traits<first_type >::param_type f,
+ BOOST_DEDUCED_TYPENAME ::boost::call_traits<second_type >::param_type s)
+
+ : second(s), first(f) {}
+
+ BOOST_DEDUCED_TYPENAME base_:: left_value_type & get_left() { return second; }
+ const BOOST_DEDUCED_TYPENAME base_:: left_value_type & get_left()const { return second; }
+ BOOST_DEDUCED_TYPENAME base_::right_value_type & get_right() { return first; }
+ const BOOST_DEDUCED_TYPENAME base_::right_value_type & get_right()const { return first; }
+};
+
+/** \struct boost::bimaps::relation::storage_finder
+\brief Obtain the a storage with the correct layout.
+
+\code
+template< class FirstType, class SecondType, class Layout >
+struct storage_finder
+{
+ typedef {normal/mirror}_storage<FirstType,SecondType> type;
+};
+\endcode
+
+See also normal_storage, mirror_storage.
+ **/
+
+#ifndef BOOST_BIMAP_DOXYGEN_WILL_NOT_PROCESS_THE_FOLLOWING_LINES
+
+template
+<
+ class FirstType,
+ class SecondType,
+ class Layout
+>
+struct storage_finder
+{
+ typedef normal_storage<FirstType,SecondType> type;
+};
+
+template
+<
+ class FirstType,
+ class SecondType
+>
+struct storage_finder<FirstType,SecondType,mirror_layout>
+{
+ typedef mirror_storage<FirstType,SecondType> type;
+};
+
+#endif // BOOST_BIMAP_DOXYGEN_WILL_NOT_PROCESS_THE_FOLLOWING_LINES
+
+
+template< class TA, class TB, class Info, class Layout >
+class pair_info_hook :
+ public ::boost::bimaps::relation::detail::storage_finder<TA,TB,Layout>::type
+{
+ typedef BOOST_DEDUCED_TYPENAME ::boost::bimaps::relation::detail::storage_finder<TA,TB,Layout>::type base_;
+
+ typedef BOOST_DEDUCED_TYPENAME ::boost::bimaps::tags::support::
+ default_tagged<Info,member_at::info>::type tagged_info_type;
+
+ public:
+ typedef BOOST_DEDUCED_TYPENAME tagged_info_type::value_type info_type;
+ typedef BOOST_DEDUCED_TYPENAME tagged_info_type::tag info_tag;
+
+ info_type info;
+
+ protected:
+
+ pair_info_hook() {}
+
+ pair_info_hook( BOOST_DEDUCED_TYPENAME ::boost::call_traits<
+ BOOST_DEDUCED_TYPENAME base_::first_type
+ >::param_type f,
+ BOOST_DEDUCED_TYPENAME ::boost::call_traits<
+ BOOST_DEDUCED_TYPENAME base_::second_type
+ >::param_type s,
+ BOOST_DEDUCED_TYPENAME ::boost::call_traits<
+ info_type
+ >::param_type i = info_type() )
+ : base_(f,s), info(i) {}
+
+ template< class Pair >
+ pair_info_hook( const Pair & p) :
+ base_(p.first,p.second),
+ info(p.info) {}
+
+ template< class Pair >
+ void change_to( const Pair & p )
+ {
+ base_::first = p.first ;
+ base_::second = p.second;
+ info = p.info ;
+ }
+
+ void clear_info()
+ {
+ info = info_type();
+ };
+};
+
+template< class TA, class TB, class Layout>
+class pair_info_hook<TA,TB,::boost::mpl::na,Layout> :
+ public ::boost::bimaps::relation::detail::storage_finder<TA,TB,Layout>::type
+{
+ typedef BOOST_DEDUCED_TYPENAME ::boost::bimaps::relation::detail::storage_finder<TA,TB,Layout>::type base_;
+
+ public:
+ typedef ::boost::mpl::na info_type;
+ typedef member_at::info info_tag;
+
+ protected:
+
+ pair_info_hook() {}
+
+ pair_info_hook( BOOST_DEDUCED_TYPENAME ::boost::call_traits<
+ BOOST_DEDUCED_TYPENAME base_::first_type
+ >::param_type f,
+ BOOST_DEDUCED_TYPENAME ::boost::call_traits<
+ BOOST_DEDUCED_TYPENAME base_::second_type
+ >::param_type s)
+
+ : base_(f,s) {}
+
+ template< class Pair >
+ pair_info_hook( const Pair & p ) :
+ base_(p.first,p.second) {}
+
+ template< class Pair >
+ void change_to( const Pair & p )
+ {
+ base_::first = p.first ;
+ base_::second = p.second;
+ }
+
+ void clear_info() {};
+};
+
+
+
+} // namespace detail
+
+template< class TA, class TB, class Info, bool FM >
+class mutant_relation;
+
+
+/// \brief A std::pair signature compatible class that allows you to control
+/// the internal structure of the data.
+/**
+This class allows you to specify the order in wich the two data types will be
+in the layout of the class.
+ **/
+
+template< class FirstType, class SecondType, class Info, class Layout = normal_layout >
+class structured_pair :
+
+ public ::boost::bimaps::relation::detail::pair_info_hook
+ <
+ FirstType, SecondType,
+ Info,
+ Layout
+
+ >
+
+{
+ typedef BOOST_DEDUCED_TYPENAME ::boost::bimaps::relation::detail::pair_info_hook
+ <
+ FirstType, SecondType,
+ Info,
+ Layout
+
+ > base_;
+
+ public:
+
+ typedef ::boost::mpl::vector3<
+ structured_pair< FirstType, SecondType, Info, normal_layout >,
+ structured_pair< FirstType, SecondType, Info, mirror_layout >,
+ BOOST_DEDUCED_TYPENAME ::boost::mpl::if_<
+ BOOST_DEDUCED_TYPENAME ::boost::is_same<Layout, normal_layout>::type,
+ mutant_relation< FirstType, SecondType, Info, true >,
+ mutant_relation< SecondType, FirstType, Info, true >
+ >::type
+
+ > mutant_views;
+
+ structured_pair() {}
+
+ structured_pair(BOOST_DEDUCED_TYPENAME boost::call_traits<
+ BOOST_DEDUCED_TYPENAME base_::first_type >::param_type f,
+ BOOST_DEDUCED_TYPENAME boost::call_traits<
+ BOOST_DEDUCED_TYPENAME base_::second_type >::param_type s)
+ : base_(f,s) {}
+
+ structured_pair(BOOST_DEDUCED_TYPENAME boost::call_traits<
+ BOOST_DEDUCED_TYPENAME base_::first_type >::param_type f,
+ BOOST_DEDUCED_TYPENAME boost::call_traits<
+ BOOST_DEDUCED_TYPENAME base_::second_type >::param_type s,
+ BOOST_DEDUCED_TYPENAME boost::call_traits<
+ BOOST_DEDUCED_TYPENAME base_::info_type >::param_type i)
+ : base_(f,s,i) {}
+
+ template< class OtherLayout >
+ structured_pair(
+ const structured_pair<FirstType,SecondType,Info,OtherLayout> & p)
+ : base_(p) {}
+
+ template< class OtherLayout >
+ structured_pair& operator=(
+ const structured_pair<FirstType,SecondType,OtherLayout> & p)
+ {
+ base_::change_to(p);
+ return *this;
+ }
+
+ template< class First, class Second >
+ structured_pair(const std::pair<First,Second> & p) :
+ base_(p.first,p.second)
+ {}
+
+ template< class First, class Second >
+ structured_pair& operator=(const std::pair<First,Second> & p)
+ {
+ base_::first = p.first;
+ base_::second = p.second;
+ base_::clear_info();
+ return *this;
+ }
+
+ template< class Tag >
+ const BOOST_DEDUCED_TYPENAME ::boost::bimaps::relation::support::
+ result_of::get<Tag,const structured_pair>::type
+ get(BOOST_EXPLICIT_TEMPLATE_TYPE(Tag)) const
+ {
+ return ::boost::bimaps::relation::support::get<Tag>(*this);
+ }
+
+ template< class Tag >
+ BOOST_DEDUCED_TYPENAME ::boost::bimaps::relation::support::
+ result_of::get<Tag,structured_pair>::type
+ get(BOOST_EXPLICIT_TEMPLATE_TYPE(Tag))
+ {
+ return ::boost::bimaps::relation::support::get<Tag>(*this);
+ }
+};
+
+// structured_pair - structured_pair
+
+template< class FirstType, class SecondType, class Info, class Layout1, class Layout2 >
+bool operator==(const structured_pair<FirstType,SecondType,Info,Layout1> & a,
+ const structured_pair<FirstType,SecondType,Info,Layout2> & b)
+{
+ return ( ( a.first == b.first ) &&
+ ( a.second == b.second ) );
+}
+
+template< class FirstType, class SecondType, class Info, class Layout1, class Layout2 >
+bool operator!=(const structured_pair<FirstType,SecondType,Info,Layout1> & a,
+ const structured_pair<FirstType,SecondType,Info,Layout2> & b)
+{
+ return ! ( a == b );
+}
+
+template< class FirstType, class SecondType, class Info, class Layout1, class Layout2 >
+bool operator<(const structured_pair<FirstType,SecondType,Info,Layout1> & a,
+ const structured_pair<FirstType,SecondType,Info,Layout2> & b)
+{
+ return ( ( a.first < b.first ) ||
+ (( a.first == b.first ) && ( a.second < b.second )));
+}
+
+template< class FirstType, class SecondType, class Info, class Layout1, class Layout2 >
+bool operator<=(const structured_pair<FirstType,SecondType,Info,Layout1> & a,
+ const structured_pair<FirstType,SecondType,Info,Layout2> & b)
+{
+ return ( ( a.first < b.first ) ||
+ (( a.first == b.first ) && ( a.second <= b.second )));
+}
+
+template< class FirstType, class SecondType, class Info, class Layout1, class Layout2 >
+bool operator>(const structured_pair<FirstType,SecondType,Info,Layout1> & a,
+ const structured_pair<FirstType,SecondType,Info,Layout2> & b)
+{
+ return ( ( a.first > b.first ) ||
+ (( a.first == b.first ) && ( a.second > b.second )));
+}
+
+template< class FirstType, class SecondType, class Info, class Layout1, class Layout2 >
+bool operator>=(const structured_pair<FirstType,SecondType,Info,Layout1> & a,
+ const structured_pair<FirstType,SecondType,Info,Layout2> & b)
+{
+ return ( ( a.first > b.first ) ||
+ (( a.first == b.first ) && ( a.second >= b.second )));
+}
+
+// structured_pair - std::pair
+
+template< class FirstType, class SecondType, class Info, class Layout, class F, class S >
+bool operator==(const structured_pair<FirstType,SecondType,Info,Layout> & a,
+ const std::pair<F,S> & b)
+{
+ return ( ( a.first == b.first ) &&
+ ( a.second == b.second ) );
+}
+
+template< class FirstType, class SecondType, class Info, class Layout, class F, class S >
+bool operator!=(const structured_pair<FirstType,SecondType,Info,Layout> & a,
+ const std::pair<F,S> & b)
+{
+ return ! ( a == b );
+}
+
+template< class FirstType, class SecondType, class Info, class Layout, class F, class S >
+bool operator<(const structured_pair<FirstType,SecondType,Info,Layout> & a,
+ const std::pair<F,S> & b)
+{
+ return ( ( a.first < b.first ) ||
+ (( a.first == b.first ) && ( a.second < b.second )));
+}
+
+template< class FirstType, class SecondType, class Info, class Layout, class F, class S >
+bool operator<=(const structured_pair<FirstType,SecondType,Info,Layout> & a,
+ const std::pair<F,S> & b)
+{
+ return ( ( a.first < b.first ) ||
+ (( a.first == b.first ) && ( a.second <= b.second )));
+}
+
+template< class FirstType, class SecondType, class Info, class Layout, class F, class S >
+bool operator>(const structured_pair<FirstType,SecondType,Info,Layout> & a,
+ const std::pair<F,S> & b)
+{
+ return ( ( a.first > b.first ) ||
+ (( a.first == b.first ) && ( a.second > b.second )));
+}
+
+template< class FirstType, class SecondType, class Info, class Layout, class F, class S >
+bool operator>=(const structured_pair<FirstType,SecondType,Info,Layout> & a,
+ const std::pair<F,S> & b)
+{
+ return ( ( a.first > b.first ) ||
+ (( a.first == b.first ) && ( a.second >= b.second )));
+}
+
+// std::pair - sturctured_pair
+
+template< class FirstType, class SecondType, class Info, class Layout, class F, class S >
+bool operator==(const std::pair<F,S> & a,
+ const structured_pair<FirstType,SecondType,Info,Layout> & b)
+{
+ return ( ( a.first == b.first ) &&
+ ( a.second == b.second ) );
+}
+
+template< class FirstType, class SecondType, class Info, class Layout, class F, class S >
+bool operator!=(const std::pair<F,S> & a,
+ const structured_pair<FirstType,SecondType,Info,Layout> & b)
+{
+ return ! ( a == b );
+}
+
+template< class FirstType, class SecondType, class Info, class Layout, class F, class S >
+bool operator<(const std::pair<F,S> & a,
+ const structured_pair<FirstType,SecondType,Info,Layout> & b)
+{
+ return ( ( a.first < b.first ) ||
+ (( a.first == b.first ) && ( a.second < b.second )));
+}
+
+template< class FirstType, class SecondType, class Info, class Layout, class F, class S >
+bool operator<=(const std::pair<F,S> & a,
+ const structured_pair<FirstType,SecondType,Info,Layout> & b)
+{
+ return ( ( a.first < b.first ) ||
+ (( a.first == b.first ) && ( a.second <= b.second )));
+}
+
+template< class FirstType, class SecondType, class Info, class Layout, class F, class S >
+bool operator>(const std::pair<F,S> & a,
+ const structured_pair<FirstType,SecondType,Info,Layout> & b)
+{
+ return ( ( a.first > b.first ) ||
+ (( a.first == b.first ) && ( a.second > b.second )));
+}
+
+template< class FirstType, class SecondType, class Info, class Layout, class F, class S >
+bool operator>=(const std::pair<F,S> & a,
+ const structured_pair<FirstType,SecondType,Info,Layout> & b)
+{
+ return ( ( a.first > b.first ) ||
+ (( a.first == b.first ) && ( a.second >= b.second )));
+}
+
+
+
+} // namespace relation
+} // namespace bimaps
+} // namespace boost
+
+#endif // BOOST_BIMAP_RELATION_STRUCTURED_PAIR_HPP
+
diff --git a/boost/bimap/relation/support/data_extractor.hpp b/boost/bimap/relation/support/data_extractor.hpp
new file mode 100644
index 0000000..eab2db7
--- /dev/null
+++ b/boost/bimap/relation/support/data_extractor.hpp
@@ -0,0 +1,110 @@
+// 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 relation/support/data_extractor.hpp
+/// \brief Data extraction functor.
+
+#ifndef BOOST_BIMAP_RELATION_SUPPORT_DATA_EXTRACTOR_HPP
+#define BOOST_BIMAP_RELATION_SUPPORT_DATA_EXTRACTOR_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 <functional>
+
+/** \struct boost::bimaps::relation::support::data_extractor
+
+\brief Data extraction functor.
+
+\ingroup relation_group
+ **/
+
+#ifndef BOOST_BIMAP_DOXYGEN_WILL_NOT_PROCESS_THE_FOLLOWING_LINES
+
+namespace boost {
+namespace bimaps {
+namespace relation {
+namespace support {
+
+template< class Tag, class Relation >
+struct data_extractor_implementation;
+
+template< class Relation >
+struct data_extractor_implementation< member_at::left, Relation > :
+ public std::unary_function<Relation,BOOST_DEDUCED_TYPENAME Relation::left_value_type>
+{
+ BOOST_DEDUCED_TYPENAME Relation::left_value_type const &
+ operator()(Relation const & rel) const
+ {
+ return rel.left;
+ }
+
+ BOOST_DEDUCED_TYPENAME Relation::left_value_type &
+ operator()(Relation & rel) const
+ {
+ return rel.left;
+ }
+};
+
+template< class Relation >
+struct data_extractor_implementation< member_at::right, Relation > :
+ public std::unary_function<Relation,BOOST_DEDUCED_TYPENAME Relation::right_value_type>
+{
+ BOOST_DEDUCED_TYPENAME Relation::right_value_type const &
+ operator()(Relation const & rel) const
+ {
+ return rel.right;
+ }
+
+ BOOST_DEDUCED_TYPENAME Relation::right_value_type &
+ operator()(Relation & rel) const
+ {
+ return rel.right;
+ }
+};
+
+template< class Tag, class Relation >
+struct data_extractor
+{
+ typedef data_extractor_implementation
+ <
+ BOOST_DEDUCED_TYPENAME member_with_tag<Tag,Relation>::type,
+ Relation
+
+ > type;
+};
+
+template< class Relation >
+struct both_keys_extractor
+{
+ typedef BOOST_DEDUCED_TYPENAME Relation::storage_base result_type;
+
+ const result_type & operator()(const Relation & rel) const
+ {
+ return rel;
+ }
+
+ result_type & operator()( Relation & rel) const
+ {
+ return rel;
+ }
+};
+
+} // namespace support
+} // namespace relation
+} // namespace bimaps
+} // namespace boost
+
+#endif // BOOST_BIMAP_DOXYGEN_WILL_NOT_PROCESS_THE_FOLLOWING_LINES
+
+#endif // BOOST_BIMAP_RELATION_SUPPORT_DATA_EXTRACTOR_HPP
+
diff --git a/boost/bimap/relation/support/get.hpp b/boost/bimap/relation/support/get.hpp
new file mode 100644
index 0000000..3a3afde
--- /dev/null
+++ b/boost/bimap/relation/support/get.hpp
@@ -0,0 +1,140 @@
+// 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 relation/support/get.hpp
+/// \brief get<tag>(r) function
+
+#ifndef BOOST_BIMAP_RELATION_SUPPORT_GET_HPP
+#define BOOST_BIMAP_RELATION_SUPPORT_GET_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER>=1200)
+#pragma once
+#endif
+
+#include <boost/config.hpp>
+
+#include <boost/bimap/relation/support/value_type_of.hpp>
+
+#include <boost/bimap/relation/detail/access_builder.hpp>
+
+#include <boost/mpl/if.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/is_const.hpp>
+
+#ifdef BOOST_BIMAP_ONLY_DOXYGEN_WILL_PROCESS_THE_FOLLOWING_LINES
+
+
+namespace boost {
+namespace bimaps {
+namespace relation {
+namespace support {
+
+/** \brief Gets a pair view of the relation.
+
+\ingroup relation_group
+ **/
+
+template< class Tag, class SymmetricType >
+BOOST_DEDUCED_TYPENAME result_of::get<Tag,SymmetricType>::type
+ get( SymmetricType & );
+
+} // namespace support
+} // namespace relation
+} // namespace bimaps
+} // namespace boost
+
+#endif // BOOST_BIMAP_ONLY_DOXYGEN_WILL_PROCESS_THE_FOLLOWING_LINES
+
+
+
+#ifndef BOOST_BIMAP_DOXYGEN_WILL_NOT_PROCESS_THE_FOLLOWING_LINES
+
+namespace boost {
+namespace bimaps {
+namespace relation {
+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 Relation >
+ struct get<Tag,Relation>;
+ {
+ typedef -unspecified- type;
+ };
+
+ } // namespace result_of
+
+*/
+
+BOOST_BIMAP_SYMMETRIC_ACCESS_RESULT_OF_BUILDER
+(
+ get,
+ value_type_of
+)
+
+
+
+// Implementation
+// -------------------------------------------------------------------------
+
+BOOST_BIMAP_SYMMETRIC_ACCESS_IMPLEMENTATION_BUILDER
+(
+ get,
+ SymmetricType,
+ st,
+ return st.get_left(),
+ return st.get_right()
+)
+
+namespace detail {
+
+template< class SymmetricType >
+BOOST_DEDUCED_TYPENAME result_of::get<
+ ::boost::bimaps::relation::member_at::info, SymmetricType >::type
+get(::boost::bimaps::relation::member_at::info, SymmetricType & rel)
+{
+ return rel.info;
+}
+
+} // namespace detail
+
+// Interface
+//----------------------------------------------------------------------------
+
+BOOST_BIMAP_SYMMETRIC_ACCESS_INTERFACE_BUILDER
+(
+ get
+)
+
+
+} // namespace support
+} // namespace relation
+} // namespace bimaps
+} // namespace boost
+
+#endif // BOOST_BIMAP_DOXYGEN_WILL_NOT_PROCESS_THE_FOLLOWING_LINES
+
+#endif // BOOST_BIMAP_RELATION_SUPPORT_GET_HPP
+
diff --git a/boost/bimap/relation/support/get_pair_functor.hpp b/boost/bimap/relation/support/get_pair_functor.hpp
new file mode 100644
index 0000000..5f37bf6
--- /dev/null
+++ b/boost/bimap/relation/support/get_pair_functor.hpp
@@ -0,0 +1,85 @@
+// 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 relation/support/get_pair_functor.hpp
+/// \brief get_pair_functor definition
+
+#ifndef BOOST_BIMAP_RELATION_SUPPORT_GET_PAIR_FUNCTOR_HPP
+#define BOOST_BIMAP_RELATION_SUPPORT_GET_PAIR_FUNCTOR_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER>=1200)
+#pragma once
+#endif
+
+#include <boost/config.hpp>
+
+#include <boost/bimap/relation/support/pair_by.hpp>
+
+namespace boost {
+namespace bimaps {
+namespace relation {
+namespace support {
+
+/// \brief A Functor that takes a relation as a parameter an return the desired view.
+/**
+
+This functor is included to help users of the relation class when using
+stl algorithms.
+
+See also member_at, pair_by().
+\ingroup relation_group
+
+ **/
+
+template< class Tag, class Relation >
+struct get_pair_functor
+{
+ BOOST_DEDUCED_TYPENAME result_of::pair_by<Tag,Relation>::type
+ operator()( Relation & r ) const
+ {
+ return pair_by<Tag>(r);
+ }
+
+ BOOST_DEDUCED_TYPENAME result_of::pair_by<Tag,const Relation>::type
+ operator()( const Relation & r ) const
+ {
+ return pair_by<Tag>(r);
+ }
+};
+
+
+/// \brief A Functor that takes a relation as a parameter an return the above view.
+/**
+
+\ingroup relation_group
+ **/
+
+template< class Relation >
+struct get_above_view_functor
+{
+ BOOST_DEDUCED_TYPENAME Relation::above_view &
+ operator()( Relation & r ) const
+ {
+ return r.get_view();
+ }
+
+ const BOOST_DEDUCED_TYPENAME Relation::above_view &
+ operator()( const Relation & r ) const
+ {
+ return r.get_view();
+ }
+};
+
+} // namespace support
+} // namespace relation
+} // namespace bimaps
+} // namespace boost
+
+
+#endif // BOOST_BIMAP_RELATION_SUPPORT_GET_PAIR_FUNCTOR_HPP
+
diff --git a/boost/bimap/relation/support/is_tag_of_member_at.hpp b/boost/bimap/relation/support/is_tag_of_member_at.hpp
new file mode 100644
index 0000000..b2b1b74
--- /dev/null
+++ b/boost/bimap/relation/support/is_tag_of_member_at.hpp
@@ -0,0 +1,181 @@
+// 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 relation/support/is_tag_of_member_at.hpp
+/// \brief is_tag_of_member_at<tag,relation> metafunction
+
+#ifndef BOOST_BIMAP_RELATION_SUPPORT_IS_TAG_OF_MEMBER_AT_HPP
+#define BOOST_BIMAP_RELATION_SUPPORT_IS_TAG_OF_MEMBER_AT_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER>=1200)
+#pragma once
+#endif
+
+#include <boost/config.hpp>
+
+#include <boost/bimap/relation/member_at.hpp>
+#include <boost/type_traits/is_same.hpp>
+
+#include <boost/mpl/bool.hpp>
+#include <boost/utility/enable_if.hpp>
+#include <boost/bimap/relation/support/member_with_tag.hpp>
+
+/** \struct boost::bimaps::relation::support::is_tag_of_member_at_left
+
+\brief Metafunction to test if a user tag is refering to the left member.
+
+\code
+
+template< class Tag, class Relation >
+struct is_tag_of_member_at_left : {true_|false_} {};
+
+\endcode
+
+This metafunction is somewhat redundant with member_with_tag, but it is included
+because it is a lot easier to metaprogram with it. The result type is the
+same that:
+
+\code
+
+ is_same< member_with_tag<Tag,Relation>::type , member_at::left >::type
+
+\endcode
+
+See also member_with_tag, member_at, is_tag_of_member_at_right.
+\ingroup relation_group
+ **/
+
+
+/** \struct boost::bimaps::relation::support::is_tag_of_member_at_right
+
+\brief Metafunction to test if a user tag is refering to the left member.
+
+\code
+
+template< class Tag, class Relation >
+struct is_tag_of_member_at_right : {true_|false_} {};
+
+\endcode
+
+This metafunction is somewhat redundat with member_with_tag, but it is included
+because it is a lot easier to metaprogram with it. The result type is the
+same that:
+
+\code
+
+ is_same< member_with_tag<Tag,Relation>::type , member_at::right >::type
+
+\endcode
+
+See also member_with_tag, member_at, is_tag_of_member_at_left.
+\ingroup relation_group
+ **/
+
+
+#ifndef BOOST_BIMAP_DOXYGEN_WILL_NOT_PROCESS_THE_FOLLOWING_LINES
+
+namespace boost {
+namespace bimaps {
+namespace relation {
+namespace support {
+
+// Metafunction is_tag_of_member_at_left
+// Easiear metaprogramming
+
+template
+<
+ class Tag,
+ class Relation,
+ class Enable = void
+>
+struct is_tag_of_member_at_left :
+ ::boost::mpl::false_ {};
+
+template< class Tag, class Relation >
+struct is_tag_of_member_at_left
+<
+ Tag, Relation,
+ BOOST_DEDUCED_TYPENAME enable_if
+ <
+ is_same
+ <
+ BOOST_DEDUCED_TYPENAME member_with_tag<Tag,Relation>::type,
+ member_at::left
+ >
+
+ >::type
+> :
+ ::boost::mpl::true_ {};
+
+// Metafunction is_tag_of_member_at_right
+// Easiear metaprogramming
+
+template
+<
+ class Tag,
+ class Relation,
+ class Enable = void
+>
+struct is_tag_of_member_at_right :
+ ::boost::mpl::false_ {};
+
+template< class Tag, class Relation >
+struct is_tag_of_member_at_right
+<
+ Tag, Relation,
+ BOOST_DEDUCED_TYPENAME enable_if
+ <
+ is_same
+ <
+ BOOST_DEDUCED_TYPENAME member_with_tag<Tag,Relation>::type,
+ member_at::right
+ >
+
+ >::type
+> :
+ ::boost::mpl::true_ {};
+
+
+// Metafunction is_tag_of_member_at_info
+// Easiear metaprogramming
+
+template
+<
+ class Tag,
+ class Relation,
+ class Enable = void
+>
+struct is_tag_of_member_at_info :
+ ::boost::mpl::false_ {};
+
+template< class Tag, class Relation >
+struct is_tag_of_member_at_info
+<
+ Tag, Relation,
+ BOOST_DEDUCED_TYPENAME enable_if
+ <
+ is_same
+ <
+ BOOST_DEDUCED_TYPENAME member_with_tag<Tag,Relation>::type,
+ member_at::info
+ >
+
+ >::type
+> :
+ ::boost::mpl::true_ {};
+
+} // namespace support
+} // namespace relation
+} // namespace bimaps
+} // namespace boost
+
+#endif // BOOST_BIMAP_DOXYGEN_WILL_NOT_PROCESS_THE_FOLLOWING_LINES
+
+#endif // BOOST_BIMAP_RELATION_SUPPORT_IS_TAG_OF_MEMBER_AT_HPP
+
+
diff --git a/boost/bimap/relation/support/member_with_tag.hpp b/boost/bimap/relation/support/member_with_tag.hpp
new file mode 100644
index 0000000..a8324ff
--- /dev/null
+++ b/boost/bimap/relation/support/member_with_tag.hpp
@@ -0,0 +1,180 @@
+// 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 relation/support/member_with_tag.hpp
+/// \brief member_with_tag<tag,relation> metafunction
+
+#ifndef BOOST_BIMAP_RELATION_SUPPORT_MEMBER_WITH_TAG_HPP
+#define BOOST_BIMAP_RELATION_SUPPORT_MEMBER_WITH_TAG_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER>=1200)
+#pragma once
+#endif
+
+#include <boost/config.hpp>
+
+#include <boost/bimap/relation/member_at.hpp>
+#include <boost/bimap/detail/debug/static_error.hpp>
+#include <boost/utility/enable_if.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/mpl/not.hpp>
+#include <boost/mpl/and.hpp>
+
+/** \struct boost::bimaps::relation::support::member_with_tag
+
+\brief Metafunction to convert user tags to the member_at idiom.
+
+\code
+
+template< class Tag, class Relation >
+struct member_with_tag
+{
+ typedef member_at::{side} type;
+};
+
+\endcode
+
+We have to allow that all the metafunctions that works with tags
+and retrieves data from a Relation will work with member_at idiom
+even if the type was tagged. This will be great for the user,
+because he can choose to tag a member after he is using the
+relation and the code will still work.
+
+If we perform this check in every metafunction it will be very
+tedious and error prone, so instead of that all metafunctions
+that works with relations first call this metafunction that
+convert the tag to a member_at tag.
+
+See also member_at, is_tag_of_member_at_left, is_tag_of_member_at_right.
+\ingroup relation_group
+ **/
+
+#ifndef BOOST_BIMAP_DOXYGEN_WILL_NOT_PROCESS_THE_FOLLOWING_LINES
+
+namespace boost {
+namespace bimaps {
+namespace relation {
+namespace support {
+
+template
+<
+ class Tag,
+ class Relation,
+ class Enable = void
+>
+struct member_with_tag
+{
+ BOOST_BIMAP_STATIC_ERROR( MEMBER_WITH_TAG_FAILURE, (Relation,Tag) );
+};
+
+template< class Relation >
+struct member_with_tag
+<
+ member_at::left, Relation, void
+>
+{
+ typedef member_at::left type;
+};
+
+template< class Relation >
+struct member_with_tag
+<
+ member_at::right, Relation, void
+>
+{
+ typedef member_at::right type;
+};
+
+template< class Relation >
+struct member_with_tag
+<
+ member_at::info, Relation, void
+>
+{
+ typedef member_at::info type;
+};
+
+
+template< class Tag, class Relation >
+struct member_with_tag
+<
+ Tag, Relation,
+ BOOST_DEDUCED_TYPENAME enable_if
+ <
+ mpl::and_
+ <
+ mpl::not_< is_same<Tag,member_at::left> >,
+ is_same
+ <
+ Tag,
+ BOOST_DEDUCED_TYPENAME Relation::left_tag
+ >
+ >
+
+ >::type
+>
+{
+ typedef member_at::left type;
+};
+
+template< class Tag, class Relation >
+struct member_with_tag
+<
+ Tag,
+ Relation,
+ BOOST_DEDUCED_TYPENAME enable_if
+ <
+ mpl::and_
+ <
+ mpl::not_< is_same<Tag,member_at::right> >,
+ is_same
+ <
+ Tag,
+ BOOST_DEDUCED_TYPENAME Relation::right_tag
+ >
+ >
+
+ >::type
+>
+{
+ typedef member_at::right type;
+};
+
+template< class Tag, class Relation >
+struct member_with_tag
+<
+ Tag, Relation,
+ BOOST_DEDUCED_TYPENAME enable_if
+ <
+ mpl::and_
+ <
+ mpl::not_< is_same<Tag,member_at::info> >,
+ is_same
+ <
+ Tag,
+ BOOST_DEDUCED_TYPENAME Relation::info_tag
+ >
+ >
+
+ >::type
+>
+{
+ typedef member_at::info type;
+};
+
+} // namespace support
+} // namespace relation
+} // namespace bimaps
+} // namespace boost
+
+#endif // BOOST_BIMAP_DOXYGEN_WILL_NOT_PROCESS_THE_FOLLOWING_LINES
+
+#endif // BOOST_BIMAP_RELATION_SUPPORT_MEMBER_WITH_TAG_HPP
+
+
diff --git a/boost/bimap/relation/support/opposite_tag.hpp b/boost/bimap/relation/support/opposite_tag.hpp
new file mode 100644
index 0000000..174bd98
--- /dev/null
+++ b/boost/bimap/relation/support/opposite_tag.hpp
@@ -0,0 +1,61 @@
+// 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 relation/support/opposite_tag.hpp
+/// \brief Metafunction to obtain the opposite tag in a relation.
+
+#ifndef BOOST_BIMAP_RELATION_SUPPORT_OPPOSITE_TAG_HPP
+#define BOOST_BIMAP_RELATION_SUPPORT_OPPOSITE_TAG_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::relation::support::opposite_tag
+
+\brief Metafunction to obtain the opposite tag in a relation.
+
+\code
+
+template< class Tag, class Relation >
+struct opposite_tag
+{
+ typedef {OppositeTag} type;
+};
+
+\endcode
+
+\ingroup relation_group
+ **/
+
+namespace boost {
+namespace bimaps {
+namespace relation {
+namespace support {
+
+// Implementation of const pair reference type by metafunction
+
+BOOST_BIMAP_SYMMETRIC_METADATA_ACCESS_BUILDER
+(
+ opossite_tag,
+ right_tag,
+ left_tag
+)
+
+} // namespace support
+} // namespace relation
+} // namespace bimaps
+} // namespace boost
+
+
+#endif // BOOST_BIMAP_RELATION_SUPPORT_OPPOSITE_TAG_HPP
+
diff --git a/boost/bimap/relation/support/pair_by.hpp b/boost/bimap/relation/support/pair_by.hpp
new file mode 100644
index 0000000..1ce25fb
--- /dev/null
+++ b/boost/bimap/relation/support/pair_by.hpp
@@ -0,0 +1,120 @@
+// 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 relation/support/pair_by.hpp
+/// \brief pair_by<member>(r) function
+
+#ifndef BOOST_BIMAP_RELATION_SUPPORT_PAIR_BY_HPP
+#define BOOST_BIMAP_RELATION_SUPPORT_PAIR_BY_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER>=1200)
+#pragma once
+#endif
+
+#include <boost/config.hpp>
+
+#include <boost/bimap/relation/support/pair_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 relation {
+namespace support {
+
+/** \brief Gets a pair view of the relation.
+
+\ingroup relation_group
+ **/
+
+template< class Tag, class Relation >
+BOOST_DEDUCED_TYPENAME result_of::pair_by<Tag,Relation>::type
+ pair_by( Relation & rel );
+
+} // namespace support
+} // namespace relation
+} // namespace bimaps
+} // namespace boost
+
+#endif // BOOST_BIMAP_ONLY_DOXYGEN_WILL_PROCESS_THE_FOLLOWING_LINES
+
+
+#ifndef BOOST_BIMAP_DOXYGEN_WILL_NOT_PROCESS_THE_FOLLOWING_LINES
+
+namespace boost {
+namespace bimaps {
+namespace relation {
+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 Relation >
+ struct pair_by<Tag,Relation>;
+ {
+ typedef -unspecified- type;
+ };
+
+ } // namespace result_of
+*/
+
+BOOST_BIMAP_SYMMETRIC_ACCESS_RESULT_OF_BUILDER
+(
+ pair_by,
+ pair_type_by
+)
+
+
+
+// Implementation
+// -------------------------------------------------------------------------
+
+BOOST_BIMAP_SYMMETRIC_ACCESS_IMPLEMENTATION_BUILDER
+(
+ pair_by,
+ Relation,
+ rel,
+ return rel.get_left_pair(),
+ return rel.get_right_pair()
+)
+
+// Interface
+// --------------------------------------------------------------------------
+
+BOOST_BIMAP_SYMMETRIC_ACCESS_INTERFACE_BUILDER
+(
+ pair_by
+)
+
+} // namespace support
+} // namespace relation
+} // namespace bimaps
+} // namespace boost
+
+
+#endif // BOOST_BIMAP_DOXIGEN_WILL_NOT_PROCESS_THE_FOLLOWING_LINES
+
+#endif // BOOST_BIMAP_RELATION_SUPPORT_PAIR_BY_HPP
diff --git a/boost/bimap/relation/support/pair_type_by.hpp b/boost/bimap/relation/support/pair_type_by.hpp
new file mode 100644
index 0000000..64f98d1
--- /dev/null
+++ b/boost/bimap/relation/support/pair_type_by.hpp
@@ -0,0 +1,62 @@
+// 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 relation/support/pair_type_by.hpp
+/// \brief pair_type_by<tag,relation> metafunction
+
+#ifndef BOOST_BIMAP_RELATION_SUPPORT_PAIR_TYPE_BY_HPP
+#define BOOST_BIMAP_RELATION_SUPPORT_PAIR_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::relation::support::pair_type_by
+
+\brief Metafunction to obtain the view type indexed by one of the sides.
+
+\code
+
+template< class Tag, class Relation >
+struct pair_type_by
+{
+ typedef {signature-compatible with std::pair} type;
+};
+
+\endcode
+
+See also member_at, pair_by().
+\ingroup relation_group
+ **/
+
+namespace boost {
+namespace bimaps {
+namespace relation {
+namespace support {
+
+// Implementation of pair type by metafunction
+
+BOOST_BIMAP_SYMMETRIC_METADATA_ACCESS_BUILDER
+(
+ pair_type_by,
+ left_pair,
+ right_pair
+)
+
+} // namespace support
+} // namespace relation
+} // namespace bimaps
+} // namespace boost
+
+
+#endif // BOOST_BIMAP_RELATION_SUPPORT_PAIR_BY_TYPE_HPP
+
diff --git a/boost/bimap/relation/support/value_type_of.hpp b/boost/bimap/relation/support/value_type_of.hpp
new file mode 100644
index 0000000..9dc5761
--- /dev/null
+++ b/boost/bimap/relation/support/value_type_of.hpp
@@ -0,0 +1,91 @@
+// 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 relation/support/value_type_of.hpp
+/// \brief value_type_of<tag,relation> metafunction
+
+#ifndef BOOST_BIMAP_RELATION_SUPPORT_VALUE_TYPE_OF_HPP
+#define BOOST_BIMAP_RELATION_SUPPORT_VALUE_TYPE_OF_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::relation::support::value_type_of
+
+\brief Metafunction to obtain the value type of one of the sides.
+
+\code
+
+template< class Tag, class Relation >
+struct value_type_of
+{
+ typedef typename Relation::{side}_type type;
+};
+
+\endcode
+
+See also member_at, get().
+\ingroup relation_group
+ **/
+
+namespace boost {
+namespace bimaps {
+namespace relation {
+namespace support {
+
+// Metafunction value_type_of
+/*
+
+ template< class Tag, class Relation >
+ struct value_type_of
+ {
+ typedef -unspecified- type;
+ };
+
+*/
+
+BOOST_BIMAP_SYMMETRIC_METADATA_ACCESS_BUILDER
+(
+ value_type_of,
+ left_value_type,
+ right_value_type
+)
+
+// Add support for info tags to value_type_of
+
+template< class Tag, class SymmetricType >
+struct value_type_of
+<
+ Tag, SymmetricType,
+ BOOST_DEDUCED_TYPENAME enable_if
+ <
+ ::boost::bimaps::relation::support::is_tag_of_member_at_info
+ <
+ Tag,
+ SymmetricType
+ >
+
+ >::type
+>
+{
+ typedef BOOST_DEDUCED_TYPENAME SymmetricType::info_type type;
+};
+
+} // namespace support
+} // namespace relation
+} // namespace bimaps
+} // namespace boost
+
+
+#endif // BOOST_BIMAP_RELATION_SUPPORT_VALUE_TYPE_OF_HPP
+
diff --git a/boost/bimap/relation/symmetrical_base.hpp b/boost/bimap/relation/symmetrical_base.hpp
new file mode 100644
index 0000000..ea787c3
--- /dev/null
+++ b/boost/bimap/relation/symmetrical_base.hpp
@@ -0,0 +1,97 @@
+// 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 relation/symmetrical_base.hpp
+/// \brief Base class for symmetrical types
+
+#ifndef BOOST_BIMAP_RELATION_SYMMETRICAL_BASE_HPP
+#define BOOST_BIMAP_RELATION_SYMMETRICAL_BASE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER>=1200)
+#pragma once
+#endif
+
+#include <boost/config.hpp>
+
+#include <boost/mpl/if.hpp>
+#include <boost/type_traits/remove_const.hpp>
+
+// Boost.Bimap
+#include <boost/bimap/tags/tagged.hpp>
+#include <boost/bimap/tags/support/default_tagged.hpp>
+
+#include <boost/bimap/relation/member_at.hpp>
+
+
+namespace boost {
+namespace bimaps {
+namespace relation {
+
+/// \brief Base of symetrical tagged types.
+/**
+
+ **/
+
+template< class TA, class TB, bool force_mutable = false >
+class symmetrical_base
+{
+
+ public:
+
+ typedef BOOST_DEDUCED_TYPENAME tags::support::default_tagged
+ <
+ TA,
+ member_at::left
+
+ >::type tagged_left_type;
+
+ typedef BOOST_DEDUCED_TYPENAME tags::support::default_tagged
+ <
+ TB,
+ member_at::right
+
+ >::type tagged_right_type;
+
+ public:
+
+ //@{
+ /// The type stored in the relation
+
+ typedef BOOST_DEDUCED_TYPENAME ::boost::mpl::if_c< force_mutable,
+
+ BOOST_DEDUCED_TYPENAME ::boost::remove_const<
+ BOOST_DEDUCED_TYPENAME tagged_left_type::value_type >::type,
+ BOOST_DEDUCED_TYPENAME tagged_left_type::value_type
+
+ >::type left_value_type;
+
+ typedef BOOST_DEDUCED_TYPENAME ::boost::mpl::if_c< force_mutable,
+
+ BOOST_DEDUCED_TYPENAME ::boost::remove_const<
+ BOOST_DEDUCED_TYPENAME tagged_right_type::value_type >::type,
+ BOOST_DEDUCED_TYPENAME tagged_right_type::value_type
+
+ >::type right_value_type;
+ //@}
+
+ //@{
+ /// The tag of the member. By default it is \c member_at::{side}
+ typedef BOOST_DEDUCED_TYPENAME tagged_left_type ::tag left_tag;
+ typedef BOOST_DEDUCED_TYPENAME tagged_right_type::tag right_tag;
+ //@}
+};
+
+
+
+} // namespace relation
+} // namespace bimaps
+} // namespace boost
+
+
+#endif // BOOST_BIMAP_RELATION_SYMMETRICAL_BASE_HPP
+
diff --git a/boost/bimap/set_of.hpp b/boost/bimap/set_of.hpp
new file mode 100644
index 0000000..caffa21
--- /dev/null
+++ b/boost/bimap/set_of.hpp
@@ -0,0 +1,206 @@
+// 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 set_of.hpp
+/// \brief Include support for set constrains for the bimap container
+
+#ifndef BOOST_BIMAP_SET_OF_HPP
+#define BOOST_BIMAP_SET_OF_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER>=1200)
+#pragma once
+#endif
+
+#include <boost/config.hpp>
+
+#include <boost/bimap/detail/user_interface_config.hpp>
+
+#include <functional>
+#include <boost/mpl/bool.hpp>
+#include <boost/mpl/aux_/na.hpp>
+
+#include <boost/concept_check.hpp>
+
+#include <boost/bimap/detail/concept_tags.hpp>
+
+#include <boost/bimap/detail/generate_index_binder.hpp>
+#include <boost/bimap/detail/generate_view_binder.hpp>
+#include <boost/bimap/detail/generate_relation_binder.hpp>
+
+#include <boost/bimap/tags/support/value_type_of.hpp>
+
+#include <boost/multi_index/ordered_index.hpp>
+
+#include <boost/bimap/views/map_view.hpp>
+#include <boost/bimap/views/set_view.hpp>
+
+namespace boost {
+namespace bimaps {
+
+/// \brief Set Type Specification
+/**
+This struct is used to specify a set specification.
+It is not a container, it is just a metaprogramming facility to
+express the type of a set. Generally, this specification will
+be used in other place to create a container.
+It has the same syntax that an std::set instantiation, except
+that the allocator cannot be specified. The rationale behind
+this difference is that the allocator is not part of the set
+type specification, rather it is a container configuration
+parameter.
+The first parameter is the type of the objects in the set, and
+the second one is a Functor that compares them.
+Bimap binding metafunctions can be used with this class in
+the following way:
+
+\code
+using namespace support;
+
+BOOST_STATIC_ASSERT( is_set_type_of< set_of<Type> >::value )
+
+BOOST_STATIC_ASSERT
+(
+ is_same
+ <
+ set_of<Type,KeyCompare>::index_bind
+ <
+ KeyExtractor,
+ Tag
+
+ >::type,
+
+ ordered_unique< tag<Tag>, KeyExtractor, KeyCompare >
+
+ >::value
+)
+
+typedef bimap
+<
+ set_of<Type>, RightKeyType
+
+> bimap_with_left_type_as_set;
+
+BOOST_STATIC_ASSERT
+(
+ is_same
+ <
+ set_of<Type>::map_view_bind
+ <
+ member_at::left,
+ bimap_with_left_type_as_set
+
+ >::type,
+
+ map_view< member_at::left, bimap_with_left_type_as_set >
+
+ >::value
+)
+
+\endcode
+
+See also set_of_relation.
+ **/
+
+template
+<
+ class KeyType,
+ class KeyCompare = std::less< BOOST_DEDUCED_TYPENAME
+ ::boost::bimaps::tags::support::value_type_of<KeyType>::type >
+>
+struct set_of : public ::boost::bimaps::detail::set_type_of_tag
+{
+ /// User type, can be tagged
+ typedef KeyType user_type;
+
+ /// Type of the object that will be stored in the set
+ typedef BOOST_DEDUCED_TYPENAME ::boost::bimaps::tags::support::
+ value_type_of<user_type>::type value_type;
+
+ /// Functor that compare two keys
+ typedef KeyCompare key_compare;
+
+ struct lazy_concept_checked
+ {
+ BOOST_CLASS_REQUIRE ( value_type,
+ boost, AssignableConcept );
+
+ BOOST_CLASS_REQUIRE4( key_compare, bool, value_type, value_type,
+ boost, BinaryFunctionConcept );
+
+ typedef set_of type;
+ };
+
+ BOOST_BIMAP_GENERATE_INDEX_BINDER_1CP(
+
+ // binds to
+ multi_index::ordered_unique,
+
+ // with
+ key_compare
+ )
+
+ BOOST_BIMAP_GENERATE_MAP_VIEW_BINDER(
+
+ // binds to
+ views::map_view
+ )
+
+ BOOST_BIMAP_GENERATE_SET_VIEW_BINDER(
+
+ // binds to
+ views::set_view
+ )
+
+ typedef mpl::bool_<false> mutable_key;
+};
+
+
+/// \brief Set Of Relation Specification
+/**
+This struct is similar to set_of but it is bind logically to a
+relation. It is used in the bimap instantiation to specify the
+desired type of the main view. This struct implements internally
+a metafunction named bind_to that manages the quite complicated
+task of finding the right type of the set for the relation.
+
+\code
+template<class Relation>
+struct bind_to
+{
+ typedef -unspecified- type;
+};
+\endcode
+
+See also set_of, is_set_type_of_relation.
+ **/
+
+template< class KeyCompare = std::less< _relation > >
+struct set_of_relation : public ::boost::bimaps::detail::set_type_of_relation_tag
+{
+ /// Functor that compare two keys
+ typedef KeyCompare key_compare;
+
+ BOOST_BIMAP_GENERATE_RELATION_BINDER_1CP(
+
+ // binds to
+ set_of,
+
+ // with
+ key_compare
+ )
+
+ typedef mpl::bool_<false> left_mutable_key;
+ typedef mpl::bool_<false> right_mutable_key;
+};
+
+} // namespace bimaps
+} // namespace boost
+
+
+#endif // BOOST_BIMAP_SET_OF_HPP
+
diff --git a/boost/bimap/support/data_type_by.hpp b/boost/bimap/support/data_type_by.hpp
new file mode 100644
index 0000000..c6d2e2c
--- /dev/null
+++ b/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
+
diff --git a/boost/bimap/support/iterator_type_by.hpp b/boost/bimap/support/iterator_type_by.hpp
new file mode 100644
index 0000000..6d1cff3
--- /dev/null
+++ b/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
+
diff --git a/boost/bimap/support/key_type_by.hpp b/boost/bimap/support/key_type_by.hpp
new file mode 100644
index 0000000..0b4abb5
--- /dev/null
+++ b/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
+
diff --git a/boost/bimap/support/lambda.hpp b/boost/bimap/support/lambda.hpp
new file mode 100644
index 0000000..cffa2c3
--- /dev/null
+++ b/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
+
diff --git a/boost/bimap/support/map_by.hpp b/boost/bimap/support/map_by.hpp
new file mode 100644
index 0000000..ac57f1b
--- /dev/null
+++ b/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
+
diff --git a/boost/bimap/support/map_type_by.hpp b/boost/bimap/support/map_type_by.hpp
new file mode 100644
index 0000000..00b4d20
--- /dev/null
+++ b/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
+
diff --git a/boost/bimap/support/value_type_by.hpp b/boost/bimap/support/value_type_by.hpp
new file mode 100644
index 0000000..a7ce6c0
--- /dev/null
+++ b/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
+
diff --git a/boost/bimap/tags/support/apply_to_value_type.hpp b/boost/bimap/tags/support/apply_to_value_type.hpp
new file mode 100644
index 0000000..bb6aa60
--- /dev/null
+++ b/boost/bimap/tags/support/apply_to_value_type.hpp
@@ -0,0 +1,70 @@
+// 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 tags/support/apply_to_value_type.hpp
+/// \brief Similar to mpl::apply but for tagged types.
+
+#ifndef BOOST_BIMAP_TAGS_SUPPORT_APPLY_TO_VALUE_TYPE_HPP
+#define BOOST_BIMAP_TAGS_SUPPORT_APPLY_TO_VALUE_TYPE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER>=1200)
+#pragma once
+#endif
+
+#include <boost/config.hpp>
+
+#include <boost/bimap/tags/tagged.hpp>
+#include <boost/mpl/apply.hpp>
+
+/** \struct boost::bimaps::tags::support::apply_to_value_type
+\brief Higger order metafunction similar to mpl::apply but for tagged types.
+
+\code
+template< class Metafunction, class TaggedType >
+struct apply_to_value_type
+{
+ typedef tagged
+ <
+ Metafuntion< value_type_of< TaggedType >::type >::type,
+ tag_of< TaggedType >::type
+
+ > type;
+};
+\endcode
+
+This higher order metafunctions is very useful, and it can be used with lambda
+expresions.
+
+See also tagged.
+ **/
+
+#ifndef BOOST_BIMAP_DOXYGEN_WILL_NOT_PROCESS_THE_FOLLOWING_LINES
+
+namespace boost {
+namespace bimaps {
+namespace tags {
+namespace support {
+
+template < class F, class TaggedType >
+struct apply_to_value_type;
+
+template < class F, class ValueType, class Tag >
+struct apply_to_value_type<F, tagged<ValueType,Tag> >
+{
+ typedef BOOST_DEDUCED_TYPENAME mpl::apply< F, ValueType >::type new_value_type;
+ typedef tagged< new_value_type, Tag > type;
+};
+
+} // namespace support
+} // namespace tags
+} // namespace bimaps
+} // namespace boost
+
+#endif // BOOST_BIMAP_DOXYGEN_WILL_NOT_PROCESS_THE_FOLLOWING_LINES
+
+#endif // BOOST_BIMAP_TAGS_SUPPORT_APPLY_TO_VALUE_TYPE_HPP
diff --git a/boost/bimap/tags/support/default_tagged.hpp b/boost/bimap/tags/support/default_tagged.hpp
new file mode 100644
index 0000000..4c02a65
--- /dev/null
+++ b/boost/bimap/tags/support/default_tagged.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 tags/support/default_tagged.hpp
+/// \brief Weak tagging
+
+#ifndef BOOST_BIMAP_TAGS_SUPPORT_DEFAULT_TAGGED_HPP
+#define BOOST_BIMAP_TAGS_SUPPORT_DEFAULT_TAGGED_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER>=1200)
+#pragma once
+#endif
+
+#include <boost/config.hpp>
+
+#include <boost/bimap/tags/tagged.hpp>
+
+/** \struct boost::bimaps::tags::support::default_tagged
+\brief Weak tagging metafunction
+
+\code
+template< class Type, class Tag >
+struct default_tagged
+{
+ typedef {TaggedType} type;
+};
+\endcode
+
+If the type is not tagged, this metafunction returns a tagged type with the
+default tag. If it is tagged, the returns the type unchanged.
+
+See also tagged, overwrite_tagged.
+ **/
+
+#ifndef BOOST_BIMAP_DOXYGEN_WILL_NOT_PROCESS_THE_FOLLOWING_LINES
+
+namespace boost {
+namespace bimaps {
+namespace tags {
+namespace support {
+
+
+// Default Tagging
+// A metafunction that create a tagged type with a default tag value.
+
+template< class Type, class DefaultTag >
+struct default_tagged
+{
+ typedef tagged<Type,DefaultTag> type;
+};
+
+template< class Type, class OldTag, class NewTag >
+struct default_tagged< tagged< Type, OldTag >, NewTag >
+{
+ typedef tagged<Type,OldTag> type;
+};
+
+} // namespace support
+} // namespace tags
+} // namespace bimaps
+} // namespace boost
+
+#endif // BOOST_BIMAP_DOXYGEN_WILL_NOT_PROCESS_THE_FOLLOWING_LINES
+
+#endif // BOOST_BIMAP_TAGS_SUPPORT_DEFAULT_TAGGED_HPP
+
+
+
diff --git a/boost/bimap/tags/support/is_tagged.hpp b/boost/bimap/tags/support/is_tagged.hpp
new file mode 100644
index 0000000..892b3b1
--- /dev/null
+++ b/boost/bimap/tags/support/is_tagged.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 tags/support/is_tagged.hpp
+/// \brief type_traits extension
+
+#ifndef BOOST_BIMAP_TAGS_SUPPORT_IS_TAGGED_HPP
+#define BOOST_BIMAP_TAGS_SUPPORT_IS_TAGGED_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER>=1200)
+#pragma once
+#endif
+
+#include <boost/config.hpp>
+
+#include <boost/mpl/bool.hpp>
+#include <boost/bimap/tags/tagged.hpp>
+
+/** \struct boost::bimaps::tags::support::is_tagged
+\brief Type trait to check if a type is tagged.
+
+\code
+template< class Type >
+struct is_tagged
+{
+ typedef {mpl::true_/mpl::false_} type;
+};
+\endcode
+
+See also tagged.
+ **/
+
+#ifndef BOOST_BIMAP_DOXYGEN_WILL_NOT_PROCESS_THE_FOLLOWING_LINES
+
+namespace boost {
+namespace bimaps {
+namespace tags {
+namespace support {
+
+
+// is_tagged metafunction
+
+template< class Type >
+struct is_tagged :
+ ::boost::mpl::false_ {};
+
+template< class Type, class Tag >
+struct is_tagged< tagged< Type, Tag > > :
+ ::boost::mpl::true_ {};
+
+} // namespace support
+} // namespace tags
+} // namespace bimaps
+} // namespace boost
+
+#endif // BOOST_BIMAP_DOXYGEN_WILL_NOT_PROCESS_THE_FOLLOWING_LINES
+
+#endif // BOOST_BIMAP_TAGS_SUPPORT_IS_TAGGED_HPP
+
diff --git a/boost/bimap/tags/support/overwrite_tagged.hpp b/boost/bimap/tags/support/overwrite_tagged.hpp
new file mode 100644
index 0000000..55cd0fc
--- /dev/null
+++ b/boost/bimap/tags/support/overwrite_tagged.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 tags/support/overwrite_tagged.hpp
+/// \brief Hard tagging
+
+#ifndef BOOST_BIMAP_TAGS_SUPPORT_OVERWRITE_TAGGED_HPP
+#define BOOST_BIMAP_TAGS_SUPPORT_OVERWRITE_TAGGED_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER>=1200)
+#pragma once
+#endif
+
+#include <boost/config.hpp>
+
+#include <boost/bimap/tags/tagged.hpp>
+
+/** \struct boost::bimaps::tags::support::overwrite_tagged
+\brief Hard tagging metafunction
+
+\code
+template< class Type, class Tag >
+struct overwrite_tagged
+{
+ typedef {TaggedType} type;
+};
+\endcode
+
+If the type is not tagged, this metafunction returns a tagged type with the
+passed tag. If it is tagged it returns a new tagged type with the tag replaced
+by the one passed as a parameter.
+
+See also tagged, default_tagged.
+ **/
+
+#ifndef BOOST_BIMAP_DOXYGEN_WILL_NOT_PROCESS_THE_FOLLOWING_LINES
+
+namespace boost {
+namespace bimaps {
+namespace tags {
+namespace support {
+
+
+// Change the tag
+
+template< class Type, class NewTag >
+struct overwrite_tagged
+{
+ typedef tagged<Type,NewTag> type;
+};
+
+template< class Type, class OldTag, class NewTag >
+struct overwrite_tagged< tagged< Type, OldTag >, NewTag >
+{
+ typedef tagged<Type,NewTag> type;
+};
+
+
+} // namespace support
+} // namespace tags
+} // namespace bimaps
+} // namespace boost
+
+#endif // BOOST_BIMAP_DOXYGEN_WILL_NOT_PROCESS_THE_FOLLOWING_LINES
+
+#endif // BOOST_BIMAP_TAGS_SUPPORT_OVERWRITE_TAGGED_HPP
+
+
diff --git a/boost/bimap/tags/support/tag_of.hpp b/boost/bimap/tags/support/tag_of.hpp
new file mode 100644
index 0000000..413703b
--- /dev/null
+++ b/boost/bimap/tags/support/tag_of.hpp
@@ -0,0 +1,75 @@
+// 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 tags/support/tag_of.hpp
+/// \brief Safe way to acces the tag of a type
+
+#ifndef BOOST_BIMAP_TAGS_SUPPORT_TAG_OF_HPP
+#define BOOST_BIMAP_TAGS_SUPPORT_TAG_OF_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER>=1200)
+#pragma once
+#endif
+
+#include <boost/config.hpp>
+
+#include <boost/bimap/tags/tagged.hpp>
+#include <boost/bimap/detail/debug/static_error.hpp>
+
+/** \struct boost::bimaps::tags::support::tag_of
+\brief Metafunction to obtain the tag of a type.
+
+\code
+template< class TaggedType >
+struct tag_of
+{
+ typedef {Tag} type;
+};
+\endcode
+
+If the type is not tagged you will get a compile timer error with the following message:
+
+\verbatim
+USING_TAG_OF_WITH_AN_UNTAGGED_TYPE, TaggedType
+\endverbatim
+
+See also tagged, value_type_of.
+ **/
+
+#ifndef BOOST_BIMAP_DOXYGEN_WILL_NOT_PROCESS_THE_FOLLOWING_LINES
+
+namespace boost {
+namespace bimaps {
+namespace tags {
+namespace support {
+
+
+// tag_of metafunction
+
+template< class Type >
+struct tag_of
+{
+ BOOST_BIMAP_STATIC_ERROR( USING_TAG_OF_WITH_AN_UNTAGGED_TYPE, (Type) );
+};
+
+template< class Type, class Tag >
+struct tag_of< tagged< Type, Tag > >
+{
+ typedef Tag type;
+};
+
+
+} // namespace support
+} // namespace tags
+} // namespace bimaps
+} // namespace boost
+
+#endif // BOOST_BIMAP_DOXYGEN_WILL_NOT_PROCESS_THE_FOLLOWING_LINES
+
+#endif // BOOST_BIMAP_TAGS_SUPPORT_TAG_OF_HPP
+
diff --git a/boost/bimap/tags/support/value_type_of.hpp b/boost/bimap/tags/support/value_type_of.hpp
new file mode 100644
index 0000000..a4ea828
--- /dev/null
+++ b/boost/bimap/tags/support/value_type_of.hpp
@@ -0,0 +1,74 @@
+// 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 tags/support/value_type_of.hpp
+/// \brief Consistent way to access the value type of a tagged or untagged type.
+
+#ifndef BOOST_BIMAP_TAGS_SUPPORT_VALUE_TYPE_OF_HPP
+#define BOOST_BIMAP_TAGS_SUPPORT_VALUE_TYPE_OF_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER>=1200)
+#pragma once
+#endif
+
+#include <boost/config.hpp>
+
+#include <boost/bimap/tags/tagged.hpp>
+
+/** \struct boost::bimaps::tags::support::value_type_of
+\brief Metafunction to work with tagged and untagged type uniformly
+
+\code
+template< class Type >
+struct value_type_of
+{
+ typedef {UntaggedType} type;
+};
+\endcode
+
+If the type is tagged this metafunction returns Type::value_type, and if it is not
+tagged it return the same type. This allows to work consistenly with tagged and
+untagged types.
+
+See also tagged, tag_of.
+ **/
+
+#ifndef BOOST_BIMAP_DOXYGEN_WILL_NOT_PROCESS_THE_FOLLOWING_LINES
+
+
+namespace boost {
+namespace bimaps {
+namespace tags {
+namespace support {
+
+
+// value_type_of metafunction
+
+template< class Type >
+struct value_type_of
+{
+ typedef Type type;
+};
+
+template< class Type, class Tag >
+struct value_type_of< tagged< Type, Tag > >
+{
+ typedef Type type;
+};
+
+
+} // namespace support
+} // namespace tags
+} // namespace bimaps
+} // namespace boost
+
+#endif // BOOST_BIMAP_DOXYGEN_WILL_NOT_PROCESS_THE_FOLLOWING_LINES
+
+#endif // BOOST_BIMAP_TAGS_SUPPORT_VALUE_TYPE_OF_HPP
+
+
diff --git a/boost/bimap/tags/tagged.hpp b/boost/bimap/tags/tagged.hpp
new file mode 100644
index 0000000..ca2a24c
--- /dev/null
+++ b/boost/bimap/tags/tagged.hpp
@@ -0,0 +1,107 @@
+// 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 tags/tagged.hpp
+/// \brief Defines the tagged class
+
+#ifndef BOOST_BIMAP_TAGS_TAGGED_HPP
+#define BOOST_BIMAP_TAGS_TAGGED_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER>=1200)
+#pragma once
+#endif
+
+#include <boost/config.hpp>
+
+namespace boost {
+namespace bimaps {
+
+/// \brief A light non-invasive idiom to tag a type.
+/**
+
+There are a lot of ways of tagging a type. The standard library for example
+defines tags (empty structs) that are then inherited by the tagged class. To
+support built-in types and other types that simple cannot inherit from the
+tag, the standard builds another level of indirection. An example of this is
+the type_traits metafunction. This approach is useful if the tags are intended
+to be used in the library internals, and if the user does not have to create
+new tagged types often.
+
+Boost.MultiIndex is an example of a library that defines a tagged idiom that
+is better suited to the user. As an option, in the indexed by declaration
+of a multi-index container a user can \b attach a tag to each index, so it
+can be referred by it instead of by the index number. It is a very user
+friendly way of specifying a tag but is very invasive from the library writer's
+point of view. Each index must now support this additional parameter. Maybe
+not in the case of the multi-index container, but in simpler classes
+the information of the tags is used by the father class rather than by the
+tagged types.
+
+\b tagged is a light non-invasive idiom to tag a type. It is very intuitive
+and user-friendly. With the use of the defined metafunctions the library
+writer can enjoy the coding too.
+
+ **/
+
+namespace tags {
+
+/// \brief The tag holder
+/**
+
+The idea is to add a level of indirection to the type being tagged. With this
+class you wrapped a type and apply a tag to it. The only thing to remember is
+that if you write
+
+\code
+typedef tagged<type,tag> taggedType;
+\endcode
+
+Then instead to use directly the tagged type, in order to access it you have
+to write \c taggedType::value_type. The tag can be obtained using \c taggedType::tag.
+The idea is not to use this metadata directly but rather using the metafunctions
+that are defined in the support namespace. With this metafunctions you can work
+with tagged and untagged types in a consistent way. For example, the following
+code is valid:
+
+\code
+BOOST_STATIC_ASSERT( is_same< value_type_of<taggedType>, value_type_of<type> >::value );
+\endcode
+
+The are other useful metafunctions there too.
+See also value_type_of, tag_of, is_tagged, apply_to_value_type.
+
+\ingroup tagged_group
+ **/
+template< class Type, class Tag >
+struct tagged
+{
+ typedef Type value_type;
+ typedef Tag tag;
+};
+
+} // namespace tags
+} // namespace bimaps
+} // namespace boost
+
+/** \namespace boost::bimaps::tags::support
+\brief Metafunctions to work with tagged types.
+
+This metafunctions aims to make easier the manage of tagged types. They are all mpl
+compatible metafunctions and can be used with lambda expresions.
+The metafunction value_type_of and tag_of get the data in a tagged type in a secure
+and consistent way.
+default_tagged and overwrite_tagged allows to work with the tag of a tagged type,
+and apply_to_value_type is a higher order metafunction that allow the user to change
+the type of a TaggedType.
+ **/
+
+#endif // BOOST_BIMAP_TAGS_TAGGED_HPP
+
+
+
+
diff --git a/boost/bimap/unconstrained_set_of.hpp b/boost/bimap/unconstrained_set_of.hpp
new file mode 100644
index 0000000..0fcf946
--- /dev/null
+++ b/boost/bimap/unconstrained_set_of.hpp
@@ -0,0 +1,150 @@
+// 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 unconstrained_set_of.hpp
+/// \brief Include support for set constrains for the bimap container
+
+#ifndef BOOST_BIMAP_UNCONSTRAINED_SET_OF_HPP
+#define BOOST_BIMAP_UNCONSTRAINED_SET_OF_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER>=1200)
+#pragma once
+#endif
+
+#include <boost/config.hpp>
+
+#include <boost/bimap/detail/user_interface_config.hpp>
+
+#include <boost/mpl/bool.hpp>
+
+#include <boost/concept_check.hpp>
+
+#include <boost/bimap/detail/concept_tags.hpp>
+
+#include <boost/bimap/tags/support/value_type_of.hpp>
+
+#include <boost/bimap/detail/generate_index_binder.hpp>
+#include <boost/bimap/detail/generate_view_binder.hpp>
+#include <boost/bimap/detail/generate_relation_binder.hpp>
+
+#include <boost/bimap/views/unconstrained_map_view.hpp>
+#include <boost/bimap/views/unconstrained_set_view.hpp>
+
+namespace boost {
+namespace bimaps {
+
+/// \brief Set Type Specification
+/**
+This struct is used to specify a set specification.
+It is not a container, it is just a metaprogramming facility to
+express the type of a set. Generally, this specification will
+be used in other place to create a container.
+The first parameter is the type of the objects in the set.
+
+\code
+
+using namespace support;
+
+BOOST_STATIC_ASSERT( is_set_type_of< unconstrained_set_of<Type> >::value )
+
+\endcode
+
+See also unconstrained_set_of_relation.
+ **/
+
+template
+<
+ class KeyType
+>
+struct unconstrained_set_of : public ::boost::bimaps::detail::set_type_of_tag
+{
+ /// User type, can be tagged
+ typedef KeyType user_type;
+
+ /// Type of the object that will be stored in the container
+ typedef BOOST_DEDUCED_TYPENAME ::boost::bimaps::tags::support::
+ value_type_of<user_type>::type value_type;
+
+ struct lazy_concept_checked
+ {
+ BOOST_CLASS_REQUIRE ( value_type,
+ boost, AssignableConcept );
+
+ typedef unconstrained_set_of type;
+ };
+
+ BOOST_BIMAP_GENERATE_INDEX_BINDER_FAKE
+
+ BOOST_BIMAP_GENERATE_MAP_VIEW_BINDER(
+
+ // binds to
+ views::unconstrained_map_view
+ )
+
+ BOOST_BIMAP_GENERATE_SET_VIEW_BINDER(
+
+ // binds to
+ views::unconstrained_set_view
+ )
+
+ typedef mpl::bool_<true> mutable_key;
+};
+
+/// \brief Set Of Relation Specification
+/**
+This struct is similar to unconstrained_set_of but it is bind
+logically to a relation. It is used in the bimap instantiation to
+specify the desired type of the main view.
+
+See also unconstrained_set_of, is_set_type_of_relation.
+ **/
+
+struct unconstrained_set_of_relation : public ::boost::bimaps::detail::set_type_of_relation_tag
+{
+
+ BOOST_BIMAP_GENERATE_RELATION_BINDER_0CP(
+
+ // binds to
+ unconstrained_set_of
+ )
+
+ typedef mpl::bool_<true> left_mutable_key;
+ typedef mpl::bool_<true> right_mutable_key;
+};
+
+#ifndef BOOST_BIMAP_DOXYGEN_WILL_NOT_PROCESS_THE_FOLLOWING_LINES
+
+namespace detail {
+
+template<class T>
+struct is_unconstrained_set_of :
+ ::boost::mpl::false_ {};
+
+template<class T>
+struct is_unconstrained_set_of< unconstrained_set_of<T> > :
+ ::boost::mpl::true_ {};
+
+} // namespace detail
+
+#endif // BOOST_BIMAP_DOXYGEN_WILL_NOT_PROCESS_THE_FOLLOWING_LINES
+
+} // namespace bimaps
+} // namespace boost
+
+
+/** \struct boost::bimaps::detail::is_unconstrained_set_of
+\brief Trait to check if a type is unconstrained_set_of.
+\code
+template< class T >
+struct is_unconstrained_set_of;
+\endcode
+ **/
+
+
+#endif // BOOST_BIMAP_UNCONSTRAINED_SET_OF_HPP
+
diff --git a/boost/bimap/unordered_multiset_of.hpp b/boost/bimap/unordered_multiset_of.hpp
new file mode 100644
index 0000000..3ff499d
--- /dev/null
+++ b/boost/bimap/unordered_multiset_of.hpp
@@ -0,0 +1,233 @@
+// 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 unordered_multiset_of.hpp
+/// \brief Include support for unordered_multiset constrains for the bimap container
+
+#ifndef BOOST_BIMAP_UNORDERED_MULTISET_OF_HPP
+#define BOOST_BIMAP_UNORDERED_MULTISET_OF_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER>=1200)
+#pragma once
+#endif
+
+#include <boost/config.hpp>
+
+#include <boost/bimap/detail/user_interface_config.hpp>
+
+#include <cstdlib>
+#include <functional>
+#include <boost/functional/hash.hpp>
+#include <boost/mpl/bool.hpp>
+
+#include <boost/concept_check.hpp>
+
+#include <boost/bimap/detail/concept_tags.hpp>
+
+#include <boost/bimap/tags/support/value_type_of.hpp>
+
+#include <boost/bimap/detail/generate_index_binder.hpp>
+#include <boost/bimap/detail/generate_view_binder.hpp>
+#include <boost/bimap/detail/generate_relation_binder.hpp>
+
+#include <boost/multi_index/hashed_index.hpp>
+
+#include <boost/bimap/views/unordered_multimap_view.hpp>
+#include <boost/bimap/views/unordered_multiset_view.hpp>
+
+namespace boost {
+namespace bimaps {
+
+
+/// \brief Set Type Specification
+/**
+This struct is used to specify an unordered_multiset specification.
+It is not a container, it is just a metaprogramming facility to
+express the type of a set. Generally, this specification will
+be used in other place to create a container.
+It has the same syntax that an tr1::unordered_multiset instantiation,
+except that the allocator cannot be specified. The rationale behind
+this difference is that the allocator is not part of the
+unordered_multiset type specification, rather it is a container
+configuration parameter.
+The first parameter is the type of the objects in the set, the
+second one is a Hash Functor that takes objects of this type, and
+the third one is a Functor that compares them for equality.
+Bimap binding metafunctions can be used with this class in
+the following way:
+
+\code
+using namespace support;
+
+BOOST_STATIC_ASSERT( is_set_type_of< unordered_multiset_of<Type> >::value )
+
+BOOST_STATIC_ASSERT
+(
+ is_same
+ <
+ compute_index_type
+ <
+ unordered_multiset_of<Type,HashFunctor,EqualKey>,
+ KeyExtractor,
+ Tag
+
+ >::type
+ ,
+ hashed_nonunique< tag<Tag>, KeyExtractor, HashFunctor, EqualKey >
+
+ >::value
+)
+
+typedef bimap
+<
+ unordered_multiset_of<Type>, RightKeyType
+
+> bimap_with_left_type_as_unordered_multiset;
+
+BOOST_STATIC_ASSERT
+(
+ is_same
+ <
+ compute_map_view_type
+ <
+ member_at::left,
+ bimap_with_left_type_as_unordered_multiset
+
+ >::type,
+
+ unordered_multimap_view
+ <
+ member_at::left,
+ bimap_with_left_type_as_unordered_multiset
+ >
+
+ >::value
+)
+
+\endcode
+
+See also unordered_multiset_of_relation.
+ **/
+
+template
+<
+ class KeyType,
+ class HashFunctor = hash< BOOST_DEDUCED_TYPENAME
+ ::boost::bimaps::tags::support::value_type_of<KeyType>::type >,
+ class EqualKey = std::equal_to< BOOST_DEDUCED_TYPENAME
+ ::boost::bimaps::tags::support::value_type_of<KeyType>::type >
+>
+struct unordered_multiset_of : public ::boost::bimaps::detail::set_type_of_tag
+{
+ /// User type, can be tagged
+ typedef KeyType user_type;
+
+ /// Type of the object that will be stored in the container
+ typedef BOOST_DEDUCED_TYPENAME ::boost::bimaps::tags::support::
+ value_type_of<user_type>::type value_type;
+
+ /// Hash Functor that takes value_type objects
+ typedef HashFunctor hasher;
+
+ /// Functor that compare two value_type objects for equality
+ typedef EqualKey key_equal;
+
+ struct lazy_concept_checked
+ {
+ BOOST_CLASS_REQUIRE ( value_type,
+ boost, AssignableConcept );
+
+ BOOST_CLASS_REQUIRE3( hasher, std::size_t, value_type,
+ boost, UnaryFunctionConcept );
+
+ BOOST_CLASS_REQUIRE4( key_equal, bool, value_type, value_type,
+ boost, BinaryFunctionConcept );
+
+ typedef unordered_multiset_of type;
+ };
+
+ BOOST_BIMAP_GENERATE_INDEX_BINDER_2CP(
+
+ // binds to
+ multi_index::hashed_non_unique,
+
+ // with
+ hasher,
+ key_equal
+ )
+
+ BOOST_BIMAP_GENERATE_MAP_VIEW_BINDER(
+
+ // binds to
+ views::unordered_multimap_view
+ )
+
+ BOOST_BIMAP_GENERATE_SET_VIEW_BINDER(
+
+ // binds to
+ views::unordered_multiset_view
+ )
+
+ typedef mpl::bool_<false> mutable_key;
+};
+
+
+/// \brief Set Of Relation Specification
+/**
+This struct is similar to unordered_multiset_of but it is bind logically
+to a relation. It is used in the bimap instantiation to specify the
+desired type of the main view. This struct implements internally
+a metafunction named bind_to that manages the quite complicated
+task of finding the right type of the set for the relation.
+
+\code
+template<class Relation>
+struct bind_to
+{
+ typedef -unspecified- type;
+};
+\endcode
+
+See also unordered_multiset_of, is_set_type_of_relation.
+ **/
+
+template
+<
+ class HashFunctor = hash< _relation >,
+ class EqualKey = std::equal_to< _relation >
+>
+struct unordered_multiset_of_relation : public ::boost::bimaps::detail::set_type_of_relation_tag
+{
+ /// Hash Functor that takes value_type objects
+ typedef HashFunctor hasher;
+
+ /// Functor that compare two value_type objects for equality
+ typedef EqualKey key_equal;
+
+
+ BOOST_BIMAP_GENERATE_RELATION_BINDER_2CP(
+
+ // binds to
+ unordered_multiset_of,
+
+ // with
+ hasher,
+ key_equal
+ )
+
+ typedef mpl::bool_<false> left_mutable_key;
+ typedef mpl::bool_<false> right_mutable_key;
+};
+
+
+} // namespace bimaps
+} // namespace boost
+
+
+#endif // BOOST_BIMAP_UNORDERED_MULTISET_OF_HPP
+
diff --git a/boost/bimap/unordered_set_of.hpp b/boost/bimap/unordered_set_of.hpp
new file mode 100644
index 0000000..146b506
--- /dev/null
+++ b/boost/bimap/unordered_set_of.hpp
@@ -0,0 +1,230 @@
+// 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 unordered_set_of.hpp
+/// \brief Include support for unordered_set constrains for the bimap container
+
+#ifndef BOOST_BIMAP_UNORDERED_SET_OF_HPP
+#define BOOST_BIMAP_UNORDERED_SET_OF_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER>=1200)
+#pragma once
+#endif
+
+#include <boost/config.hpp>
+
+#include <boost/bimap/detail/user_interface_config.hpp>
+
+#include <functional>
+#include <boost/functional/hash.hpp>
+#include <boost/mpl/bool.hpp>
+
+#include <boost/concept_check.hpp>
+
+#include <boost/bimap/detail/concept_tags.hpp>
+
+#include <boost/bimap/tags/support/value_type_of.hpp>
+
+#include <boost/bimap/detail/generate_index_binder.hpp>
+#include <boost/bimap/detail/generate_view_binder.hpp>
+#include <boost/bimap/detail/generate_relation_binder.hpp>
+
+#include <boost/multi_index/hashed_index.hpp>
+
+#include <boost/bimap/views/unordered_map_view.hpp>
+#include <boost/bimap/views/unordered_set_view.hpp>
+
+namespace boost {
+namespace bimaps {
+
+/// \brief Set Type Specification
+/**
+This struct is used to specify an unordered_set specification.
+It is not a container, it is just a metaprogramming facility to
+express the type of a set. Generally, this specification will
+be used in other place to create a container.
+It has the same syntax that an tr1::unordered_set instantiation,
+except that the allocator cannot be specified. The rationale behind
+this difference is that the allocator is not part of the
+unordered_set type specification, rather it is a container
+configuration parameter.
+The first parameter is the type of the objects in the set, the
+second one is a Hash Functor that takes objects of this type, and
+the third one is a Functor that compares them for equality.
+Bimap binding metafunctions can be used with this class in
+the following way:
+
+\code
+using namespace support;
+
+BOOST_STATIC_ASSERT( is_set_type_of< unordered_set_of<Type> >::value )
+
+BOOST_STATIC_ASSERT
+(
+ is_same
+ <
+ unordered_set_of<Type,HashFunctor,EqualKey>::index_bind
+ <
+ KeyExtractor,
+ Tag
+
+ >::type,
+
+ hashed_unique< tag<Tag>, KeyExtractor, HashFunctor, EqualKey >
+
+ >::value
+)
+
+typedef bimap
+<
+ unordered_set_of<Type>, RightKeyType
+
+> bimap_with_left_type_as_unordered_set;
+
+BOOST_STATIC_ASSERT
+(
+ is_same
+ <
+ unordered_set_of<Type>::map_view_bind
+ <
+ member_at::left,
+ bimap_with_left_type_as_unordered_set
+
+ >::type,
+
+ unordered_map_view
+ <
+ member_at::left,
+ bimap_with_left_type_as_unordered_set
+ >
+
+ >::value
+)
+
+\endcode
+
+See also unordered_set_of_relation.
+ **/
+
+template
+<
+ class KeyType,
+ class HashFunctor = hash< BOOST_DEDUCED_TYPENAME
+ ::boost::bimaps::tags::support::value_type_of<KeyType>::type >,
+ class EqualKey = std::equal_to< BOOST_DEDUCED_TYPENAME
+ ::boost::bimaps::tags::support::value_type_of<KeyType>::type >
+>
+struct unordered_set_of : public ::boost::bimaps::detail::set_type_of_tag
+{
+ /// User type, can be tagged
+ typedef KeyType user_type;
+
+ /// Type of the object that will be stored in the container
+ typedef BOOST_DEDUCED_TYPENAME ::boost::bimaps::tags::support::
+ value_type_of<user_type>::type value_type;
+
+ /// Hash Functor that takes value_type objects
+ typedef HashFunctor hasher;
+
+ /// Functor that compare two value_type objects for equality
+ typedef EqualKey key_equal;
+
+ struct lazy_concept_checked
+ {
+ BOOST_CLASS_REQUIRE ( value_type,
+ boost, AssignableConcept );
+
+ BOOST_CLASS_REQUIRE3( hasher, std::size_t, value_type,
+ boost, UnaryFunctionConcept );
+
+ BOOST_CLASS_REQUIRE4( key_equal, bool, value_type, value_type,
+ boost, BinaryFunctionConcept );
+
+ typedef unordered_set_of type;
+ };
+
+ BOOST_BIMAP_GENERATE_INDEX_BINDER_2CP(
+
+ // binds to
+ multi_index::hashed_unique,
+
+ // with
+ hasher,
+ key_equal
+ )
+
+ BOOST_BIMAP_GENERATE_MAP_VIEW_BINDER(
+
+ // binds to
+ views::unordered_map_view
+ )
+
+ BOOST_BIMAP_GENERATE_SET_VIEW_BINDER(
+
+ // binds to
+ views::unordered_set_view
+ )
+
+ typedef mpl::bool_<false> mutable_key;
+};
+
+
+/// \brief Set Of Relation Specification
+/**
+This struct is similar to unordered_set_of but it is bind logically to
+a relation. It is used in the bimap instantiation to specify the
+desired type of the main view. This struct implements internally
+a metafunction named bind_to that manages the quite complicated
+task of finding the right type of the set for the relation.
+
+\code
+template<class Relation>
+struct bind_to
+{
+ typedef -unspecified- type;
+};
+\endcode
+
+See also unordered_set_of, is_set_type_of_relation.
+ **/
+
+template
+<
+ class HashFunctor = hash< _relation >,
+ class EqualKey = std::equal_to< _relation >
+>
+struct unordered_set_of_relation : public ::boost::bimaps::detail::set_type_of_relation_tag
+{
+ /// Hash Functor that takes value_type objects
+ typedef HashFunctor hasher;
+
+ /// Functor that compare two value_type objects for equality
+ typedef EqualKey key_equal;
+
+
+ BOOST_BIMAP_GENERATE_RELATION_BINDER_2CP(
+
+ // binds to
+ unordered_set_of,
+
+ // with
+ hasher,
+ key_equal
+ )
+
+ typedef mpl::bool_<false> left_mutable_key;
+ typedef mpl::bool_<false> right_mutable_key;
+};
+
+
+} // namespace bimaps
+} // namespace boost
+
+
+#endif // BOOST_BIMAP_UNORDERED_SET_OF_HPP
+
diff --git a/boost/bimap/vector_of.hpp b/boost/bimap/vector_of.hpp
new file mode 100644
index 0000000..cacb41f
--- /dev/null
+++ b/boost/bimap/vector_of.hpp
@@ -0,0 +1,186 @@
+// 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 vector_of.hpp
+/// \brief Include support for vector constrains for the bimap container
+
+#ifndef BOOST_BIMAP_VECTOR_OF_HPP
+#define BOOST_BIMAP_VECTOR_OF_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER>=1200)
+#pragma once
+#endif
+
+#include <boost/config.hpp>
+
+#include <boost/bimap/detail/user_interface_config.hpp>
+
+#include <boost/mpl/bool.hpp>
+
+#include <boost/concept_check.hpp>
+
+#include <boost/bimap/detail/concept_tags.hpp>
+
+#include <boost/bimap/tags/support/value_type_of.hpp>
+
+#include <boost/bimap/detail/generate_index_binder.hpp>
+#include <boost/bimap/detail/generate_view_binder.hpp>
+#include <boost/bimap/detail/generate_relation_binder.hpp>
+
+#include <boost/multi_index/random_access_index.hpp>
+
+#include <boost/bimap/views/vector_map_view.hpp>
+#include <boost/bimap/views/vector_set_view.hpp>
+
+namespace boost {
+namespace bimaps {
+
+
+/// \brief Set Type Specification
+/**
+This struct is used to specify a set specification.
+It is not a container, it is just a metaprogramming facility to
+express the type of a set. Generally, this specification will
+be used in other place to create a container.
+It has the same syntax that an std::vector instantiation, except
+that the allocator cannot be specified. The rationale behind
+this difference is that the allocator is not part of the set
+type specification, rather it is a container configuration
+parameter.
+The first parameter is the type of the objects in the set, and
+the second one is a Functor that compares them.
+Bimap binding metafunctions can be used with this class in
+the following way:
+
+\code
+using namespace support;
+
+BOOST_STATIC_ASSERT( is_set_type_of< vector_of<Type> >::value )
+
+BOOST_STATIC_ASSERT
+(
+ is_same
+ <
+ vector_of<Type>::index_bind
+ <
+ KeyExtractor,
+ Tag
+
+ >::type,
+
+ random_access< tag<Tag>, KeyExtractor >
+
+ >::value
+)
+
+typedef bimap
+<
+ vector_of<Type>, RightKeyType
+
+> bimap_with_left_type_as_vector;
+
+BOOST_STATIC_ASSERT
+(
+ is_same
+ <
+ vector_of<Type>::map_view_bind
+ <
+ member_at::left,
+ bimap_with_left_type_as_vector
+
+ >::type,
+
+ vector_map_view< member_at::left, bimap_with_left_type_as_vector >
+
+ >::value
+)
+
+\endcode
+
+See also vector_of_relation.
+ **/
+
+template< class Type >
+struct vector_of : public ::boost::bimaps::detail::set_type_of_tag
+{
+ /// User type, can be tagged
+ typedef Type user_type;
+
+ /// Type of the object that will be stored in the vector
+ typedef BOOST_DEDUCED_TYPENAME ::boost::bimaps::tags::support::
+ value_type_of<user_type>::type value_type;
+
+
+ struct lazy_concept_checked
+ {
+ BOOST_CLASS_REQUIRE ( value_type,
+ boost, AssignableConcept );
+
+ typedef vector_of type;
+ };
+
+ BOOST_BIMAP_GENERATE_INDEX_BINDER_0CP_NO_EXTRACTOR(
+
+ // binds to
+ multi_index::random_access
+ )
+
+ BOOST_BIMAP_GENERATE_MAP_VIEW_BINDER(
+
+ // binds to
+ views::vector_map_view
+ )
+
+ BOOST_BIMAP_GENERATE_SET_VIEW_BINDER(
+
+ // binds to
+ views::vector_set_view
+ )
+
+ typedef mpl::bool_<true> mutable_key;
+};
+
+
+/// \brief Set Of Relation Specification
+/**
+This struct is similar to vector_of but it is bind logically to a
+relation. It is used in the bimap instantiation to specify the
+desired type of the main view. This struct implements internally
+a metafunction named bind_to that manages the quite complicated
+task of finding the right type of the set for the relation.
+
+\code
+template<class Relation>
+struct bind_to
+{
+ typedef -unspecified- type;
+};
+\endcode
+
+See also vector_of, is_set_type_of_relation.
+ **/
+
+struct vector_of_relation : public ::boost::bimaps::detail::set_type_of_relation_tag
+{
+ BOOST_BIMAP_GENERATE_RELATION_BINDER_0CP(
+
+ // binds to
+ vector_of
+ )
+
+ typedef mpl::bool_<true> left_mutable_key;
+ typedef mpl::bool_<true> right_mutable_key;
+};
+
+
+} // namespace bimaps
+} // namespace boost
+
+
+#endif // BOOST_BIMAP_VECTOR_OF_HPP
+
diff --git a/boost/bimap/views/list_map_view.hpp b/boost/bimap/views/list_map_view.hpp
new file mode 100644
index 0000000..2a7d2b1
--- /dev/null
+++ b/boost/bimap/views/list_map_view.hpp
@@ -0,0 +1,182 @@
+// 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 views/list_map_view.hpp
+/// \brief View of a side of a bimap.
+
+#ifndef BOOST_BIMAP_VIEWS_LIST_MAP_VIEW_HPP
+#define BOOST_BIMAP_VIEWS_LIST_MAP_VIEW_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER>=1200)
+#pragma once
+#endif
+
+#include <boost/config.hpp>
+
+#include <boost/bimap/container_adaptor/list_map_adaptor.hpp>
+#include <boost/bimap/relation/support/pair_by.hpp>
+#include <boost/bimap/support/iterator_type_by.hpp>
+#include <boost/bimap/detail/map_view_base.hpp>
+#include <boost/bimap/relation/support/data_extractor.hpp>
+#include <boost/bimap/relation/detail/to_mutable_relation_functor.hpp>
+
+namespace boost {
+namespace bimaps {
+namespace views {
+
+#ifndef BOOST_BIMAP_DOXYGEN_WILL_NOT_PROCESS_THE_FOLLOWING_LINES
+
+template< class Tag, class BimapType >
+struct list_map_view_base
+{
+ typedef ::boost::bimaps::container_adaptor::list_map_adaptor
+ <
+ BOOST_DEDUCED_TYPENAME BimapType::core_type::BOOST_NESTED_TEMPLATE index<Tag>::type,
+ BOOST_DEDUCED_TYPENAME ::boost::bimaps::support::
+ iterator_type_by<Tag,BimapType>::type,
+ BOOST_DEDUCED_TYPENAME ::boost::bimaps::support::
+ const_iterator_type_by<Tag,BimapType>::type,
+ BOOST_DEDUCED_TYPENAME ::boost::bimaps::support::
+ reverse_iterator_type_by<Tag,BimapType>::type,
+ BOOST_DEDUCED_TYPENAME ::boost::bimaps::support::
+ const_reverse_iterator_type_by<Tag,BimapType>::type,
+ ::boost::bimaps::container_adaptor::support::iterator_facade_to_base
+ <
+ BOOST_DEDUCED_TYPENAME ::boost::bimaps::support::
+ iterator_type_by<Tag,BimapType>::type,
+ BOOST_DEDUCED_TYPENAME ::boost::bimaps::support::
+ const_iterator_type_by<Tag,BimapType>::type
+
+ >,
+ ::boost::mpl::na,
+ ::boost::mpl::na,
+ ::boost::bimaps::relation::detail::
+ pair_to_relation_functor<Tag, BOOST_DEDUCED_TYPENAME BimapType::relation >,
+ ::boost::bimaps::relation::support::
+ get_pair_functor<Tag, BOOST_DEDUCED_TYPENAME BimapType::relation >,
+
+ BOOST_DEDUCED_TYPENAME ::boost::bimaps::relation::support::data_extractor
+ <
+ Tag,
+ BOOST_DEDUCED_TYPENAME BimapType::relation
+
+ >::type
+
+ > type;
+};
+
+#endif // BOOST_BIMAP_DOXYGEN_WILL_NOT_PROCESS_THE_FOLLOWING_LINES
+
+/// \brief View of a side of a bimap.
+/**
+
+This class uses container_adaptor and iterator_adaptor to wrapped a index of the
+multi_index bimap core.
+
+See also const_list_map_view.
+ **/
+template< class Tag, class BimapType >
+class list_map_view
+:
+ public list_map_view_base<Tag,BimapType>::type,
+ public ::boost::bimaps::detail::
+ map_view_base< list_map_view<Tag,BimapType>,Tag,BimapType >
+
+{
+ typedef BOOST_DEDUCED_TYPENAME list_map_view_base<Tag,BimapType>::type base_;
+
+ BOOST_BIMAP_MAP_VIEW_BASE_FRIEND(list_map_view,Tag,BimapType)
+
+ public:
+
+ typedef BOOST_DEDUCED_TYPENAME base_::value_type::info_type info_type;
+
+ list_map_view(BOOST_DEDUCED_TYPENAME base_::base_type & c) :
+ base_(c) {}
+
+ list_map_view & operator=(const list_map_view & v)
+ {
+ this->base() = v.base();
+ return *this;
+ }
+
+ BOOST_BIMAP_VIEW_ASSIGN_IMPLEMENTATION(base_)
+
+ BOOST_BIMAP_VIEW_FRONT_BACK_IMPLEMENTATION(base_)
+
+ // Rearrange Operations
+
+ void relocate(BOOST_DEDUCED_TYPENAME base_::iterator position,
+ BOOST_DEDUCED_TYPENAME base_::iterator i)
+ {
+ this->base().relocate(
+ this->template functor<
+ BOOST_DEDUCED_TYPENAME base_::iterator_to_base>()(position),
+ this->template functor<
+ BOOST_DEDUCED_TYPENAME base_::iterator_to_base>()(i)
+ );
+ }
+
+ void relocate(BOOST_DEDUCED_TYPENAME base_::iterator position,
+ BOOST_DEDUCED_TYPENAME base_::iterator first,
+ BOOST_DEDUCED_TYPENAME base_::iterator last)
+ {
+ this->base().relocate(
+ this->template functor<
+ BOOST_DEDUCED_TYPENAME base_::iterator_to_base>()(position),
+ this->template functor<
+ BOOST_DEDUCED_TYPENAME base_::iterator_to_base>()(first),
+ this->template functor<
+ BOOST_DEDUCED_TYPENAME base_::iterator_to_base>()(last)
+ );
+ }
+};
+
+
+} // namespace views
+
+/*===========================================================================*/
+#define BOOST_BIMAP_MAP_VIEW_EXTRA_TYPEDEF(MAP_VIEW,SIDE,TYPENAME) \
+typedef BOOST_DEDUCED_TYPENAME MAP_VIEW::TYPENAME \
+ BOOST_PP_CAT(SIDE,BOOST_PP_CAT(_,TYPENAME));
+/*===========================================================================*/
+
+/*===========================================================================*/
+#define BOOST_BIMAP_MAP_VIEW_EXTRA_TYPEDEFS_BODY(MAP_VIEW,SIDE) \
+ BOOST_BIMAP_MAP_VIEW_EXTRA_TYPEDEF(MAP_VIEW,SIDE,reverse_iterator) \
+ BOOST_BIMAP_MAP_VIEW_EXTRA_TYPEDEF(MAP_VIEW,SIDE,const_reverse_iterator) \
+/*===========================================================================*/
+
+namespace detail {
+
+template< class Tag, class BimapType >
+struct left_map_view_extra_typedefs< ::boost::bimaps::views::list_map_view<Tag,BimapType> >
+{
+ private: typedef ::boost::bimaps::views::list_map_view<Tag,BimapType> map_view_;
+ public : BOOST_BIMAP_MAP_VIEW_EXTRA_TYPEDEFS_BODY(map_view_,left)
+};
+
+template< class Tag, class BimapType >
+struct right_map_view_extra_typedefs< ::boost::bimaps::views::list_map_view<Tag,BimapType> >
+{
+ private: typedef ::boost::bimaps::views::list_map_view<Tag,BimapType> map_view_;
+ public : BOOST_BIMAP_MAP_VIEW_EXTRA_TYPEDEFS_BODY(map_view_,right)
+};
+
+} // namespace detail
+
+/*===========================================================================*/
+#undef BOOST_BIMAP_MAP_VIEW_EXTRA_TYPEDEF
+#undef BOOST_BIMAP_MAP_VIEW_EXTRA_TYPEDEFS_BODY
+/*===========================================================================*/
+
+} // namespace bimaps
+} // namespace boost
+
+#endif // BOOST_BIMAP_VIEWS_LIST_MAP_VIEW_HPP
+
diff --git a/boost/bimap/views/list_set_view.hpp b/boost/bimap/views/list_set_view.hpp
new file mode 100644
index 0000000..ce9c47d
--- /dev/null
+++ b/boost/bimap/views/list_set_view.hpp
@@ -0,0 +1,109 @@
+// 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 views/list_set_view.hpp
+/// \brief View of a side of a bimap that is signature compatible with std::list.
+
+#ifndef BOOST_BIMAP_VIEWS_LIST_SET_VIEW_HPP
+#define BOOST_BIMAP_VIEWS_LIST_SET_VIEW_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER>=1200)
+#pragma once
+#endif
+
+#include <boost/config.hpp>
+
+#include <boost/bimap/container_adaptor/list_adaptor.hpp>
+#include <boost/bimap/detail/set_view_base.hpp>
+#include <boost/bimap/detail/map_view_base.hpp>
+
+namespace boost {
+namespace bimaps {
+namespace views {
+
+/// \brief View of a bimap that is signature compatible with std::list.
+/**
+
+This class uses container_adaptor and iterator_adaptor to wrapped a index of the
+multi_index bimap core so it can be used as a std::list.
+
+See also const_list_set_view.
+ **/
+
+template< class CoreIndex >
+class list_set_view
+:
+ public BOOST_BIMAP_SEQUENCED_SET_VIEW_CONTAINER_ADAPTOR(
+ list_adaptor,
+ CoreIndex,
+ reverse_iterator, const_reverse_iterator
+ ),
+
+ public ::boost::bimaps::detail::
+ set_view_base< list_set_view< CoreIndex >, CoreIndex >
+{
+ BOOST_BIMAP_SET_VIEW_BASE_FRIEND(list_set_view,CoreIndex)
+
+ typedef BOOST_BIMAP_SEQUENCED_SET_VIEW_CONTAINER_ADAPTOR(
+ list_adaptor,
+ CoreIndex,
+ reverse_iterator, const_reverse_iterator
+
+ ) base_;
+
+ public:
+
+ list_set_view(BOOST_DEDUCED_TYPENAME base_::base_type & c) :
+ base_(c) {}
+
+ list_set_view & operator=(const list_set_view & v)
+ {
+ this->base() = v.base();
+ return *this;
+ }
+
+ BOOST_BIMAP_VIEW_ASSIGN_IMPLEMENTATION(base_)
+
+ BOOST_BIMAP_VIEW_FRONT_BACK_IMPLEMENTATION(base_)
+
+ // Rearrange Operations
+
+ void relocate(BOOST_DEDUCED_TYPENAME base_::iterator position,
+ BOOST_DEDUCED_TYPENAME base_::iterator i)
+ {
+ this->base().relocate(
+ this->template functor<
+ BOOST_DEDUCED_TYPENAME base_::iterator_to_base>()(position),
+ this->template functor<
+ BOOST_DEDUCED_TYPENAME base_::iterator_to_base>()(i)
+ );
+ }
+
+ void relocate(BOOST_DEDUCED_TYPENAME base_::iterator position,
+ BOOST_DEDUCED_TYPENAME base_::iterator first,
+ BOOST_DEDUCED_TYPENAME base_::iterator last)
+ {
+ this->base().relocate(
+ this->template functor<
+ BOOST_DEDUCED_TYPENAME base_::iterator_to_base>()(position),
+ this->template functor<
+ BOOST_DEDUCED_TYPENAME base_::iterator_to_base>()(first),
+ this->template functor<
+ BOOST_DEDUCED_TYPENAME base_::iterator_to_base>()(last)
+ );
+ }
+};
+
+
+} // namespace views
+} // namespace bimaps
+} // namespace boost
+
+
+#endif // BOOST_BIMAP_VIEWS_LIST_SET_VIEW_HPP
+
diff --git a/boost/bimap/views/map_view.hpp b/boost/bimap/views/map_view.hpp
new file mode 100644
index 0000000..245b5d6
--- /dev/null
+++ b/boost/bimap/views/map_view.hpp
@@ -0,0 +1,156 @@
+// 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 views/map_view.hpp
+/// \brief View of a side of a bimap that is signature compatible with std::map.
+
+#ifndef BOOST_BIMAP_VIEWS_MAP_VIEW_HPP
+#define BOOST_BIMAP_VIEWS_MAP_VIEW_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER>=1200)
+#pragma once
+#endif
+
+#include <boost/config.hpp>
+
+#include <boost/bimap/container_adaptor/map_adaptor.hpp>
+#include <boost/bimap/detail/map_view_base.hpp>
+
+namespace boost {
+namespace bimaps {
+namespace views {
+
+/// \brief View of a side of a bimap that is signature compatible with std::map.
+/**
+
+This class uses container_adaptor and iterator_adaptor to wrapped a index of the
+multi_index bimap core so it can be used as a std::map.
+
+See also const_map_view.
+ **/
+
+template< class Tag, class BimapType >
+class map_view
+:
+ public BOOST_BIMAP_MAP_VIEW_CONTAINER_ADAPTOR(
+ map_adaptor,
+ Tag,BimapType,
+ reverse_iterator_type_by,const_reverse_iterator_type_by
+ ),
+ public ::boost::bimaps::detail::
+ map_view_base< map_view<Tag,BimapType>,Tag,BimapType >,
+ public ::boost::bimaps::detail::
+ unique_map_view_access< map_view<Tag,BimapType>, Tag, BimapType>::type
+{
+ typedef BOOST_BIMAP_MAP_VIEW_CONTAINER_ADAPTOR(
+ map_adaptor,
+ Tag,BimapType,
+ reverse_iterator_type_by,const_reverse_iterator_type_by
+
+ ) base_;
+
+ BOOST_BIMAP_MAP_VIEW_BASE_FRIEND(map_view,Tag,BimapType)
+
+ typedef BOOST_DEDUCED_TYPENAME ::boost::bimaps::detail::
+ unique_map_view_access<
+ map_view<Tag,BimapType>, Tag, BimapType
+
+ >::type unique_map_view_access_;
+
+ public:
+
+ typedef BOOST_DEDUCED_TYPENAME base_::value_type::info_type info_type;
+
+ map_view(BOOST_DEDUCED_TYPENAME base_::base_type & c) : base_(c) {}
+
+ using unique_map_view_access_::at;
+ using unique_map_view_access_::operator[];
+
+ BOOST_BIMAP_MAP_VIEW_RANGE_IMPLEMENTATION(base_)
+
+ map_view & operator=(const map_view & v)
+ {
+ this->base() = v.base();
+ return *this;
+ }
+
+ // It can be used enable_if here but the error message when there
+ // is no info is very clear like this
+
+ template< class CompatibleKey >
+ const info_type & info_at(const CompatibleKey& k) const
+ {
+ BOOST_DEDUCED_TYPENAME base_::const_iterator iter = this->find(k);
+ if( iter == this->end() )
+ {
+ ::boost::throw_exception(
+ std::out_of_range("bimap<>: invalid key")
+ );
+ }
+ return iter->info;
+ }
+
+ template< class CompatibleKey >
+ info_type & info_at(const CompatibleKey& k)
+ {
+ BOOST_DEDUCED_TYPENAME base_::iterator iter = this->find(k);
+ if( iter == this->end() )
+ {
+ ::boost::throw_exception(
+ std::out_of_range("bimap<>: invalid key")
+ );
+ }
+ return iter->info;
+ }
+};
+
+} // namespace views
+
+/*===========================================================================*/
+#define BOOST_BIMAP_MAP_VIEW_EXTRA_TYPEDEF(MAP_VIEW,SIDE,TYPENAME) \
+typedef BOOST_DEDUCED_TYPENAME MAP_VIEW::TYPENAME \
+ BOOST_PP_CAT(SIDE,BOOST_PP_CAT(_,TYPENAME));
+/*===========================================================================*/
+
+/*===========================================================================*/
+#define BOOST_BIMAP_MAP_VIEW_EXTRA_TYPEDEFS_BODY(MAP_VIEW,SIDE) \
+ BOOST_BIMAP_MAP_VIEW_EXTRA_TYPEDEF(MAP_VIEW,SIDE,reverse_iterator) \
+ BOOST_BIMAP_MAP_VIEW_EXTRA_TYPEDEF(MAP_VIEW,SIDE,const_reverse_iterator) \
+ BOOST_BIMAP_MAP_VIEW_EXTRA_TYPEDEF(MAP_VIEW,SIDE,range_type) \
+ BOOST_BIMAP_MAP_VIEW_EXTRA_TYPEDEF(MAP_VIEW,SIDE,const_range_type) \
+ BOOST_BIMAP_MAP_VIEW_EXTRA_TYPEDEF(MAP_VIEW,SIDE,key_compare)
+/*===========================================================================*/
+
+namespace detail {
+
+template< class Tag, class BimapType >
+struct left_map_view_extra_typedefs< ::boost::bimaps::views::map_view<Tag,BimapType> >
+{
+ private: typedef ::boost::bimaps::views::map_view<Tag,BimapType> map_view_;
+ public : BOOST_BIMAP_MAP_VIEW_EXTRA_TYPEDEFS_BODY(map_view_,left)
+};
+
+template< class Tag, class BimapType >
+struct right_map_view_extra_typedefs< ::boost::bimaps::views::map_view<Tag,BimapType> >
+{
+ private: typedef ::boost::bimaps::views::map_view<Tag,BimapType> map_view_;
+ public : BOOST_BIMAP_MAP_VIEW_EXTRA_TYPEDEFS_BODY(map_view_,right)
+};
+
+} // namespace detail
+
+/*===========================================================================*/
+#undef BOOST_BIMAP_MAP_VIEW_EXTRA_TYPEDEF
+#undef BOOST_BIMAP_MAP_VIEW_EXTRA_TYPEDEFS_BODY
+/*===========================================================================*/
+
+} // namespace bimaps
+} // namespace boost
+
+#endif // BOOST_BIMAP_VIEWS_MAP_VIEW_HPP
+
diff --git a/boost/bimap/views/multimap_view.hpp b/boost/bimap/views/multimap_view.hpp
new file mode 100644
index 0000000..4176949
--- /dev/null
+++ b/boost/bimap/views/multimap_view.hpp
@@ -0,0 +1,123 @@
+// 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 views/multimap_view.hpp
+/// \brief View of a side of a bimap that is signature compatible with std::multimap.
+
+#ifndef BOOST_BIMAP_VIEWS_MULTIMAP_VIEW_HPP
+#define BOOST_BIMAP_VIEWS_MULTIMAP_VIEW_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER>=1200)
+#pragma once
+#endif
+
+#include <boost/config.hpp>
+
+#include <boost/bimap/container_adaptor/multimap_adaptor.hpp>
+#include <boost/bimap/detail/non_unique_views_helper.hpp>
+#include <boost/bimap/support/iterator_type_by.hpp>
+#include <boost/bimap/detail/map_view_base.hpp>
+
+namespace boost {
+namespace bimaps {
+namespace views {
+
+/// \brief View of a side of a bimap that is signature compatible with std::multimap.
+/**
+
+This class uses container_adaptor and iterator_adaptor to wrapped a index of the
+multi_index bimap core so it can be used as a std::multimap.
+
+See also const_multimap_view.
+ **/
+
+template< class Tag, class BimapType >
+class multimap_view
+:
+ public BOOST_BIMAP_MAP_VIEW_CONTAINER_ADAPTOR(
+ multimap_adaptor,
+ Tag,BimapType,
+ reverse_iterator_type_by,const_reverse_iterator_type_by
+ ),
+ public ::boost::bimaps::detail::
+ map_view_base< multimap_view<Tag,BimapType>,Tag,BimapType >
+
+{
+ typedef BOOST_BIMAP_MAP_VIEW_CONTAINER_ADAPTOR(
+ multimap_adaptor,
+ Tag,BimapType,
+ reverse_iterator_type_by,const_reverse_iterator_type_by
+
+ ) base_;
+
+ BOOST_BIMAP_MAP_VIEW_BASE_FRIEND(multimap_view,Tag,BimapType)
+
+ public:
+
+ typedef BOOST_DEDUCED_TYPENAME base_::value_type::info_type info_type;
+
+ multimap_view(BOOST_DEDUCED_TYPENAME base_::base_type & c)
+ : base_(c) {}
+
+ BOOST_BIMAP_MAP_VIEW_RANGE_IMPLEMENTATION(base_)
+
+ multimap_view & operator=(const multimap_view & v)
+ {
+ this->base() = v.base();
+ return *this;
+ }
+
+ BOOST_BIMAP_NON_UNIQUE_VIEW_INSERT_FUNCTIONS
+};
+
+
+} // namespace views
+
+/*===========================================================================*/
+#define BOOST_BIMAP_MAP_VIEW_EXTRA_TYPEDEF(MAP_VIEW,SIDE,TYPENAME) \
+typedef BOOST_DEDUCED_TYPENAME MAP_VIEW::TYPENAME \
+ BOOST_PP_CAT(SIDE,BOOST_PP_CAT(_,TYPENAME));
+/*===========================================================================*/
+
+/*===========================================================================*/
+#define BOOST_BIMAP_MAP_VIEW_EXTRA_TYPEDEFS_BODY(MAP_VIEW,SIDE) \
+ BOOST_BIMAP_MAP_VIEW_EXTRA_TYPEDEF(MAP_VIEW,SIDE,reverse_iterator) \
+ BOOST_BIMAP_MAP_VIEW_EXTRA_TYPEDEF(MAP_VIEW,SIDE,const_reverse_iterator) \
+ BOOST_BIMAP_MAP_VIEW_EXTRA_TYPEDEF(MAP_VIEW,SIDE,range_type) \
+ BOOST_BIMAP_MAP_VIEW_EXTRA_TYPEDEF(MAP_VIEW,SIDE,const_range_type) \
+ BOOST_BIMAP_MAP_VIEW_EXTRA_TYPEDEF(MAP_VIEW,SIDE,key_compare)
+/*===========================================================================*/
+
+namespace detail {
+
+template< class Tag, class BimapType >
+struct left_map_view_extra_typedefs< ::boost::bimaps::views::multimap_view<Tag,BimapType> >
+{
+ private: typedef ::boost::bimaps::views::multimap_view<Tag,BimapType> map_view_;
+ public : BOOST_BIMAP_MAP_VIEW_EXTRA_TYPEDEFS_BODY(map_view_,left)
+};
+
+template< class Tag, class BimapType >
+struct right_map_view_extra_typedefs< ::boost::bimaps::views::multimap_view<Tag,BimapType> >
+{
+ private: typedef ::boost::bimaps::views::multimap_view<Tag,BimapType> map_view_;
+ public : BOOST_BIMAP_MAP_VIEW_EXTRA_TYPEDEFS_BODY(map_view_,right)
+};
+
+} // namespace detail
+
+/*===========================================================================*/
+#undef BOOST_BIMAP_MAP_VIEW_EXTRA_TYPEDEF
+#undef BOOST_BIMAP_MAP_VIEW_EXTRA_TYPEDEFS_BODY
+/*===========================================================================*/
+
+} // namespace bimaps
+} // namespace boost
+
+#endif // BOOST_BIMAP_VIEWS_MAP_VIEW_HPP
+
diff --git a/boost/bimap/views/multiset_view.hpp b/boost/bimap/views/multiset_view.hpp
new file mode 100644
index 0000000..c49230b
--- /dev/null
+++ b/boost/bimap/views/multiset_view.hpp
@@ -0,0 +1,110 @@
+// 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 views/multiset_view.hpp
+/// \brief View of a bimap that is signature compatible with std::multiset.
+
+#ifndef BOOST_BIMAP_VIEWS_MULTISET_VIEW_HPP
+#define BOOST_BIMAP_VIEWS_MULTISET_VIEW_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER>=1200)
+#pragma once
+#endif
+
+#include <boost/config.hpp>
+
+#include <boost/bimap/container_adaptor/multiset_adaptor.hpp>
+#include <boost/bimap/container_adaptor/detail/comparison_adaptor.hpp>
+#include <boost/bimap/detail/non_unique_views_helper.hpp>
+#include <boost/bimap/detail/set_view_base.hpp>
+
+namespace boost {
+namespace bimaps {
+namespace views {
+
+/// \brief View of a bimap that is signature compatible with std::multiset.
+/**
+
+This class uses container_adaptor and iterator_adaptor to wrapped a index of the
+multi_index bimap core so it can be used as a std::multiset.
+
+See also const_multiset_view.
+ **/
+
+template< class CoreIndex >
+class multiset_view
+:
+ public BOOST_BIMAP_SET_VIEW_CONTAINER_ADAPTOR(
+ multiset_adaptor,
+ CoreIndex,
+ reverse_iterator,
+ const_reverse_iterator
+ ),
+
+ public ::boost::bimaps::detail::
+ set_view_base< multiset_view< CoreIndex >, CoreIndex >
+{
+ BOOST_BIMAP_SET_VIEW_BASE_FRIEND(multiset_view, CoreIndex)
+
+ typedef BOOST_BIMAP_SET_VIEW_CONTAINER_ADAPTOR(
+ multiset_adaptor,
+ CoreIndex,
+ reverse_iterator,
+ const_reverse_iterator
+
+ ) base_;
+
+ public:
+
+ multiset_view(BOOST_DEDUCED_TYPENAME base_::base_type & c) : base_(c) {}
+
+ /*
+ template< class LowerBounder, class UpperBounder >
+ std::pair<BOOST_DEDUCED_TYPENAME base_::const_iterator,
+ BOOST_DEDUCED_TYPENAME base_::const_iterator>
+ range(LowerBounder lower,UpperBounder upper) const
+ {
+ return this->base().range(
+
+ ::boost::bimaps::container_adaptor::detail::unary_check_adaptor
+ <
+ LowerBounder,
+ BOOST_DEDUCED_TYPENAME base_::base_type::value_type,
+ BOOST_DEDUCED_TYPENAME base_::value_from_base
+
+ >( lower, this->template functor<
+ BOOST_DEDUCED_TYPENAME base_::value_from_base>() ),
+
+ ::boost::bimaps::container_adaptor::detail::unary_check_adaptor
+ <
+ UpperBounder,
+ BOOST_DEDUCED_TYPENAME base_::base_type::value_type,
+ BOOST_DEDUCED_TYPENAME base_::value_from_base
+
+ >( upper, this->template functor<
+ BOOST_DEDUCED_TYPENAME base_::value_from_base>() )
+
+ );
+ }
+ */
+
+ multiset_view & operator=(const multiset_view & v)
+ {
+ this->base() = v.base(); return *this;
+ }
+
+ BOOST_BIMAP_NON_UNIQUE_VIEW_INSERT_FUNCTIONS
+};
+
+
+} // namespace views
+} // namespace bimaps
+} // namespace boost
+
+#endif // BOOST_BIMAP_VIEWS_MULTISET_VIEW_HPP
+
diff --git a/boost/bimap/views/set_view.hpp b/boost/bimap/views/set_view.hpp
new file mode 100644
index 0000000..8a857af
--- /dev/null
+++ b/boost/bimap/views/set_view.hpp
@@ -0,0 +1,106 @@
+// 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 views/set_view.hpp
+/// \brief View of a bimap that is signature compatible with std::set.
+
+#ifndef BOOST_BIMAP_VIEWS_SET_VIEW_HPP
+#define BOOST_BIMAP_VIEWS_SET_VIEW_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER>=1200)
+#pragma once
+#endif
+
+#include <boost/config.hpp>
+
+#include <boost/bimap/container_adaptor/set_adaptor.hpp>
+#include <boost/bimap/detail/set_view_base.hpp>
+
+namespace boost {
+namespace bimaps {
+namespace views {
+
+/// \brief View of a bimap that is signature compatible with std::set.
+/**
+
+This class uses container_adaptor and iterator_adaptor to wrapped a index of the
+multi_index bimap core so it can be used as a std::set.
+
+See also const_set_view.
+ **/
+
+template< class CoreIndex >
+class set_view
+:
+ public BOOST_BIMAP_SET_VIEW_CONTAINER_ADAPTOR(
+ set_adaptor,
+ CoreIndex,
+ reverse_iterator, const_reverse_iterator
+ ),
+
+ public ::boost::bimaps::detail::
+ set_view_base< set_view< CoreIndex >, CoreIndex >
+{
+ typedef BOOST_BIMAP_SET_VIEW_CONTAINER_ADAPTOR(
+ set_adaptor,
+ CoreIndex,
+ reverse_iterator, const_reverse_iterator
+
+ ) base_;
+
+ BOOST_BIMAP_SET_VIEW_BASE_FRIEND(set_view,CoreIndex)
+
+ public:
+
+ set_view(BOOST_DEDUCED_TYPENAME base_::base_type & c) : base_(c) {}
+
+ /*
+ template< class LowerBounder, class UpperBounder >
+ std::pair<BOOST_DEDUCED_TYPENAME base_::const_iterator,
+ BOOST_DEDUCED_TYPENAME base_::const_iterator>
+ range(LowerBounder lower,UpperBounder upper) const
+ {
+ return this->base().range(
+
+ ::boost::bimaps::container_adaptor::detail::unary_check_adaptor
+ <
+ LowerBounder,
+ BOOST_DEDUCED_TYPENAME base_::base_type::value_type,
+ BOOST_DEDUCED_TYPENAME base_::value_from_base
+
+ >( lower, this->template functor<
+ BOOST_DEDUCED_TYPENAME base_::value_from_base>() ),
+
+ ::boost::bimaps::container_adaptor::detail::unary_check_adaptor
+ <
+ UpperBounder,
+ BOOST_DEDUCED_TYPENAME base_::base_type::value_type,
+ BOOST_DEDUCED_TYPENAME base_::value_from_base
+
+ >( upper, this->template functor<
+ BOOST_DEDUCED_TYPENAME base_::value_from_base>() )
+
+ );
+ }
+ */
+
+ set_view & operator=(const set_view & v)
+ {
+ this->base() = v.base();
+ return *this;
+ }
+};
+
+
+} // namespace views
+} // namespace bimaps
+} // namespace boost
+
+#endif // BOOST_BIMAP_VIEWS_SET_VIEW_HPP
+
+
diff --git a/boost/bimap/views/unconstrained_map_view.hpp b/boost/bimap/views/unconstrained_map_view.hpp
new file mode 100644
index 0000000..da9b4b4
--- /dev/null
+++ b/boost/bimap/views/unconstrained_map_view.hpp
@@ -0,0 +1,44 @@
+// 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 views/unconstrained_map_view.hpp
+/// \brief Unconstrained view of a side of a bimap.
+
+#ifndef BOOST_BIMAP_VIEWS_UNCONSTRAINED_MAP_VIEW_HPP
+#define BOOST_BIMAP_VIEWS_UNCONSTRAINED_MAP_VIEW_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER>=1200)
+#pragma once
+#endif
+
+#include <boost/config.hpp>
+
+namespace boost {
+namespace bimaps {
+namespace views {
+
+/// \brief Unconstrained view of a side of a bimap.
+
+template< class Tag, class BimapType>
+class unconstrained_map_view
+{
+ public:
+ template< class T >
+ unconstrained_map_view(const T & t) {}
+
+ typedef void reference;
+ typedef void const_reference;
+ typedef void info_type;
+};
+
+} // namespace views
+} // namespace bimaps
+} // namespace boost
+
+#endif // BOOST_BIMAP_VIEWS_UNCONSTRAINED_MAP_VIEW_HPP
+
diff --git a/boost/bimap/views/unconstrained_set_view.hpp b/boost/bimap/views/unconstrained_set_view.hpp
new file mode 100644
index 0000000..6b4a6e2
--- /dev/null
+++ b/boost/bimap/views/unconstrained_set_view.hpp
@@ -0,0 +1,42 @@
+// 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 views/unconstrained_set_view.hpp
+/// \brief Unconstrained view of a bimap.
+
+#ifndef BOOST_BIMAP_VIEWS_UNCONSTRAINED_SET_VIEW_HPP
+#define BOOST_BIMAP_VIEWS_UNCONSTRAINED_SET_VIEW_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER>=1200)
+#pragma once
+#endif
+
+#include <boost/config.hpp>
+
+namespace boost {
+namespace bimaps {
+namespace views {
+
+/// \brief Unconstrained view of a bimap.
+
+template< class CoreIndex >
+class unconstrained_set_view
+{
+ public:
+ template< class T >
+ unconstrained_set_view(const T & t) {}
+
+ typedef void iterator;
+ typedef void const_iterator;
+};
+
+} // namespace views
+} // namespace bimaps
+} // namespace boost
+
+#endif // BOOST_BIMAP_VIEWS_UNCONSTRAINED_SET_VIEW_HPP
diff --git a/boost/bimap/views/unordered_map_view.hpp b/boost/bimap/views/unordered_map_view.hpp
new file mode 100644
index 0000000..14813e2
--- /dev/null
+++ b/boost/bimap/views/unordered_map_view.hpp
@@ -0,0 +1,174 @@
+// 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 views/unordered_map_view.hpp
+/// \brief View of a side of a bimap that is signature compatible with tr1::unordered_map.
+
+#ifndef BOOST_BIMAP_VIEWS_UNOREDERED_MAP_VIEW_HPP
+#define BOOST_BIMAP_VIEWS_UNOREDERED_MAP_VIEW_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER>=1200)
+#pragma once
+#endif
+
+#include <boost/config.hpp>
+
+#include <utility>
+
+#include <boost/bimap/container_adaptor/unordered_map_adaptor.hpp>
+#include <boost/bimap/detail/map_view_base.hpp>
+
+namespace boost {
+namespace bimaps {
+namespace views {
+
+/// \brief Map View of a bimap, signature compatible with tr1::unordered_map.
+/**
+
+This class uses container_adaptor and iterator_adaptor to wrapped a index of the
+multi_index bimap core so it can be used as a tr1::unordered_map.
+
+See also const_unordered_map_view.
+ **/
+
+
+template< class Tag, class BimapType >
+class unordered_map_view
+:
+ public BOOST_BIMAP_MAP_VIEW_CONTAINER_ADAPTOR(
+ unordered_map_adaptor,
+ Tag,BimapType,
+ local_iterator_type_by,const_local_iterator_type_by
+ ),
+
+ public ::boost::bimaps::detail::map_view_base<
+ unordered_map_view<Tag,BimapType>,Tag,BimapType >,
+ public ::boost::bimaps::detail::
+ unique_map_view_access<
+ unordered_map_view<Tag,BimapType>, Tag, BimapType>::type
+
+{
+ typedef BOOST_BIMAP_MAP_VIEW_CONTAINER_ADAPTOR(
+ unordered_map_adaptor,
+ Tag,BimapType,
+ local_iterator_type_by,const_local_iterator_type_by
+
+ ) base_;
+
+ BOOST_BIMAP_MAP_VIEW_BASE_FRIEND(unordered_map_view,Tag,BimapType)
+
+ typedef BOOST_DEDUCED_TYPENAME ::boost::bimaps::detail::
+ unique_map_view_access<
+ unordered_map_view<Tag,BimapType>, Tag, BimapType
+
+ >::type unique_map_view_access_;
+
+ public:
+
+ typedef std::pair<
+ BOOST_DEDUCED_TYPENAME base_::iterator,
+ BOOST_DEDUCED_TYPENAME base_::iterator
+ > range_type;
+
+ typedef std::pair<
+ BOOST_DEDUCED_TYPENAME base_::const_iterator,
+ BOOST_DEDUCED_TYPENAME base_::const_iterator
+ > const_range_type;
+
+ typedef BOOST_DEDUCED_TYPENAME base_::value_type::info_type info_type;
+
+ unordered_map_view(BOOST_DEDUCED_TYPENAME base_::base_type & c)
+ : base_(c) {}
+
+ using unique_map_view_access_::at;
+ using unique_map_view_access_::operator[];
+
+ unordered_map_view & operator=(const unordered_map_view & v)
+ {
+ this->base() = v.base();
+ return *this;
+ }
+
+ // It can be used enable_if here but the error message when there
+ // is no info is very clear like this
+
+ template< class CompatibleKey >
+ const info_type & info_at(const CompatibleKey& k) const
+ {
+ BOOST_DEDUCED_TYPENAME base_::const_iterator iter = this->find(k);
+ if( iter == this->end() )
+ {
+ ::boost::throw_exception(
+ std::out_of_range("bimap<>: invalid key")
+ );
+ }
+ return iter->info;
+ }
+
+ template< class CompatibleKey >
+ info_type & info_at(const CompatibleKey& k)
+ {
+ BOOST_DEDUCED_TYPENAME base_::iterator iter = this->find(k);
+ if( iter == this->end() )
+ {
+ ::boost::throw_exception(
+ std::out_of_range("bimap<>: invalid key")
+ );
+ }
+ return iter->info;
+ }
+};
+
+
+} // namespace views
+
+/*===========================================================================*/
+#define BOOST_BIMAP_MAP_VIEW_EXTRA_TYPEDEF(MAP_VIEW,SIDE,TYPENAME) \
+typedef BOOST_DEDUCED_TYPENAME MAP_VIEW::TYPENAME \
+ BOOST_PP_CAT(SIDE,BOOST_PP_CAT(_,TYPENAME));
+/*===========================================================================*/
+
+/*===========================================================================*/
+#define BOOST_BIMAP_MAP_VIEW_EXTRA_TYPEDEFS_BODY(MAP_VIEW,SIDE) \
+ BOOST_BIMAP_MAP_VIEW_EXTRA_TYPEDEF(MAP_VIEW,SIDE,local_iterator) \
+ BOOST_BIMAP_MAP_VIEW_EXTRA_TYPEDEF(MAP_VIEW,SIDE,const_local_iterator) \
+ BOOST_BIMAP_MAP_VIEW_EXTRA_TYPEDEF(MAP_VIEW,SIDE,range_type) \
+ BOOST_BIMAP_MAP_VIEW_EXTRA_TYPEDEF(MAP_VIEW,SIDE,const_range_type) \
+ BOOST_BIMAP_MAP_VIEW_EXTRA_TYPEDEF(MAP_VIEW,SIDE,hasher) \
+ BOOST_BIMAP_MAP_VIEW_EXTRA_TYPEDEF(MAP_VIEW,SIDE,key_equal)
+/*===========================================================================*/
+
+namespace detail {
+
+template< class Tag, class BimapType >
+struct left_map_view_extra_typedefs< ::boost::bimaps::views::unordered_map_view<Tag,BimapType> >
+{
+ private: typedef ::boost::bimaps::views::unordered_map_view<Tag,BimapType> map_view_;
+ public : BOOST_BIMAP_MAP_VIEW_EXTRA_TYPEDEFS_BODY(map_view_,left)
+};
+
+template< class Tag, class BimapType >
+struct right_map_view_extra_typedefs< ::boost::bimaps::views::unordered_map_view<Tag,BimapType> >
+{
+ private: typedef ::boost::bimaps::views::unordered_map_view<Tag,BimapType> map_view_;
+ public : BOOST_BIMAP_MAP_VIEW_EXTRA_TYPEDEFS_BODY(map_view_,right)
+};
+
+} // namespace detail
+
+/*===========================================================================*/
+#undef BOOST_BIMAP_MAP_VIEW_EXTRA_TYPEDEF
+#undef BOOST_BIMAP_MAP_VIEW_EXTRA_TYPEDEFS_BODY
+/*===========================================================================*/
+
+} // namespace bimaps
+} // namespace boost
+
+#endif // BOOST_BIMAP_VIEWS_UNOREDERED_MAP_VIEW_HPP
+
+
diff --git a/boost/bimap/views/unordered_multimap_view.hpp b/boost/bimap/views/unordered_multimap_view.hpp
new file mode 100644
index 0000000..db22205
--- /dev/null
+++ b/boost/bimap/views/unordered_multimap_view.hpp
@@ -0,0 +1,136 @@
+// 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 views/unordered_multimap_view.hpp
+/// \brief View of a side of a bimap that is signature compatible with tr1::unordered_multimap.
+
+#ifndef BOOST_BIMAP_VIEWS_UNOREDERED_MULTIMAP_VIEW_HPP
+#define BOOST_BIMAP_VIEWS_UNOREDERED_MULTIMAP_VIEW_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER>=1200)
+#pragma once
+#endif
+
+#include <boost/config.hpp>
+
+#include <utility>
+
+#include <boost/bimap/container_adaptor/unordered_multimap_adaptor.hpp>
+#include <boost/bimap/detail/non_unique_views_helper.hpp>
+#include <boost/bimap/support/iterator_type_by.hpp>
+#include <boost/bimap/detail/map_view_base.hpp>
+
+namespace boost {
+namespace bimaps {
+namespace views {
+
+/// \brief View of a side of a bimap that is signature compatible with tr1::unordered_multimap.
+/**
+
+This class uses container_adaptor and iterator_adaptor to wrapped a index of the
+multi_index bimap core so it can be used as a tr1::unordered_multimap.
+
+See also const_unordered_multimap_view.
+ **/
+
+template< class Tag, class BimapType >
+class unordered_multimap_view
+:
+ public BOOST_BIMAP_MAP_VIEW_CONTAINER_ADAPTOR(
+ unordered_multimap_adaptor,
+ Tag,BimapType,
+ local_iterator_type_by,const_local_iterator_type_by
+ ),
+
+ public ::boost::bimaps::detail::map_view_base<
+ unordered_multimap_view<Tag,BimapType>,Tag,BimapType >
+
+{
+ typedef BOOST_BIMAP_MAP_VIEW_CONTAINER_ADAPTOR(
+ unordered_multimap_adaptor,
+ Tag,BimapType,
+ local_iterator_type_by,const_local_iterator_type_by
+
+ ) base_;
+
+ BOOST_BIMAP_MAP_VIEW_BASE_FRIEND(unordered_multimap_view,Tag,BimapType)
+
+ public:
+
+ typedef std::pair<
+ BOOST_DEDUCED_TYPENAME base_::iterator,
+ BOOST_DEDUCED_TYPENAME base_::iterator
+ > range_type;
+
+ typedef std::pair<
+ BOOST_DEDUCED_TYPENAME base_::const_iterator,
+ BOOST_DEDUCED_TYPENAME base_::const_iterator
+ > const_range_type;
+
+ typedef BOOST_DEDUCED_TYPENAME base_::value_type::info_type info_type;
+
+ unordered_multimap_view(BOOST_DEDUCED_TYPENAME base_::base_type & c)
+ : base_(c) {}
+
+ BOOST_BIMAP_NON_UNIQUE_VIEW_INSERT_FUNCTIONS
+
+ unordered_multimap_view & operator=(const unordered_multimap_view & v)
+ {
+ this->base() = v.base();
+ return *this;
+ }
+};
+
+
+} // namespace views
+
+/*===========================================================================*/
+#define BOOST_BIMAP_MAP_VIEW_EXTRA_TYPEDEF(MAP_VIEW,SIDE,TYPENAME) \
+typedef BOOST_DEDUCED_TYPENAME MAP_VIEW::TYPENAME \
+ BOOST_PP_CAT(SIDE,BOOST_PP_CAT(_,TYPENAME));
+/*===========================================================================*/
+
+/*===========================================================================*/
+#define BOOST_BIMAP_MAP_VIEW_EXTRA_TYPEDEFS_BODY(MAP_VIEW,SIDE) \
+ BOOST_BIMAP_MAP_VIEW_EXTRA_TYPEDEF(MAP_VIEW,SIDE,local_iterator) \
+ BOOST_BIMAP_MAP_VIEW_EXTRA_TYPEDEF(MAP_VIEW,SIDE,const_local_iterator) \
+ BOOST_BIMAP_MAP_VIEW_EXTRA_TYPEDEF(MAP_VIEW,SIDE,range_type) \
+ BOOST_BIMAP_MAP_VIEW_EXTRA_TYPEDEF(MAP_VIEW,SIDE,const_range_type) \
+ BOOST_BIMAP_MAP_VIEW_EXTRA_TYPEDEF(MAP_VIEW,SIDE,hasher) \
+ BOOST_BIMAP_MAP_VIEW_EXTRA_TYPEDEF(MAP_VIEW,SIDE,key_equal)
+/*===========================================================================*/
+
+namespace detail {
+
+template< class Tag, class BimapType >
+struct left_map_view_extra_typedefs< ::boost::bimaps::views::unordered_multimap_view<Tag,BimapType> >
+{
+ private: typedef ::boost::bimaps::views::unordered_multimap_view<Tag,BimapType> map_view_;
+ public : BOOST_BIMAP_MAP_VIEW_EXTRA_TYPEDEFS_BODY(map_view_,left)
+};
+
+template< class Tag, class BimapType >
+struct right_map_view_extra_typedefs< ::boost::bimaps::views::unordered_multimap_view<Tag,BimapType> >
+{
+ private: typedef ::boost::bimaps::views::unordered_multimap_view<Tag,BimapType> map_view_;
+ public : BOOST_BIMAP_MAP_VIEW_EXTRA_TYPEDEFS_BODY(map_view_,right)
+};
+
+} // namespace detail
+
+/*===========================================================================*/
+#undef BOOST_BIMAP_MAP_VIEW_EXTRA_TYPEDEF
+#undef BOOST_BIMAP_MAP_VIEW_EXTRA_TYPEDEFS_BODY
+/*===========================================================================*/
+
+} // namespace bimaps
+} // namespace boost
+
+#endif // BOOST_BIMAP_VIEWS_UNOREDERED_MULTIMAP_VIEW_HPP
+
+
diff --git a/boost/bimap/views/unordered_multiset_view.hpp b/boost/bimap/views/unordered_multiset_view.hpp
new file mode 100644
index 0000000..3a72e36
--- /dev/null
+++ b/boost/bimap/views/unordered_multiset_view.hpp
@@ -0,0 +1,83 @@
+// 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 views/unordered_multiset_view.hpp
+/// \brief View of a bimap that is signature compatible with tr1::unordered_multiset.
+
+#ifndef BOOST_BIMAP_VIEWS_UNORDERED_MULTISET_VIEW_HPP
+#define BOOST_BIMAP_VIEWS_UNORDERED_MULTISET_VIEW_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER>=1200)
+#pragma once
+#endif
+
+#include <boost/config.hpp>
+
+#include <boost/bimap/container_adaptor/unordered_multiset_adaptor.hpp>
+#include <boost/bimap/detail/non_unique_views_helper.hpp>
+#include <boost/bimap/detail/set_view_base.hpp>
+
+namespace boost {
+namespace bimaps {
+namespace views {
+
+/// \brief View of a bimap that is signature compatible with std::unordered_multiset.
+/**
+
+This class uses container_adaptor and iterator_adaptor to wrapped a index of the
+multi_index bimap core so it can be used as a std::unordered_multiset.
+
+See also const_unordered_multiset_view.
+ **/
+
+template< class CoreIndex >
+class unordered_multiset_view
+:
+ public BOOST_BIMAP_SET_VIEW_CONTAINER_ADAPTOR(
+ unordered_multiset_adaptor,
+ CoreIndex,
+ local_iterator,
+ const_local_iterator
+
+ ),
+
+ public ::boost::bimaps::detail::
+ set_view_base< unordered_multiset_view< CoreIndex >, CoreIndex >
+{
+ BOOST_BIMAP_SET_VIEW_BASE_FRIEND(unordered_multiset_view,CoreIndex)
+
+ typedef BOOST_BIMAP_SET_VIEW_CONTAINER_ADAPTOR(
+ unordered_multiset_adaptor,
+ CoreIndex,
+ local_iterator,
+ const_local_iterator
+
+ ) base_;
+
+ public:
+
+ unordered_multiset_view(BOOST_DEDUCED_TYPENAME base_::base_type & c)
+ : base_(c) {}
+
+ BOOST_BIMAP_NON_UNIQUE_VIEW_INSERT_FUNCTIONS
+
+ unordered_multiset_view & operator=(const unordered_multiset_view & v)
+ {
+ this->base() = v.base();
+ return *this;
+ }
+};
+
+
+} // namespace views
+} // namespace bimaps
+} // namespace boost
+
+#endif // BOOST_BIMAP_VIEWS_UNORDERED_MULTISET_VIEW_HPP
+
+
diff --git a/boost/bimap/views/unordered_set_view.hpp b/boost/bimap/views/unordered_set_view.hpp
new file mode 100644
index 0000000..02187ae
--- /dev/null
+++ b/boost/bimap/views/unordered_set_view.hpp
@@ -0,0 +1,78 @@
+// 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 views/unordered_set_view.hpp
+/// \brief View of a bimap that is signature compatible with tr1::unordered_set.
+
+#ifndef BOOST_BIMAP_VIEWS_UNORDERED_SET_VIEW_HPP
+#define BOOST_BIMAP_VIEWS_UNORDERED_SET_VIEW_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER>=1200)
+#pragma once
+#endif
+
+#include <boost/config.hpp>
+
+#include <boost/bimap/container_adaptor/unordered_set_adaptor.hpp>
+#include <boost/bimap/detail/set_view_base.hpp>
+
+namespace boost {
+namespace bimaps {
+namespace views {
+
+/// \brief View of a bimap that is signature compatible with std::unordered_set.
+/**
+
+This class uses container_adaptor and iterator_adaptor to wrapped a index of the
+multi_index bimap core so it can be used as a std::unordered_set.
+
+See also const_unordered_set_view.
+ **/
+
+template< class CoreIndex >
+class unordered_set_view
+:
+ public BOOST_BIMAP_SET_VIEW_CONTAINER_ADAPTOR(
+ unordered_set_adaptor,
+ CoreIndex,
+ local_iterator,
+ const_local_iterator
+ ),
+
+ public ::boost::bimaps::detail::
+ set_view_base< unordered_set_view< CoreIndex >, CoreIndex >
+{
+ BOOST_BIMAP_SET_VIEW_BASE_FRIEND(unordered_set_view,CoreIndex)
+
+ typedef BOOST_BIMAP_SET_VIEW_CONTAINER_ADAPTOR(
+ unordered_set_adaptor,
+ CoreIndex,
+ local_iterator,
+ const_local_iterator
+
+ ) base_;
+
+ public:
+
+ unordered_set_view(BOOST_DEDUCED_TYPENAME base_::base_type & c)
+ : base_(c) {}
+
+ unordered_set_view & operator=(const unordered_set_view & v)
+ {
+ this->base() = v.base();
+ return *this;
+ }
+};
+
+
+} // namespace views
+} // namespace bimaps
+} // namespace boost
+
+#endif // BOOST_BIMAP_VIEWS_UNORDERED_SET_VIEW_HPP
+
diff --git a/boost/bimap/views/vector_map_view.hpp b/boost/bimap/views/vector_map_view.hpp
new file mode 100644
index 0000000..1837c27
--- /dev/null
+++ b/boost/bimap/views/vector_map_view.hpp
@@ -0,0 +1,306 @@
+// 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 views/vector_map_view.hpp
+/// \brief View of a side of a bimap.
+
+#ifndef BOOST_BIMAP_VIEWS_VECTOR_MAP_VIEW_HPP
+#define BOOST_BIMAP_VIEWS_VECTOR_MAP_VIEW_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER>=1200)
+#pragma once
+#endif
+
+#include <boost/config.hpp>
+
+#include <boost/bimap/container_adaptor/vector_map_adaptor.hpp>
+#include <boost/bimap/support/iterator_type_by.hpp>
+#include <boost/bimap/detail/map_view_base.hpp>
+#include <boost/bimap/container_adaptor/detail/comparison_adaptor.hpp>
+
+namespace boost {
+namespace bimaps {
+namespace views {
+
+/// \brief View of a side of a bimap.
+/**
+
+This class uses container_adaptor and iterator_adaptor to wrapped a index of the
+multi_index bimap core.
+
+See also const_map_view.
+ **/
+template< class Tag, class BimapType >
+class vector_map_view
+:
+ public BOOST_BIMAP_MAP_VIEW_CONTAINER_ADAPTOR(
+ vector_map_adaptor,
+ Tag,BimapType,
+ reverse_iterator_type_by, const_reverse_iterator_type_by
+ ),
+
+ public ::boost::bimaps::detail::
+ map_view_base< vector_map_view<Tag,BimapType>,Tag,BimapType >
+{
+ typedef BOOST_BIMAP_MAP_VIEW_CONTAINER_ADAPTOR(
+ vector_map_adaptor,
+ Tag,BimapType,
+ reverse_iterator_type_by, const_reverse_iterator_type_by
+
+ ) base_;
+
+ BOOST_BIMAP_MAP_VIEW_BASE_FRIEND(vector_map_view,Tag,BimapType)
+
+ typedef BOOST_DEDUCED_TYPENAME ::boost::bimaps::relation::support::data_extractor
+ <
+ Tag,
+ BOOST_DEDUCED_TYPENAME BimapType::relation
+
+ >::type key_from_base_value;
+
+ public:
+
+ typedef BOOST_DEDUCED_TYPENAME base_::value_type::info_type info_type;
+
+ vector_map_view(BOOST_DEDUCED_TYPENAME base_::base_type & c) :
+ base_(c) {}
+
+ vector_map_view & operator=(const vector_map_view & v)
+ {
+ this->base() = v.base();
+ return *this;
+ }
+
+ BOOST_BIMAP_VIEW_ASSIGN_IMPLEMENTATION(base_)
+
+ BOOST_BIMAP_VIEW_FRONT_BACK_IMPLEMENTATION(base_)
+
+ // Lists operations
+
+ void splice(BOOST_DEDUCED_TYPENAME base_::iterator position, vector_map_view & x)
+ {
+ this->base().splice(
+ this->template functor<
+ BOOST_DEDUCED_TYPENAME base_::iterator_to_base>()(position),
+ x.base()
+ );
+ }
+
+ void splice(BOOST_DEDUCED_TYPENAME base_::iterator position,
+ vector_map_view & x,
+ BOOST_DEDUCED_TYPENAME base_::iterator i)
+ {
+ this->base().splice(
+ this->template functor<
+ BOOST_DEDUCED_TYPENAME base_::iterator_to_base>()(position),
+ x.base(),
+ this->template functor<
+ BOOST_DEDUCED_TYPENAME base_::iterator_to_base>()(i)
+ );
+ }
+
+ void splice(BOOST_DEDUCED_TYPENAME base_::iterator position,
+ vector_map_view & x,
+ BOOST_DEDUCED_TYPENAME base_::iterator first,
+ BOOST_DEDUCED_TYPENAME base_::iterator last)
+ {
+ this->base().splice(
+ this->template functor<
+ BOOST_DEDUCED_TYPENAME base_::iterator_to_base>()(position),
+ x.base(),
+ this->template functor<
+ BOOST_DEDUCED_TYPENAME base_::iterator_to_base>()(first),
+ this->template functor<
+ BOOST_DEDUCED_TYPENAME base_::iterator_to_base>()(last)
+ );
+ }
+
+ void remove(BOOST_DEDUCED_TYPENAME ::boost::call_traits<
+ BOOST_DEDUCED_TYPENAME base_::value_type >::param_type value)
+ {
+ this->base().remove(
+ this->template functor<
+ BOOST_DEDUCED_TYPENAME base_::value_to_base>()(value)
+ );
+ }
+
+ template< class Predicate >
+ void remove_if(Predicate pred)
+ {
+ this->base().remove_if(
+ ::boost::bimaps::container_adaptor::detail::unary_check_adaptor
+ <
+ Predicate,
+ BOOST_DEDUCED_TYPENAME base_::base_type::value_type,
+ key_from_base_value
+
+ >( pred, key_from_base_value() )
+ );
+ }
+
+ void unique()
+ {
+ this->base().unique(
+ ::boost::bimaps::container_adaptor::detail::comparison_adaptor
+ <
+ std::equal_to<BOOST_DEDUCED_TYPENAME base_::key_type>,
+ BOOST_DEDUCED_TYPENAME base_::base_type::value_type,
+ key_from_base_value
+
+ >(std::equal_to<BOOST_DEDUCED_TYPENAME base_::key_type>(),
+ key_from_base_value() )
+ );
+ }
+
+ template< class BinaryPredicate >
+ void unique(BinaryPredicate binary_pred)
+ {
+ this->base().unique(
+ ::boost::bimaps::container_adaptor::detail::comparison_adaptor
+ <
+ BinaryPredicate,
+ BOOST_DEDUCED_TYPENAME base_::base_type::value_type,
+ key_from_base_value
+
+ >( binary_pred, key_from_base_value() )
+ );
+ }
+
+ void merge(vector_map_view & x)
+ {
+ this->base().merge(x.base(),
+ ::boost::bimaps::container_adaptor::detail::comparison_adaptor
+ <
+ std::less<BOOST_DEDUCED_TYPENAME base_::key_type>,
+ BOOST_DEDUCED_TYPENAME base_::base_type::value_type,
+ key_from_base_value
+
+ >( std::less<BOOST_DEDUCED_TYPENAME base_::key_type>(),
+ key_from_base_value() )
+ );
+ }
+
+ template< class Compare >
+ void merge(vector_map_view & x, Compare comp)
+ {
+ this->base().merge(x.base(),
+ ::boost::bimaps::container_adaptor::detail::comparison_adaptor
+ <
+ Compare,
+ BOOST_DEDUCED_TYPENAME base_::base_type::value_type,
+ key_from_base_value
+
+ >( comp, key_from_base_value() )
+ );
+ }
+
+ void sort()
+ {
+ this->base().sort(
+ ::boost::bimaps::container_adaptor::detail::comparison_adaptor
+ <
+ std::less<BOOST_DEDUCED_TYPENAME base_::key_type>,
+ BOOST_DEDUCED_TYPENAME base_::base_type::value_type,
+ key_from_base_value
+
+ >( std::less<BOOST_DEDUCED_TYPENAME base_::key_type>(),
+ key_from_base_value() )
+ );
+ }
+
+ template< class Compare >
+ void sort(Compare comp)
+ {
+ this->base().sort(
+ ::boost::bimaps::container_adaptor::detail::comparison_adaptor
+ <
+ Compare,
+ BOOST_DEDUCED_TYPENAME base_::base_type::value_type,
+ key_from_base_value
+
+ >( comp, key_from_base_value() )
+ );
+ }
+
+ void reverse()
+ {
+ this->base().reverse();
+ }
+
+ // Rearrange Operations
+
+ void relocate(BOOST_DEDUCED_TYPENAME base_::iterator position,
+ BOOST_DEDUCED_TYPENAME base_::iterator i)
+ {
+ this->base().relocate(
+ this->template functor<
+ BOOST_DEDUCED_TYPENAME base_::iterator_to_base>()(position),
+ this->template functor<
+ BOOST_DEDUCED_TYPENAME base_::iterator_to_base>()(i)
+ );
+ }
+
+ void relocate(BOOST_DEDUCED_TYPENAME base_::iterator position,
+ BOOST_DEDUCED_TYPENAME base_::iterator first,
+ BOOST_DEDUCED_TYPENAME base_::iterator last)
+ {
+ this->base().relocate(
+ this->template functor<
+ BOOST_DEDUCED_TYPENAME base_::iterator_to_base>()(position),
+ this->template functor<
+ BOOST_DEDUCED_TYPENAME base_::iterator_to_base>()(first),
+ this->template functor<
+ BOOST_DEDUCED_TYPENAME base_::iterator_to_base>()(last)
+ );
+ }
+
+};
+
+
+} // namespace views
+
+/*===========================================================================*/
+#define BOOST_BIMAP_MAP_VIEW_EXTRA_TYPEDEF(MAP_VIEW,SIDE,TYPENAME) \
+typedef BOOST_DEDUCED_TYPENAME MAP_VIEW::TYPENAME \
+ BOOST_PP_CAT(SIDE,BOOST_PP_CAT(_,TYPENAME));
+/*===========================================================================*/
+
+/*===========================================================================*/
+#define BOOST_BIMAP_MAP_VIEW_EXTRA_TYPEDEFS_BODY(MAP_VIEW,SIDE) \
+ BOOST_BIMAP_MAP_VIEW_EXTRA_TYPEDEF(MAP_VIEW,SIDE,reverse_iterator) \
+ BOOST_BIMAP_MAP_VIEW_EXTRA_TYPEDEF(MAP_VIEW,SIDE,const_reverse_iterator) \
+/*===========================================================================*/
+
+namespace detail {
+
+template< class Tag, class BimapType >
+struct left_map_view_extra_typedefs< ::boost::bimaps::views::vector_map_view<Tag,BimapType> >
+{
+ private: typedef ::boost::bimaps::views::vector_map_view<Tag,BimapType> map_view_;
+ public : BOOST_BIMAP_MAP_VIEW_EXTRA_TYPEDEFS_BODY(map_view_,left)
+};
+
+template< class Tag, class BimapType >
+struct right_map_view_extra_typedefs< ::boost::bimaps::views::vector_map_view<Tag,BimapType> >
+{
+ private: typedef ::boost::bimaps::views::vector_map_view<Tag,BimapType> map_view_;
+ public : BOOST_BIMAP_MAP_VIEW_EXTRA_TYPEDEFS_BODY(map_view_,right)
+};
+
+} // namespace detail
+
+/*===========================================================================*/
+#undef BOOST_BIMAP_MAP_VIEW_EXTRA_TYPEDEF
+#undef BOOST_BIMAP_MAP_VIEW_EXTRA_TYPEDEFS_BODY
+/*===========================================================================*/
+
+} // namespace bimaps
+} // namespace boost
+
+#endif // BOOST_BIMAP_VIEWS_VECTOR_MAP_VIEW_HPP
+
diff --git a/boost/bimap/views/vector_set_view.hpp b/boost/bimap/views/vector_set_view.hpp
new file mode 100644
index 0000000..58e347a
--- /dev/null
+++ b/boost/bimap/views/vector_set_view.hpp
@@ -0,0 +1,279 @@
+// 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 views/vector_set_view.hpp
+/// \brief View of a side of a bimap that is signature compatible with std::vector.
+
+#ifndef BOOST_BIMAP_VIEWS_VECTOR_SET_VIEW_HPP
+#define BOOST_BIMAP_VIEWS_VECTOR_SET_VIEW_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER>=1200)
+#pragma once
+#endif
+
+#include <boost/config.hpp>
+
+#include <boost/bimap/container_adaptor/vector_adaptor.hpp>
+#include <boost/bimap/container_adaptor/detail/comparison_adaptor.hpp>
+#include <boost/bimap/detail/set_view_base.hpp>
+#include <boost/bimap/detail/map_view_base.hpp>
+
+namespace boost {
+namespace bimaps {
+namespace views {
+
+/// \brief View of a bimap that is signature compatible with std::vector.
+/**
+
+This class uses container_adaptor and iterator_adaptor to wrapped a index of the
+multi_index bimap core so it can be used as a std::vector.
+
+See also const_set_view.
+ **/
+
+template< class CoreIndex >
+class vector_set_view
+:
+ public BOOST_BIMAP_SEQUENCED_SET_VIEW_CONTAINER_ADAPTOR(
+ vector_adaptor,
+ CoreIndex,
+ reverse_iterator, const_reverse_iterator
+ ),
+
+ public ::boost::bimaps::detail::
+ set_view_base< vector_set_view< CoreIndex >, CoreIndex >
+{
+ BOOST_BIMAP_SET_VIEW_BASE_FRIEND(vector_set_view,CoreIndex)
+
+ typedef BOOST_BIMAP_SEQUENCED_SET_VIEW_CONTAINER_ADAPTOR(
+ vector_adaptor,
+ CoreIndex,
+ reverse_iterator, const_reverse_iterator
+
+ ) base_;
+
+ public:
+
+ vector_set_view(BOOST_DEDUCED_TYPENAME base_::base_type & c) :
+ base_(c) {}
+
+ vector_set_view & operator=(const vector_set_view & v)
+ {
+ this->base() = v.base();
+ return *this;
+ }
+
+ BOOST_BIMAP_VIEW_ASSIGN_IMPLEMENTATION(base_)
+
+ BOOST_BIMAP_VIEW_FRONT_BACK_IMPLEMENTATION(base_)
+
+ // List operations
+
+ void splice(BOOST_DEDUCED_TYPENAME base_::iterator position,
+ vector_set_view & x)
+ {
+ this->base().splice(
+ this->template functor<
+ BOOST_DEDUCED_TYPENAME base_::iterator_to_base>()(position),
+ x.base()
+ );
+ }
+
+ void splice(BOOST_DEDUCED_TYPENAME base_::iterator position,
+ vector_set_view & x,
+ BOOST_DEDUCED_TYPENAME base_::iterator i)
+ {
+ this->base().splice(
+ this->template functor<
+ BOOST_DEDUCED_TYPENAME base_::iterator_to_base>()(position),
+ x.base(),
+ this->template functor<
+ BOOST_DEDUCED_TYPENAME base_::iterator_to_base>()(i)
+ );
+ }
+
+ void splice(BOOST_DEDUCED_TYPENAME base_::iterator position,
+ vector_set_view & x,
+ BOOST_DEDUCED_TYPENAME base_::iterator first,
+ BOOST_DEDUCED_TYPENAME base_::iterator last)
+ {
+ this->base().splice(
+ this->template functor<
+ BOOST_DEDUCED_TYPENAME base_::iterator_to_base>()(position),
+ x.base(),
+ this->template functor<
+ BOOST_DEDUCED_TYPENAME base_::iterator_to_base>()(first),
+ this->template functor<
+ BOOST_DEDUCED_TYPENAME base_::iterator_to_base>()(last)
+ );
+ }
+
+ void remove(BOOST_DEDUCED_TYPENAME ::boost::call_traits<
+ BOOST_DEDUCED_TYPENAME base_::value_type >::param_type value)
+ {
+ this->base().remove(
+ this->template functor<
+ BOOST_DEDUCED_TYPENAME base_::value_to_base>()(value)
+ );
+ }
+
+ template<typename Predicate>
+ void remove_if(Predicate pred)
+ {
+ this->base().remove_if(
+ ::boost::bimaps::container_adaptor::detail::unary_check_adaptor
+ <
+ Predicate,
+ BOOST_DEDUCED_TYPENAME base_::base_type::value_type,
+ BOOST_DEDUCED_TYPENAME base_::value_from_base
+
+ >( pred, this->template functor<
+ BOOST_DEDUCED_TYPENAME base_::value_from_base>() )
+ );
+ }
+
+ void unique()
+ {
+ this->base().unique(
+ ::boost::bimaps::container_adaptor::detail::comparison_adaptor
+ <
+ std::equal_to<BOOST_DEDUCED_TYPENAME base_::value_type>,
+ BOOST_DEDUCED_TYPENAME base_::base_type::value_type,
+ BOOST_DEDUCED_TYPENAME base_::value_from_base
+
+ >(
+ std::equal_to<BOOST_DEDUCED_TYPENAME base_::value_type>(),
+ this->template functor<
+ BOOST_DEDUCED_TYPENAME base_::value_from_base>()
+ )
+ );
+ }
+
+ template< class BinaryPredicate >
+ void unique(BinaryPredicate binary_pred)
+ {
+ this->base().unique(
+ ::boost::bimaps::container_adaptor::detail::comparison_adaptor
+ <
+ BinaryPredicate,
+ BOOST_DEDUCED_TYPENAME base_::base_type::value_type,
+ BOOST_DEDUCED_TYPENAME base_::value_from_base
+
+ >( binary_pred,
+ this->template functor<
+ BOOST_DEDUCED_TYPENAME base_::value_from_base>()
+ )
+ );
+ }
+
+ void merge(vector_set_view & x)
+ {
+ this->base().merge(x.base(),
+ ::boost::bimaps::container_adaptor::detail::comparison_adaptor
+ <
+ std::less<BOOST_DEDUCED_TYPENAME base_::value_type>,
+ BOOST_DEDUCED_TYPENAME base_::base_type::value_type,
+ BOOST_DEDUCED_TYPENAME base_::value_from_base
+
+ >(
+ std::less<BOOST_DEDUCED_TYPENAME base_::value_type>(),
+ this->template functor<
+ BOOST_DEDUCED_TYPENAME base_::value_from_base>()
+ )
+ );
+ }
+
+ template< class Compare >
+ void merge(vector_set_view & x, Compare comp)
+ {
+ this->base().merge(x.base(),
+ ::boost::bimaps::container_adaptor::detail::comparison_adaptor
+ <
+ Compare,
+ BOOST_DEDUCED_TYPENAME base_::base_type::value_type,
+ BOOST_DEDUCED_TYPENAME base_::value_from_base
+
+ >( comp, this->template functor<
+ BOOST_DEDUCED_TYPENAME base_::value_from_base>() )
+ );
+ }
+
+ void sort()
+ {
+ this->base().sort(
+ ::boost::bimaps::container_adaptor::detail::comparison_adaptor
+ <
+ std::less<BOOST_DEDUCED_TYPENAME base_::value_type>,
+ BOOST_DEDUCED_TYPENAME base_::base_type::value_type,
+ BOOST_DEDUCED_TYPENAME base_::value_from_base
+
+ >(
+ std::less<BOOST_DEDUCED_TYPENAME base_::value_type>(),
+ this->template functor<
+ BOOST_DEDUCED_TYPENAME base_::value_from_base>()
+ )
+ );
+ }
+
+ template< class Compare >
+ void sort(Compare comp)
+ {
+ this->base().sort(
+ ::boost::bimaps::container_adaptor::detail::comparison_adaptor
+ <
+ Compare,
+ BOOST_DEDUCED_TYPENAME base_::base_type::value_type,
+ BOOST_DEDUCED_TYPENAME base_::value_from_base
+
+ >( comp, this->template functor<
+ BOOST_DEDUCED_TYPENAME base_::value_from_base>() )
+ );
+ }
+
+ void reverse()
+ {
+ this->base().reverse();
+ }
+
+ // Rearrange Operations
+
+ void relocate(BOOST_DEDUCED_TYPENAME base_::iterator position,
+ BOOST_DEDUCED_TYPENAME base_::iterator i)
+ {
+ this->base().relocate(
+ this->template functor<
+ BOOST_DEDUCED_TYPENAME base_::iterator_to_base>()(position),
+ this->template functor<
+ BOOST_DEDUCED_TYPENAME base_::iterator_to_base>()(i)
+ );
+ }
+
+ void relocate(BOOST_DEDUCED_TYPENAME base_::iterator position,
+ BOOST_DEDUCED_TYPENAME base_::iterator first,
+ BOOST_DEDUCED_TYPENAME base_::iterator last)
+ {
+ this->base().relocate(
+ this->template functor<
+ BOOST_DEDUCED_TYPENAME base_::iterator_to_base>()(position),
+ this->template functor<
+ BOOST_DEDUCED_TYPENAME base_::iterator_to_base>()(first),
+ this->template functor<
+ BOOST_DEDUCED_TYPENAME base_::iterator_to_base>()(last)
+ );
+ }
+
+};
+
+
+} // namespace views
+} // namespace bimaps
+} // namespace boost
+
+
+#endif // BOOST_BIMAP_VIEWS_VECTOR_SET_VIEW_HPP
+