[ceph.git] / ceph / src / boost / libs / intrusive / include / boost / intrusive / detail / tree_value_compare.hpp

//////////////////////////////////////////////////////////////////////////////
//
// (C) Copyright Ion Gaztanaga 2015-2015. 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)
//
// See http://www.boost.org/libs/container for documentation.
//
//////////////////////////////////////////////////////////////////////////////
#ifndef BOOST_INTRUSIVE_DETAIL_TREE_VALUE_COMPARE_HPP
#define BOOST_INTRUSIVE_DETAIL_TREE_VALUE_COMPARE_HPP

#ifndef BOOST_CONFIG_HPP
#  include <boost/config.hpp>
#endif

#if defined(BOOST_HAS_PRAGMA_ONCE)
#  pragma once
#endif

#include <boost/intrusive/detail/workaround.hpp>
#include <boost/intrusive/detail/mpl.hpp>
#include <boost/intrusive/detail/ebo_functor_holder.hpp>
#include <boost/intrusive/pointer_traits.hpp>

namespace boost{
namespace intrusive{

//Needed to support smart references to value types
template <class From, class ValuePtr>
struct disable_if_smartref_to
   : detail::disable_if_c 
      <  detail::is_same
            <From, typename pointer_traits
               <ValuePtr>
                  ::reference>::value
      || detail::is_same
            <From, typename pointer_traits
                     < typename pointer_rebind
                           <ValuePtr, const typename pointer_element<ValuePtr>::type>::type>
                  ::reference>::value
      >
{};

//This function object takes a KeyCompare function object
//and compares values that contains keys using KeyOfValue
template< class ValuePtr, class KeyCompare, class KeyOfValue
        , bool = boost::intrusive::detail::is_same<typename pointer_element<ValuePtr>::type, typename KeyOfValue::type>::value >
struct tree_value_compare
   :  public boost::intrusive::detail::ebo_functor_holder<KeyCompare>
{
   typedef typename pointer_element<ValuePtr>::type   value_type;
   typedef KeyCompare                                 key_compare;
   typedef KeyOfValue                                 key_of_value;
   typedef typename KeyOfValue::type                  key_type;

   typedef boost::intrusive::detail::ebo_functor_holder<KeyCompare> base_t;

   BOOST_INTRUSIVE_FORCEINLINE tree_value_compare()
      :  base_t()
   {}

   BOOST_INTRUSIVE_FORCEINLINE explicit tree_value_compare(const key_compare &kcomp)
      :  base_t(kcomp)
   {}

   BOOST_INTRUSIVE_FORCEINLINE tree_value_compare (const tree_value_compare &x)
      :  base_t(x.base_t::get())
   {}

   BOOST_INTRUSIVE_FORCEINLINE tree_value_compare &operator=(const tree_value_compare &x)
   {  this->base_t::get() = x.base_t::get();   return *this;  }

   BOOST_INTRUSIVE_FORCEINLINE tree_value_compare &operator=(const key_compare &x)
   {  this->base_t::get() = x;   return *this;  }

   BOOST_INTRUSIVE_FORCEINLINE const key_compare &key_comp() const
   {  return static_cast<const key_compare &>(*this);  }

   BOOST_INTRUSIVE_FORCEINLINE bool operator()(const key_type &key1, const key_type &key2) const
   {  return this->key_comp()(key1, key2);  }

   BOOST_INTRUSIVE_FORCEINLINE bool operator()(const value_type &value1, const value_type &value2) const
   {  return this->key_comp()(KeyOfValue()(value1), KeyOfValue()(value2));  }

   BOOST_INTRUSIVE_FORCEINLINE bool operator()(const key_type &key1, const value_type &value2) const
   {  return this->key_comp()(key1, KeyOfValue()(value2));  }

   BOOST_INTRUSIVE_FORCEINLINE bool operator()(const value_type &value1, const key_type &key2) const
   {  return this->key_comp()(KeyOfValue()(value1), key2);  }

   template<class U>
   BOOST_INTRUSIVE_FORCEINLINE bool operator()( const key_type &key1, const U &nonkey2
                                              , typename disable_if_smartref_to<U, ValuePtr>::type* = 0) const
   {  return this->key_comp()(key1, nonkey2);  }

   template<class U>
   BOOST_INTRUSIVE_FORCEINLINE bool operator()( const U &nonkey1, const key_type &key2
                                              , typename disable_if_smartref_to<U, ValuePtr>::type* = 0) const
   {  return this->key_comp()(nonkey1, key2);  }

   template<class U>
   BOOST_INTRUSIVE_FORCEINLINE bool operator()( const value_type &value1, const U &nonvalue2
                                              , typename disable_if_smartref_to<U, ValuePtr>::type* = 0) const
   {  return this->key_comp()(KeyOfValue()(value1), nonvalue2);  }

   template<class U>
   BOOST_INTRUSIVE_FORCEINLINE bool operator()( const U &nonvalue1, const value_type &value2
                                              , typename disable_if_smartref_to<U, ValuePtr>::type* = 0) const
   {  return this->key_comp()(nonvalue1, KeyOfValue()(value2));  }
};

template<class ValuePtr, class KeyCompare, class KeyOfValue>
struct tree_value_compare<ValuePtr, KeyCompare, KeyOfValue, true>
   :  public boost::intrusive::detail::ebo_functor_holder<KeyCompare>
{
   typedef typename pointer_element<ValuePtr>::type   value_type;
   typedef KeyCompare                                 key_compare;
   typedef KeyOfValue                                 key_of_value;
   typedef typename KeyOfValue::type                  key_type;

   typedef boost::intrusive::detail::ebo_functor_holder<KeyCompare> base_t;


   BOOST_INTRUSIVE_FORCEINLINE tree_value_compare()
      :  base_t()
   {}

   BOOST_INTRUSIVE_FORCEINLINE explicit tree_value_compare(const key_compare &kcomp)
      :  base_t(kcomp)
   {}

   BOOST_INTRUSIVE_FORCEINLINE tree_value_compare (const tree_value_compare &x)
      :  base_t(x.base_t::get())
   {}

   BOOST_INTRUSIVE_FORCEINLINE tree_value_compare &operator=(const tree_value_compare &x)
   {  this->base_t::get() = x.base_t::get();   return *this;  }

   BOOST_INTRUSIVE_FORCEINLINE tree_value_compare &operator=(const key_compare &x)
   {  this->base_t::get() = x;   return *this;  }

   BOOST_INTRUSIVE_FORCEINLINE const key_compare &key_comp() const
   {  return static_cast<const key_compare &>(*this);  }

   BOOST_INTRUSIVE_FORCEINLINE bool operator()(const key_type &key1, const key_type &key2) const
   {  return this->key_comp()(key1, key2);  }

   template<class U>
   BOOST_INTRUSIVE_FORCEINLINE bool operator()( const key_type &key1, const U &nonkey2
                                              , typename disable_if_smartref_to<U, ValuePtr>::type* = 0) const
   {  return this->key_comp()(key1, nonkey2);  }

   template<class U>
   BOOST_INTRUSIVE_FORCEINLINE bool operator()(const U &nonkey1, const key_type &key2
                                              , typename disable_if_smartref_to<U, ValuePtr>::type* = 0) const
   {  return this->key_comp()(nonkey1, key2);  }
};

}  //namespace intrusive{
}  //namespace boost{

#endif   //#ifdef BOOST_INTRUSIVE_DETAIL_TREE_VALUE_COMPARE_HPP
Commit	Line	Data
7c673cae FG	1	//////////////////////////////////////////////////////////////////////////////
	2	//
	3	// (C) Copyright Ion Gaztanaga 2015-2015. Distributed under the Boost
	4	// Software License, Version 1.0. (See accompanying file
	5	// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
	6	//
	7	// See http://www.boost.org/libs/container for documentation.
	8	//
	9	//////////////////////////////////////////////////////////////////////////////
	10	#ifndef BOOST_INTRUSIVE_DETAIL_TREE_VALUE_COMPARE_HPP
	11	#define BOOST_INTRUSIVE_DETAIL_TREE_VALUE_COMPARE_HPP
	12
	13	#ifndef BOOST_CONFIG_HPP
	14	# include <boost/config.hpp>
	15	#endif
	16
	17	#if defined(BOOST_HAS_PRAGMA_ONCE)
	18	# pragma once
	19	#endif
	20
	21	#include <boost/intrusive/detail/workaround.hpp>
	22	#include <boost/intrusive/detail/mpl.hpp>
	23	#include <boost/intrusive/detail/ebo_functor_holder.hpp>
	24	#include <boost/intrusive/pointer_traits.hpp>
	25
	26	namespace boost{
	27	namespace intrusive{
	28
	29	//Needed to support smart references to value types
	30	template <class From, class ValuePtr>
	31	struct disable_if_smartref_to
	32	: detail::disable_if_c
	33	< detail::is_same
	34	<From, typename pointer_traits
	35	<ValuePtr>
	36	::reference>::value
	37	\|\| detail::is_same
	38	<From, typename pointer_traits
	39	< typename pointer_rebind
	40	<ValuePtr, const typename pointer_element<ValuePtr>::type>::type>
	41	::reference>::value
	42	>
	43	{};
	44
	45	//This function object takes a KeyCompare function object
	46	//and compares values that contains keys using KeyOfValue
	47	template< class ValuePtr, class KeyCompare, class KeyOfValue
	48	, bool = boost::intrusive::detail::is_same<typename pointer_element<ValuePtr>::type, typename KeyOfValue::type>::value >
	49	struct tree_value_compare
	50	: public boost::intrusive::detail::ebo_functor_holder<KeyCompare>
	51	{
	52	typedef typename pointer_element<ValuePtr>::type value_type;
	53	typedef KeyCompare key_compare;
	54	typedef KeyOfValue key_of_value;
	55	typedef typename KeyOfValue::type key_type;
	56
	57	typedef boost::intrusive::detail::ebo_functor_holder<KeyCompare> base_t;
	58
	59	BOOST_INTRUSIVE_FORCEINLINE tree_value_compare()
	60	: base_t()
	61	{}
	62
	63	BOOST_INTRUSIVE_FORCEINLINE explicit tree_value_compare(const key_compare &kcomp)
	64	: base_t(kcomp)
65	{}
66
67	BOOST_INTRUSIVE_FORCEINLINE tree_value_compare (const tree_value_compare &x)
68	: base_t(x.base_t::get())
69	{}
70
71	BOOST_INTRUSIVE_FORCEINLINE tree_value_compare &operator=(const tree_value_compare &x)
72	{ this->base_t::get() = x.base_t::get(); return *this; }
73
74	BOOST_INTRUSIVE_FORCEINLINE tree_value_compare &operator=(const key_compare &x)
75	{ this->base_t::get() = x; return *this; }
76
77	BOOST_INTRUSIVE_FORCEINLINE const key_compare &key_comp() const
78	{ return static_cast<const key_compare &>(*this); }
79
80	BOOST_INTRUSIVE_FORCEINLINE bool operator()(const key_type &key1, const key_type &key2) const
81	{ return this->key_comp()(key1, key2); }
82
83	BOOST_INTRUSIVE_FORCEINLINE bool operator()(const value_type &value1, const value_type &value2) const
84	{ return this->key_comp()(KeyOfValue()(value1), KeyOfValue()(value2)); }
85
86	BOOST_INTRUSIVE_FORCEINLINE bool operator()(const key_type &key1, const value_type &value2) const
87	{ return this->key_comp()(key1, KeyOfValue()(value2)); }
88
89	BOOST_INTRUSIVE_FORCEINLINE bool operator()(const value_type &value1, const key_type &key2) const
90	{ return this->key_comp()(KeyOfValue()(value1), key2); }
91
92	template<class U>
93	BOOST_INTRUSIVE_FORCEINLINE bool operator()( const key_type &key1, const U &nonkey2
94	, typename disable_if_smartref_to<U, ValuePtr>::type* = 0) const
95	{ return this->key_comp()(key1, nonkey2); }
96
97	template<class U>
98	BOOST_INTRUSIVE_FORCEINLINE bool operator()( const U &nonkey1, const key_type &key2
99	, typename disable_if_smartref_to<U, ValuePtr>::type* = 0) const
100	{ return this->key_comp()(nonkey1, key2); }
101
102	template<class U>
103	BOOST_INTRUSIVE_FORCEINLINE bool operator()( const value_type &value1, const U &nonvalue2
104	, typename disable_if_smartref_to<U, ValuePtr>::type* = 0) const
105	{ return this->key_comp()(KeyOfValue()(value1), nonvalue2); }
106
107	template<class U>
108	BOOST_INTRUSIVE_FORCEINLINE bool operator()( const U &nonvalue1, const value_type &value2
109	, typename disable_if_smartref_to<U, ValuePtr>::type* = 0) const
110	{ return this->key_comp()(nonvalue1, KeyOfValue()(value2)); }
111	};
112
113	template<class ValuePtr, class KeyCompare, class KeyOfValue>
114	struct tree_value_compare<ValuePtr, KeyCompare, KeyOfValue, true>
115	: public boost::intrusive::detail::ebo_functor_holder<KeyCompare>
116	{
117	typedef typename pointer_element<ValuePtr>::type value_type;
118	typedef KeyCompare key_compare;
119	typedef KeyOfValue key_of_value;
120	typedef typename KeyOfValue::type key_type;
121
122	typedef boost::intrusive::detail::ebo_functor_holder<KeyCompare> base_t;
123
124
125	BOOST_INTRUSIVE_FORCEINLINE tree_value_compare()
126	: base_t()
127	{}
128
129	BOOST_INTRUSIVE_FORCEINLINE explicit tree_value_compare(const key_compare &kcomp)
130	: base_t(kcomp)
131	{}
132
133	BOOST_INTRUSIVE_FORCEINLINE tree_value_compare (const tree_value_compare &x)
134	: base_t(x.base_t::get())
135	{}
136
137	BOOST_INTRUSIVE_FORCEINLINE tree_value_compare &operator=(const tree_value_compare &x)
138	{ this->base_t::get() = x.base_t::get(); return *this; }
139
140	BOOST_INTRUSIVE_FORCEINLINE tree_value_compare &operator=(const key_compare &x)
141	{ this->base_t::get() = x; return *this; }
142
143	BOOST_INTRUSIVE_FORCEINLINE const key_compare &key_comp() const
144	{ return static_cast<const key_compare &>(*this); }
145
146	BOOST_INTRUSIVE_FORCEINLINE bool operator()(const key_type &key1, const key_type &key2) const
147	{ return this->key_comp()(key1, key2); }
148
149	template<class U>
150	BOOST_INTRUSIVE_FORCEINLINE bool operator()( const key_type &key1, const U &nonkey2
151	, typename disable_if_smartref_to<U, ValuePtr>::type* = 0) const
152	{ return this->key_comp()(key1, nonkey2); }
153
154	template<class U>
155	BOOST_INTRUSIVE_FORCEINLINE bool operator()(const U &nonkey1, const key_type &key2
156	, typename disable_if_smartref_to<U, ValuePtr>::type* = 0) const
157	{ return this->key_comp()(nonkey1, key2); }
158	};
159
160	} //namespace intrusive{
161	} //namespace boost{
162
163	#endif //#ifdef BOOST_INTRUSIVE_DETAIL_TREE_VALUE_COMPARE_HPP