29aa25d8e9
* Added examples for derivation_value_traits and member_value_traits and updated configuration.
119 lines
4.4 KiB
C++
119 lines
4.4 KiB
C++
/////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// (C) Copyright Ion Gaztanaga 2006-2013
|
|
//
|
|
// 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.
|
|
//
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//[doc_value_traits_code_legacy
|
|
#include <boost/intrusive/link_mode.hpp>
|
|
#include <boost/intrusive/list.hpp>
|
|
#include <boost/intrusive/slist.hpp>
|
|
//<-
|
|
#include <boost/intrusive/trivial_value_traits.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_;
|
|
};
|
|
//]
|
|
|
|
//[doc_value_traits_value_traits
|
|
//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); }
|
|
};
|
|
|
|
//]
|
|
|
|
//[doc_value_traits_trivial
|
|
|
|
typedef bi::trivial_value_traits<legacy_node_traits, bi::normal_link> trivial_legacy_value_traits;
|
|
|
|
//]
|
|
|
|
//[doc_value_traits_test
|
|
//Now define an intrusive list and slist that will store legacy_value objects
|
|
typedef bi::value_traits<legacy_value_traits> ValueTraitsOption;
|
|
typedef bi::value_traits<trivial_legacy_value_traits> TrivialValueTraitsOption;
|
|
|
|
typedef bi::list<legacy_value, ValueTraitsOption> LegacyAbiList;
|
|
typedef bi::slist<legacy_value, ValueTraitsOption> LegacyAbiSlist;
|
|
typedef bi::list<legacy_value, TrivialValueTraitsOption> TrivialLegacyAbiList;
|
|
typedef bi::slist<legacy_value, TrivialValueTraitsOption> TrivialLegacyAbiSlist;
|
|
|
|
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>() &&
|
|
test_list<TrivialLegacyAbiList>() && test_list<TrivialLegacyAbiSlist>()
|
|
? 0 : 1;
|
|
}
|
|
//]
|