Added boost header

test/external/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
+
+

test/external/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
+
+

test/external/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
+
+

test/external/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
+
+

test/external/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
+
+