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