summaryrefslogtreecommitdiff
path: root/boost/intrusive/detail/key_nodeptr_comp.hpp
blob: 1a5ec32acceb2d1746d86da7cb62ff7c53349406 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
/////////////////////////////////////////////////////////////////////////////
//
// (C) Copyright Ion Gaztanaga  2014-2014
//
// 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/intrusive for documentation.
//
/////////////////////////////////////////////////////////////////////////////

#ifndef BOOST_INTRUSIVE_DETAIL_KEY_NODEPTR_COMP_HPP
#define BOOST_INTRUSIVE_DETAIL_KEY_NODEPTR_COMP_HPP

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

#if defined(BOOST_HAS_PRAGMA_ONCE)
#  pragma once
#endif

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

namespace boost {
namespace intrusive {
namespace detail {

template < class KeyTypeKeyCompare
         , class ValueTraits
         , class KeyOfValue = void
         >
struct key_nodeptr_comp
   //Use public inheritance to avoid MSVC bugs with closures
   :  public ebo_functor_holder<KeyTypeKeyCompare>
{
   typedef ValueTraits                             value_traits;
   typedef typename value_traits::value_type       value_type;
   typedef typename value_traits::node_ptr         node_ptr;
   typedef typename value_traits::const_node_ptr   const_node_ptr;
   typedef ebo_functor_holder<KeyTypeKeyCompare>   base_t;
   typedef typename detail::if_c
            < detail::is_same<KeyOfValue, void>::value
            , detail::identity<value_type>
            , KeyOfValue
            >::type                                key_of_value;
   typedef typename key_of_value::type         key_type;

   key_nodeptr_comp(KeyTypeKeyCompare kcomp, const ValueTraits *traits)
      :  base_t(kcomp), traits_(traits)
   {}

   template<class T>
   struct is_node_ptr
   {
      static const bool value = is_same<T, const_node_ptr>::value || is_same<T, node_ptr>::value;
   };

   //key_forward
   template<class T>
   typename enable_if<is_node_ptr<T>, const key_type &>::type key_forward(const T &node) const
   {  return key_of_value()(*traits_->to_value_ptr(node));  }

   template<class T>
   #if defined(BOOST_MOVE_HELPERS_RETURN_SFINAE_BROKEN)
   const T &key_forward (const T &key, typename disable_if<is_node_ptr<T> >::type* =0) const
   #else
   typename disable_if<is_node_ptr<T>, const T &>::type key_forward(const T &key) const
   #endif
   {  return key;  }

   //operator() 1 arg
   template<class KeyType>
   bool operator()(const KeyType &key1) const
   {  return base_t::get()(this->key_forward(key1));  }

   template<class KeyType>
   bool operator()(const KeyType &key1)
   {  return base_t::get()(this->key_forward(key1));  }

   //operator() 2 arg
   template<class KeyType, class KeyType2>
   bool operator()(const KeyType &key1, const KeyType2 &key2) const
   {  return base_t::get()(this->key_forward(key1), this->key_forward(key2));  }

   template<class KeyType, class KeyType2>
   bool operator()(const KeyType &key1, const KeyType2 &key2)
   {  return base_t::get()(this->key_forward(key1), this->key_forward(key2));  }

   const ValueTraits *const traits_;
};

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

#endif //BOOST_INTRUSIVE_DETAIL_KEY_NODEPTR_COMP_HPP