Boost C++ Libraries of the most highly regarded and expertly designed C++ library projects in the world. Herb Sutter and Andrei Alexandrescu, C++ Coding Standards

This is the documentation for an old version of Boost. Click here to view this page for the latest version.

Any Hooks: A single hook for any Intrusive container

Sometimes, a class programmer wants to place a class in several intrusive containers but no at the same time. In this case, the programmer might decide to insert two hooks in the same class.

class MyClass
   : public list_base_hook<>, public slist_base_hook<> //...

However, there is a more size-efficient alternative in Boost.Intrusive: "any" hooks (any_base_hook and any_member_hook). These hooks can be used to store a type in several containers offered by Boost.Intrusive minimizing the size of the class.

These hooks support these options:

auto_unlink can't be supported because the hook does not know in which type of container might be currently inserted. Additionally, these hooks don't support unlink() and swap_nodes() operations for the same reason.

Here is an example that creates a class with two any hooks, and uses one to insert the class in a slist and the other one in a list.

#include <vector>
#include <boost/intrusive/any_hook.hpp>
#include <boost/intrusive/slist.hpp>
#include <boost/intrusive/list.hpp>

using namespace boost::intrusive;

class MyClass : public any_base_hook<> //Base hook
   int int_;

   any_member_hook<> member_hook_;  //Member hook

   MyClass(int i = 0) : int_(i)

int main()
   //Define a base hook option that converts any_base_hook to a slist hook
   typedef any_to_slist_hook < base_hook< any_base_hook<> > >     BaseSlistOption;
   typedef slist<MyClass, BaseSlistOption>                        BaseSList;

   //Define a member hook option that converts any_member_hook to a list hook
   typedef any_to_list_hook< member_hook
         < MyClass, any_member_hook<>, &MyClass::member_hook_> >  MemberListOption;
   typedef list<MyClass, MemberListOption>                        MemberList;

   //Create several MyClass objects, each one with a different value
   std::vector<MyClass> values;
   for(int i = 0; i < 100; ++i){ values.push_back(MyClass(i)); }

   BaseSList base_slist;   MemberList member_list;

   //Now insert them in reverse order in the slist and in order in the list
   for(std::vector<MyClass>::iterator it(values.begin()), itend(values.end()); it != itend; ++it)
      base_slist.push_front(*it), member_list.push_back(*it);

   //Now test lists
   BaseSList::iterator bit(base_slist.begin()), bitend(base_slist.end());
   MemberList::reverse_iterator mrit(member_list.rbegin()), mritend(member_list.rend());
   std::vector<MyClass>::reverse_iterator rit(values.rbegin()), ritend(values.rend());

   //Test the objects inserted in the base hook list
   for(; rit != ritend; ++rit, ++bit, ++mrit)
      if(&*bit != &*rit || &*mrit != &*rit)  return 1;
   return 0;