ceph/src/boost/libs/intrusive/test/function_hook_test.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 //
   3 // (C) Copyright Ion Gaztanaga 2010-2013
   4 //
   5 // Distributed under the Boost Software License, Version 1.0.
   6 //    (See accompanying file LICENSE_1_0.txt or copy at
   7 //          http://www.boost.org/LICENSE_1_0.txt)
   8 //
   9 // See http://www.boost.org/libs/intrusive for documentation.
  10 //
  11 /////////////////////////////////////////////////////////////////////////////
  12 #include <boost/intrusive/parent_from_member.hpp>
  13 #include <boost/intrusive/list.hpp>
  14 #include <boost/intrusive/slist.hpp>
  15 #include <boost/intrusive/set.hpp>
  16 #include <boost/intrusive/unordered_set.hpp>
  17 #include <boost/functional/hash.hpp>
  18
  19 using namespace boost::intrusive;
  20
  21 struct MyClass
  22 {
  23    MyClass() : order(0) {}
  24    int order;
  25
  26    //This internal type has two hooks
  27    struct InnerNode : public list_base_hook<>, public slist_base_hook<>
  28                     , public set_base_hook<>,  public unordered_set_base_hook<>
  29    {
  30       list_member_hook<>            listhook;
  31       slist_member_hook<>           slisthook;
  32       set_member_hook<>             sethook;
  33       unordered_set_member_hook<>   usethook;
  34    } inner;
  35
  36    friend bool operator < (const MyClass &l, const MyClass &r)
  37       { return l.order < r.order; }
  38    friend bool operator == (const MyClass &l, const MyClass &r)
  39       { return l.order == r.order; }
  40    friend std::size_t hash_value(const MyClass &value)
  41       {  return std::size_t(value.order); }
  42 };
  43
  44 //This functor converts between MyClass and the InnerNode member hook
  45 #define InnerMemberHook(TAG, HOOKTYPE, MEMBERNAME)\
  46    struct InnerMemberHookFunctor##TAG \
  47    {\
  48       typedef HOOKTYPE              hook_type;\
  49       typedef hook_type*            hook_ptr;\
  50       typedef const hook_type*      const_hook_ptr;\
  51       typedef MyClass               value_type;\
  52       typedef value_type*           pointer;\
  53       typedef const value_type*     const_pointer;\
  54                                                 \
  55       static hook_ptr to_hook_ptr (value_type &value)\
  56          {  return &value.inner.MEMBERNAME; }\
  57       static const_hook_ptr to_hook_ptr(const value_type &value)\
  58          {  return &value.inner.MEMBERNAME; }\
  59       static pointer to_value_ptr(hook_ptr n)\
  60       {\
  61          return get_parent_from_member<MyClass>\
  62             (get_parent_from_member<MyClass::InnerNode>(n, &MyClass::InnerNode::MEMBERNAME)\
  63             ,&MyClass::inner\
  64          );\
  65       }\
  66       static const_pointer to_value_ptr(const_hook_ptr n)\
  67       {\
  68          return get_parent_from_member<MyClass>\
  69             (get_parent_from_member<MyClass::InnerNode>(n, &MyClass::InnerNode::MEMBERNAME)\
  70             ,&MyClass::inner\
  71          );\
  72       }\
  73    };\
  74 //
  75
  76
  77 //This functor converts between MyClass and the InnerNode base hook
  78 #define InnerBaseHook(TAG, HOOKTYPE)\
  79    struct InnerBaseHookFunctor##TAG \
  80    {\
  81       typedef HOOKTYPE              hook_type;\
  82       typedef hook_type*            hook_ptr;\
  83       typedef const hook_type*      const_hook_ptr;\
  84       typedef MyClass               value_type;\
  85       typedef value_type*           pointer;\
  86       typedef const value_type*     const_pointer;\
  87                                                 \
  88       static hook_ptr to_hook_ptr (value_type &value)\
  89          {  return &value.inner; }\
  90       static const_hook_ptr to_hook_ptr(const value_type &value)\
  91          {  return &value.inner; }\
  92       static pointer to_value_ptr(hook_ptr n)\
  93       {\
  94          return get_parent_from_member<MyClass>(static_cast<MyClass::InnerNode*>(n),&MyClass::inner);\
  95       }\
  96       static const_pointer to_value_ptr(const_hook_ptr n)\
  97       {\
  98          return get_parent_from_member<MyClass>(static_cast<const MyClass::InnerNode*>(n),&MyClass::inner);\
  99       }\
 100    };\
 101 //
 102
 103 //List
 104 InnerMemberHook(List, list_member_hook<>, listhook)
 105 InnerBaseHook(List, list_base_hook<>)
 106 //Slist
 107 InnerMemberHook(Slist, slist_member_hook<>, slisthook)
 108 InnerBaseHook(Slist, slist_base_hook<>)
 109 //Set
 110 InnerMemberHook(Set, set_member_hook<>, sethook)
 111 InnerBaseHook(Set, set_base_hook<>)
 112 //Unordered Set
 113 InnerMemberHook(USet, unordered_set_member_hook<>, usethook)
 114 InnerBaseHook(USet, unordered_set_base_hook<>)
 115
 116 //Define containers
 117 typedef list < MyClass, function_hook< InnerMemberHookFunctorList> >         CustomListMember;
 118 typedef list < MyClass, function_hook< InnerBaseHookFunctorList  > >         CustomListBase;
 119 typedef slist< MyClass, function_hook< InnerMemberHookFunctorSlist> >        CustomSlistMember;
 120 typedef slist< MyClass, function_hook< InnerBaseHookFunctorSlist  > >        CustomSlistBase;
 121 typedef set  < MyClass, function_hook< InnerMemberHookFunctorSet> >          CustomSetMember;
 122 typedef set  < MyClass, function_hook< InnerBaseHookFunctorSet  > >          CustomSetBase;
 123 typedef unordered_set< MyClass, function_hook< InnerMemberHookFunctorUSet> > CustomUSetMember;
 124 typedef unordered_set< MyClass, function_hook< InnerBaseHookFunctorUSet  > > CustomUSetBase;
 125
 126 int main()
 127 {
 128    MyClass n;
 129    CustomListBase    listbase;
 130    CustomListMember  listmember;
 131    CustomSlistBase   slistbase;
 132    CustomSlistMember slistmember;
 133    CustomSetBase     setbase;
 134    CustomSetMember   setmember;
 135    CustomUSetBase::bucket_type buckets_uset[1];
 136    CustomUSetBase    usetbase(CustomUSetBase::bucket_traits(buckets_uset, 1));
 137    CustomUSetBase::bucket_type buckets_umultiset[1];
 138    CustomUSetMember  usetmember(CustomUSetMember::bucket_traits(buckets_umultiset, 1));
 139
 140    listbase.insert(listbase.begin(), n);
 141    listmember.insert(listmember.begin(), n);
 142    slistbase.insert(slistbase.begin(), n);
 143    slistmember.insert(slistmember.begin(), n);
 144    setbase.insert(n);
 145    setmember.insert(n);
 146    usetbase.insert(n);
 147    usetmember.insert(n);
 148
 149    return 0;
 150 }