Boost C++ Libraries

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

Click here to view the latest version of this page.
PrevUpHomeNext

Containers with custom ValueTraits

ValueTraits interface
Custom ValueTraits example
Reusing node algorithms for different values
Simplifying value traits definition
Stateful value traits

As explained in the Concepts section, Boost.Intrusive containers need a ValueTraits class to perform transformations between nodes and user values. ValueTraits can be explicitly configured (using the value_traits<> option) or implicitly configured (using hooks and their base_hook<>/member_hook<> options). ValueTraits contains all the information to glue the value_type of the containers and the node to be used in node algorithms, since these types can be different. Apart from this, ValueTraits also stores information about the link policy of the values to be inserted.

Instead of using Boost.Intrusive predefined hooks a user might want to develop customized containers, for example, using nodes that are optimized for a specific application or that are compatible with a a legacy ABI. A user might want to have only two additional pointers in his class and insert the class in a doubly linked list sometimes and in a singly linked list in other situations. You can't achieve this using Boost.Intrusive predefined hooks. Now, instead of using base_hook<...> or member_hook<...> options the user will specify the value_traits<...> options. Let's see how we can do this:

ValueTraits has the following interface:

#include <boost/pointer_to_other.hpp>
#include <boost/intrusive/link_mode.hpp>

struct my_value_traits
{
   typedef implementation_defined                                    node_traits;
   typedef implementation_defined                                    value_type;
   typedef node_traits::node_ptr                                     node_ptr;
   typedef node_traits::const_node_ptr                               const_node_ptr;
   typedef boost::pointer_to_other<node_ptr, value_type>::type       pointer;
   typedef boost::pointer_to_other<node_ptr, const value_type>::type const_pointer;

   static const link_mode_type link_mode = some_linking_policy;

   static node_ptr       to_node_ptr    (value_type &value);
   static const_node_ptr to_node_ptr    (const value_type &value);
   static pointer        to_value_ptr   (node_ptr n);
   static const_pointer  to_value_ptr   (const_node_ptr n);
};

Let's explain each type and function:

  • node_traits: The node configuration that is needed by node algorithms. These node traits and algorithms are described in the previous chapter: Node Algorithms.
  • node_ptr: A typedef for node_traits::node_ptr.
  • const_node_ptr: A typedef for node_traits::const_node_ptr.
  • value_type: The type that the user wants to insert in the container. This type can be the same as node_traits::node but it can be different (for example, node_traits::node can be a member type of value_type). If value_type and node_traits::node are the same type, the to_node_ptr and to_value_ptr functions are trivial.
  • pointer: The type of a pointer to a value_type. It must be the same pointer type as node_ptr: If node_ptr is node*, pointer must be value_type*. If node_ptr is smart_ptr<node_traits::node>, pointer must be smart_ptr<value_type>. This can be generically achieved using boost::pointer_to_other utility from Boost SmartPointers defined in <boost/pointer_to_other.hpp>.
  • const_pointer: The type of a pointer to a const value_type. It must be the same pointer type as node_ptr: If node_ptr is node*, const_pointer must be const value_type*. If node_ptr is smart_ptr<node_traits::node>, const_pointer must be smart_ptr<const value_type> This can be generically achieved using boost::pointer_to_other utility from Boost SmartPointers defined in <boost/pointer_to_other.hpp>.
  • link_mode: Indicates that value_traits needs some additional work or checks from the container. The types are enumerations defined in the link_mode.hpp header. These are the possible types:
    • normal_link: If this linking policy is specified in a ValueTraits class as the link mode, containers configured with such ValueTraits won't set the hooks of the erased values to a default state. Containers also won't check that the hooks of the new values are default initialized.
    • safe_link: If this linking policy is specified as the link mode in a ValueTraits class, containers configured with this ValueTraits will set the hooks of the erased values to a default state. Containers also will check that the hooks of the new values are default initialized.
    • auto_unlink: Same as "safe_link" but containers with constant-time size features won't be compatible with ValueTraits configured with this policy. Containers also know that a value can be silently erased from the container without using any function provided by the containers.
  • static node_ptr to_node_ptr (value_type &value) and static const_node_ptr to_node_ptr (const value_type &value): These functions take a reference to a value_type and return a pointer to the node to be used with node algorithms.
  • static pointer to_value_ptr (node_ptr n) and static const_pointer to_value_ptr (const_node_ptr n): These functions take a pointer to a node and return a pointer to the value that contains the node.

Let's define our own value_traits class to be able to use Boost.Intrusive containers with an old C structure whose definition can't be changed. That legacy type has two pointers that can be used to build singly and doubly linked lists: in singly linked lists we only need a pointer, whereas in doubly linked lists, we need two pointers. Since we only have two pointers, we can't insert the object in both a singly and a doubly linked list at the same time. This is the definition of the old node:

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

//This node is the legacy type we can't modify and we want to insert in
//intrusive list and slist containers using only two pointers, since
//we know the object will never be at the same time in both lists. 
struct legacy_value
{
   legacy_value *prev_;
   legacy_value *next_;
   int id_;
};

Now we have to define a NodeTraits class that will implement the functions/typedefs that will make the legacy node compatible with Boost.Intrusive algorithms. After that, we'll define a ValueTraits class that will configure Boost.Intrusive containers:

//Define our own NodeTraits that will configure singly and doubly linked
//list algorithms. Note that this node traits is compatible with
//circular_slist_algorithms and circular_list_algorithms.

namespace bi = boost::intrusive;

struct legacy_node_traits
{
   typedef legacy_value                            node;
   typedef legacy_value *                          node_ptr;
   typedef const legacy_value *                    const_node_ptr;

   static node *get_next(const node *n)            {  return n->next_;  }  
   static void set_next(node *n, node *next)       {  n->next_ = next;  }  
   static node *get_previous(const node *n)        {  return n->prev_;  }  
   static void set_previous(node *n, node *prev)   {  n->prev_ = prev;  }  
};

//This ValueTraits will configure list and slist. In this case,
//legacy_node_traits::node is the same as the 
//legacy_value_traits::value_type so to_node_ptr/to_value_ptr
//functions are trivial.
struct legacy_value_traits
{
   typedef legacy_node_traits                                  node_traits;
   typedef node_traits::node_ptr                               node_ptr;
   typedef node_traits::const_node_ptr                         const_node_ptr;
   typedef legacy_value                                        value_type;
   typedef legacy_value *                                      pointer;
   typedef const legacy_value *                                const_pointer;
   static const bi::link_mode_type link_mode = bi::normal_link;
   static node_ptr to_node_ptr (value_type &value)             {  return node_ptr(&value); }
   static const_node_ptr to_node_ptr (const value_type &value) {  return const_node_ptr(&value); }
   static pointer to_value_ptr(node_ptr n)                     {  return pointer(n); }
   static const_pointer to_value_ptr(const_node_ptr n)         {  return const_pointer(n); }
};

Defining a value traits class that simply defines value_type as legacy_node_traits::node is a common approach when defining customized intrusive containers, so Boost.Intrusive offers a templatized trivial_value_traits class that does exactly what we want:

#include <boost/intrusive/trivial_value_traits.hpp>

//Now we can define legacy_value_traits just with a single line
using namespace boost::intrusive;
typedef trivial_value_traits<legacy_node_traits, normal_link> legacy_value_traits;

Now we can just define the containers that will store the legacy abi objects and write a little test:

//Now define an intrusive list and slist that will store legacy_value objects
typedef bi::value_traits<legacy_value_traits>      ValueTraitsOption;
typedef bi::list<legacy_value, ValueTraitsOption>  LegacyAbiList;
typedef bi::slist<legacy_value, ValueTraitsOption> LegacyAbiSlist;

template<class List>
bool test_list()
{
   typedef std::vector<legacy_value> Vect;

   //Create legacy_value objects, with a different internal number
   Vect legacy_vector;
   for(int i = 0; i < 100; ++i){
      legacy_value value;     value.id_ = i;    legacy_vector.push_back(value);
   }

   //Create the list with the objects
   List mylist(legacy_vector.begin(), legacy_vector.end());

   //Now test both lists
   typename List::const_iterator bit(mylist.begin()), bitend(mylist.end());
   typename Vect::const_iterator it(legacy_vector.begin()), itend(legacy_vector.end());

   //Test the objects inserted in our list
   for(; it != itend; ++it, ++bit)
      if(&*bit != &*it) return false;
   return true;
}

int main()
{
   return test_list<LegacyAbiList>() && test_list<LegacyAbiSlist>() ? 0 : 1;
}

As seen, several key elements of Boost.Intrusive can be reused with custom user types, if the user does not want to use the provided Boost.Intrusive facilities.

In the previous example, legacy_node_traits::node type and legacy_value_traits::value_type are the same type, but this is not necessary. It's possible to have several ValueTraits defining the same node_traits type (and thus, the same node_traits::node). This reduces the number of node algorithm instantiations, but now ValueTraits::to_node_ptr and ValueTraits::to_value_ptr functions need to offer conversions between both types. Let's see a small example:

First, we'll define the node to be used in the algorithms. For a linked list, we just need a node that stores two pointers:

#include <boost/intrusive/link_mode.hpp>
#include <boost/intrusive/list.hpp>
#include <vector>

//This is the node that will be used with algorithms. 
struct simple_node
{
   simple_node *prev_;
   simple_node *next_;
};

Now we'll define two different types that will be inserted in intrusive lists and a templatized ValueTraits that will work for both types:

class base_1{};
class base_2{};

struct value_1 :  public base_1, public simple_node   
{  int   id_;  };

struct value_2 :  public base_1, public base_2, public simple_node
{  float id_;  };

//Define the node traits. A single node_traits will be enough.
struct simple_node_traits
{
   typedef simple_node                             node;
   typedef node *                                  node_ptr;
   typedef const node *                            const_node_ptr;
   static node *get_next(const node *n)            {  return n->next_;  }  
   static void set_next(node *n, node *next)       {  n->next_ = next;  }  
   static node *get_previous(const node *n)        {  return n->prev_;  }  
   static void set_previous(node *n, node *prev)   {  n->prev_ = prev;  }  
};

//A templatized value traits for value_1 and value_2
template<class ValueType>
struct simple_value_traits
{
   typedef simple_node_traits                                  node_traits;
   typedef node_traits::node_ptr                               node_ptr;
   typedef node_traits::const_node_ptr                         const_node_ptr;
   typedef ValueType                                           value_type;
   typedef ValueType *                                         pointer;
   typedef const ValueType *                                   const_pointer;
   static const boost::intrusive::link_mode_type link_mode = boost::intrusive::normal_link;
   static node_ptr to_node_ptr (value_type &value)             {  return node_ptr(&value); }
   static const_node_ptr to_node_ptr (const value_type &value) {  return const_node_ptr(&value); }
   static pointer to_value_ptr(node_ptr n)                     {  return static_cast<value_type*>(n); }
   static const_pointer to_value_ptr(const_node_ptr n)         {  return static_cast<const value_type*>(n); }
};

Now define two containers. Both containers will instantiate the same list algorithms (circular_list_algorithms<simple_node_traits>), due to the fact that the value traits used to define the containers provide the same node_traits type:

//Now define two intrusive lists. Both lists will use the same algorithms:
// circular_list_algorithms<simple_node_traits>

using namespace boost::intrusive;
typedef list <value_1, value_traits<simple_value_traits<value_1> > > Value1List;
typedef list <value_2, value_traits<simple_value_traits<value_2> > > Value2List;

All Boost.Intrusive containers using predefined hooks use this technique to minimize code size: all possible list containers created with predefined hooks that define the same VoidPointer type share the same list algorithms.

The previous example can be further simplified using the derivation_value_traits class to define a value traits class with a value that stores the simple_node as a base class:

#include <boost/intrusive/derivation_value_traits.hpp>

//value_1, value_2, simple_node and simple_node_traits are defined
//as in the previous example...
//...

using namespace boost::intrusive;

//Now define the needed value traits using 
typedef derivation_value_traits<value_1, simple_node_traits, normal_link> ValueTraits1;
typedef derivation_value_traits<value_2, simple_node_traits, normal_link> ValueTraits2;

//Now define the containers
typedef list <value1, value_traits<ValueTraits1> > Value1List;
typedef list <value2, value_traits<ValueTraits2> > Value2List;

We can even choose to store simple_node as a member of value_1 and value_2 classes and use member_value_traits to define the needed value traits classes:

class base_1{};
class base_2{};

struct value_1 :  public base_1, public simple_node   
{
   int   id_;
   simple_node node_;
};

struct value_2 :  public base_1, public base_2, public simple_node
{
   simple_node node_;
   float id_;
};

using namespace boost::intrusive;

typedef member_value_traits
   <value_1, simple_node_traits, &value_1::node_, normal_link> ValueTraits1;
typedef member_value_traits
<value_2, simple_node_traits, &value_2::node_, normal_link> ValueTraits2;

//Now define two intrusive lists. Both lists will use the same algorithms:
// circular_list_algorithms<simple_node_traits>
typedef list <value_1, value_traits<ValueTraits1> > Value1List;
typedef list <value_2, value_traits<ValueTraits2> > Value2List;

Until now all shown custom value traits are stateless, that is, the transformation between nodes and values is implemented in terms of static functions. It's possible to use stateful value traits so that we can separate nodes and values and avoid modifying types to insert nodes. Boost.Intrusive differentiates between stateful and stateless value traits by checking if the ValueTraits class is empty:

  • If the class is empty, a stateless value traits is assumed. Node <-> Value transformations must be static functions.
  • If the class is not empty, a stateful value traits is assumed. Node <-> Value transformations must be non-static functions.

Using stateful value traits it's possible to create containers of non-copyable/moveble objects without modifying the definition of the class to be inserted. This interesting property is achieved without using global variables (stateless value traits could use global variables to achieve the same goal), so:

  • Thread-safety guarantees: Better thread-safety guarantees can be achieved with stateful value traits, since accessing global resources might require syncronization primitives that can be avoided when using internal state.
  • Flexibility: A stateful value traits type can be configured at run-time.
  • Run-time polymorphism: A value traits might implement node <-> value transformations as virtual functions. A single container type could be configured at run-time to use different node <-> value relatioships.

Stateful value traits have many advantages but also some downsides:

  • Performance: Value traits operations should be very efficient since they are basic operations used by containers. A heavy node <-> value transformation will hurt intrusive containers' performance.
  • Exception guarantees: The stateful ValueTraits must maintain no-throw guarantees, otherwise, the container invariants won't be preserved.
  • Static functions: Some static functions offered by intrusive containers are not available because node <-> value transformations are not static.
  • Bigger iterators: The size of some iterators is increased because the iterator needs to store a pointer to the stateful value traits to implement node to value tranformations (e.g. operator*() and operator->()).

An easy and useful example of stateful value traits is when an array of values can be indirectly introduced in a list guaranteeing no additional allocation apart from the initial resource reservation:

#include <boost/intrusive/list.hpp>

using namespace boost::intrusive;

//This type is not modifiable so we can't store hooks or custom nodes
typedef int identifier_t;

//This value traits will associate elements from an array of identifiers with
//elements of an array of nodes. The element i of the value array will use the
//node i of the node array:
struct stateful_value_traits
{
   typedef list_node_traits<void*>           node_traits;
   typedef node_traits::node                 node;
   typedef node *                            node_ptr;
   typedef const node *                      const_node_ptr;
   typedef identifier_t                      value_type;
   typedef identifier_t *                    pointer; 
   typedef const identifier_t *              const_pointer; 
   static const link_mode_type link_mode =   normal_link;

   stateful_value_traits(pointer ids, node_ptr node_array)
      :  ids_(ids),  nodes_(node_array)
   {}

   ///Note: non static functions!
   node_ptr to_node_ptr (value_type &value)
      {  return this->nodes_ + (&value - this->ids_); }
   const_node_ptr to_node_ptr (const value_type &value) const
      {  return this->nodes_ + (&value - this->ids_); }
   pointer to_value_ptr(node_ptr n)
      {  return this->ids_ + (n - this->nodes_); }
   const_pointer to_value_ptr(const_node_ptr n) const
      {  return this->ids_ + (n - this->nodes_); }

   private:
   pointer  ids_;
   node_ptr nodes_;
};

int main()
{
   const int NumElements = 100;

   //This is an array of ids that we want to "store"
   identifier_t                  ids   [NumElements];

   //This is an array of nodes that is necessary to form the linked list
   list_node_traits<void*>::node nodes [NumElements];

   //Initialize id objects, each one with a different number
   for(int i = 0; i != NumElements; ++i)   ids[i] = i;

   //Define a list that will "link" identifiers using external nodes
   typedef list<identifier_t, value_traits<stateful_value_traits> > List;

   //This list will store ids without modifying identifier_t instances
   //Stateful value traits must be explicitly passed in the constructor.
   List  my_list (stateful_value_traits (ids, nodes));

   //Insert ids in reverse order in the list
   for(identifier_t * it(&ids[0]), *itend(&ids[NumElements]); it != itend; ++it)
      my_list.push_front(*it);

   //Now test lists
   List::const_iterator   list_it (my_list.cbegin());
   identifier_t *it_val(&ids[NumElements-1]), *it_rbeg_val(&ids[0]-1);

   //Test the objects inserted in the base hook list
   for(; it_val != it_rbeg_val; --it_val, ++list_it)
      if(&*list_it  != &*it_val)   return 1;

   return 0;
}


PrevUpHomeNext