| // 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 |