FM / detail

/usr/include/boost/intrusive/detail

Name	Size	Mode	Actions
algorithm.hpp	2880	0644	edit dl rm
algo_type.hpp	1303	0644	edit dl rm
any_node_and_algorithms.hpp	9467	0644	edit dl rm
array_initializer.hpp	2235	0644	edit dl rm
assert.hpp	1520	0644	edit dl rm
avltree_node.hpp	6714	0644	edit dl rm
bstree_algorithms_base.hpp	5523	0644	edit dl rm
common_slist_algorithms.hpp	5974	0644	edit dl rm
config_begin.hpp	2456	0644	edit dl rm
config_end.hpp	496	0644	edit dl rm
default_header_holder.hpp	2243	0644	edit dl rm
ebo_functor_holder.hpp	8005	0644	edit dl rm
empty_node_checker.hpp	1243	0644	edit dl rm
equal_to_value.hpp	1217	0644	edit dl rm
exception_disposer.hpp	2132	0644	edit dl rm
function_detector.hpp	3456	0644	edit dl rm
generic_hook.hpp	6588	0644	edit dl rm
get_value_traits.hpp	7098	0644	edit dl rm
hashtable_node.hpp	10234	0644	edit dl rm
has_member_function_callable_with.hpp	18438	0644	edit dl rm
hook_traits.hpp	8438	0644	edit dl rm
iiterator.hpp	4446	0644	edit dl rm
is_stateful_value_traits.hpp	2524	0644	edit dl rm
iterator.hpp	7612	0644	edit dl rm
key_nodeptr_comp.hpp	4882	0644	edit dl rm
list_iterator.hpp	5230	0644	edit dl rm
list_node.hpp	2152	0644	edit dl rm
math.hpp	8059	0644	edit dl rm
minimal_less_equal_header.hpp	932	0644	edit dl rm
minimal_pair_header.hpp	904	0644	edit dl rm
mpl.hpp	8592	0644	edit dl rm
node_cloner_disposer.hpp	3973	0644	edit dl rm
node_holder.hpp	883	0644	edit dl rm
node_to_value.hpp	3994	0644	edit dl rm
parent_from_member.hpp	4191	0644	edit dl rm
rbtree_node.hpp	6952	0644	edit dl rm
reverse_iterator.hpp	4644	0644	edit dl rm
simple_disposers.hpp	1177	0644	edit dl rm
size_holder.hpp	2261	0644	edit dl rm
slist_iterator.hpp	4968	0644	edit dl rm
slist_node.hpp	1907	0644	edit dl rm
std_fwd.hpp	1226	0644	edit dl rm
transform_iterator.hpp	5789	0644	edit dl rm
tree_iterator.hpp	6605	0644	edit dl rm
tree_node.hpp	2307	0644	edit dl rm
tree_value_compare.hpp	7711	0644	edit dl rm
uncast.hpp	1646	0644	edit dl rm
workaround.hpp	2061	0644	edit dl rm

Edit: /usr/include/boost/intrusive/detail/tree_value_compare.hpp (7711B)

#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 boost::movelib::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, class Ret = bool
        , bool = boost::intrusive::detail::is_same
   <typename boost::movelib::pointer_element<ValuePtr>::type, typename KeyOfValue::type>::value >
struct tree_value_compare
   :  public boost::intrusive::detail::ebo_functor_holder<KeyCompare>
{
   typedef typename
      boost::movelib::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 Ret operator()(const key_type &key) const
   {  return this->key_comp()(key);   }

BOOST_INTRUSIVE_FORCEINLINE Ret operator()(const value_type &value) const
   {  return this->key_comp()(KeyOfValue()(value));  }

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

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

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

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

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

template<class U>
   BOOST_INTRUSIVE_FORCEINLINE Ret 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 Ret 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 Ret 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 Ret 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, class Ret>
struct tree_value_compare<ValuePtr, KeyCompare, KeyOfValue, Ret, true>
   :  public boost::intrusive::detail::ebo_functor_holder<KeyCompare>
{
   typedef typename
      boost::movelib::pointer_element<ValuePtr>::type value_type;
   typedef KeyCompare                                 key_compare;
   typedef KeyOfValue                                 key_of_value;
   typedef typename KeyOfValue::type                  key_type;