feedc0de/boost_intrusive
1
0
Fork 0
forked from boostorg/intrusive
Code Pull Requests Activity

New Interprocess version

Browse Source 
[SVN r38271]
This commit is contained in:
Ion Gaztañaga
2007-07-22 14:08:34 +00:00
parent 0653ca2678
commit 1e108ff97e
18 changed files with 945 additions and 131 deletions
Download Patch File Download Diff File Expand all files Collapse all files

57
include/boost/intrusive/derivation_value_traits.hpp Normal file
View File

@@ -0,0 +1,57 @@
/////////////////////////////////////////////////////////////////////////////
//
// (C) Copyright Ion Gaztanaga 2006-2007
//
// 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_DERIVATION_VALUE_TRAITS_HPP
#define BOOST_INTRUSIVE_DERIVATION_VALUE_TRAITS_HPP
#include <boost/intrusive/linking_policy.hpp>
#include <iterator>
namespace boost {
namespace intrusive {
//!This value traits template is used to create value traits
//!from user defined node traits where value_traits::value_type will
//!derive from node_traits::node
template<class T, class NodeTraits, linking_policy Policy>
struct derivation_value_traits
{
public:
typedef NodeTraits node_traits;
typedef T value_type;
typedef typename node_traits::node node;
typedef typename node_traits::node_ptr node_ptr;
typedef typename node_traits::const_node_ptr const_node_ptr;
typedef typename boost::pointer_to_other<node_ptr, T>::type pointer;
typedef typename boost::pointer_to_other<node_ptr, const T>::type const_pointer;
typedef typename std::iterator_traits<pointer>::reference reference;
typedef typename std::iterator_traits<const_pointer>::reference const_reference;
enum { linking_policy = Policy };
static node_ptr to_node_ptr(reference value)
{ return node_ptr(&value); }
static const_node_ptr to_node_ptr(const_reference value)
{ return node_ptr(&value); }
static pointer to_value_ptr(node_ptr n)
{ return pointer(static_cast<T*>(detail::get_pointer(n))); }
static const_pointer to_value_ptr(const_node_ptr n)
{ return const_pointer(static_cast<T*>(detail::get_pointer(n))); }
};
} //namespace intrusive
} //namespace boost
#endif //BOOST_INTRUSIVE_DERIVATION_VALUE_TRAITS_HPP

8
include/boost/intrusive/detail/assert.hpp
View File

@@ -22,14 +22,14 @@
#define BOOST_INTRUSIVE_INVARIANT_ASSERT BOOST_ASSERT
#endif
#if !defined(BOOST_INTRUSIVE_SAFE_MODE_CONTAINER_INSERTION_ASSERT)
#if !defined(BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT)
#include <boost/assert.hpp>
#define BOOST_INTRUSIVE_SAFE_MODE_CONTAINER_INSERTION_ASSERT BOOST_ASSERT
#define BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT BOOST_ASSERT
#endif
#if !defined(BOOST_INTRUSIVE_SAFE_MODE_HOOK_DESTRUCTOR_ASSERT)
#if !defined(BOOST_INTRUSIVE_SAFE_HOOK_DESTRUCTOR_ASSERT)
#include <boost/assert.hpp>
#define BOOST_INTRUSIVE_SAFE_MODE_HOOK_DESTRUCTOR_ASSERT BOOST_ASSERT
#define BOOST_INTRUSIVE_SAFE_HOOK_DESTRUCTOR_ASSERT BOOST_ASSERT
#endif
#endif //BOOST_INTRUSIVE_DETAIL_ASSERT_HPP

2
include/boost/intrusive/detail/config_begin.hpp
View File

@@ -12,8 +12,6 @@
#ifndef BOOST_INTRUSIVE_SELECT_COMPILER_INCLUDED
#ifndef BOOST_COMPILER_CONFIG
//#include <boost/config/select_compiler_config.hpp>
//#include BOOST_COMPILER_CONFIG
#include <boost/config.hpp>
#endif
#define BOOST_INTRUSIVE_SELECT_COMPILER_INCLUDED

14
include/boost/intrusive/detail/parent_from_member.hpp
View File

@@ -14,32 +14,34 @@
#include <boost/intrusive/detail/config_begin.hpp>
#include <cstddef>
namespace boost {
namespace intrusive {
namespace detail {
template<class Parent, class Member>
std::size_t offset_from_pointer_to_member(const Member Parent::* ptr_to_member)
inline std::size_t offset_from_pointer_to_member(const Member Parent::* ptr_to_member)
{
//The implementation of a pointer to member is compiler dependent.
#if (defined(_MSC_VER) || defined(__GNUC__) || defined(BOOST_INTEL) || defined(__HP_aCC))
#if (defined(_MSC_VER) || defined(__GNUC__) || \
defined(BOOST_INTEL) || defined(__HP_aCC))
//This works with gcc, msvc, ac++
return *(const std::size_t*)(const void*)&ptr_to_member;
return *(const std::ptrdiff_t*)(void*)&ptr_to_member;
#else
//This is the traditional C-front approach: __MWERKS__, __DMC__, __SUNPRO_CC
return *(const std::size_t*)(const void*)&ptr_to_member - 1;
return *(const std::ptrdiff_t*)(void*)&ptr_to_member - 1;
#endif
}
template<class Parent, class Member>
Parent *parent_from_member(Member *member, const Member Parent::* ptr_to_member)
inline Parent *parent_from_member(Member *member, const Member Parent::* ptr_to_member)
{
return (Parent*)((char*)member -
offset_from_pointer_to_member(ptr_to_member));
}
template<class Parent, class Member>
const Parent *parent_from_member(const Member *member, const Member Parent::* ptr_to_member)
inline const Parent *parent_from_member(const Member *member, const Member Parent::* ptr_to_member)
{
return (const Parent*)((const char*)member -
offset_from_pointer_to_member(ptr_to_member));

25
include/boost/intrusive/detail/utilities.hpp
View File

@@ -116,7 +116,7 @@ struct size_holder<false, SizeType>
};
template<class T, class DerivationHookType, typename Tag>
struct derivation_value_traits
struct derivation_hook_value_traits
{
public:
typedef typename DerivationHookType::node_traits node_traits;
@@ -148,7 +148,7 @@ struct derivation_value_traits
template<class T, class MemberHookType, MemberHookType T::* P>
struct member_value_traits
struct member_hook_value_traits
{
public:
typedef typename MemberHookType::node_traits node_traits;
@@ -174,21 +174,22 @@ struct member_value_traits
return result->to_node_ptr();
}
//Now let's be nasty. A pointer to member is usually implemented
//as an offset from the start of the class.
//get the offset in bytes and go
//backwards from n to the value subtracting
//the needed bytes.
static pointer to_value_ptr(node_ptr n)
{
return pointer(parent_from_member<value_type, MemberHookType>
((MemberHookType*)detail::get_pointer(n), P));
return pointer
(
parent_from_member<value_type, MemberHookType>
(detail::get_pointer(MemberHookType::to_hook_ptr(n)), P)
);
}
static const_pointer to_value_ptr(const_node_ptr n)
{
const_pointer(parent_from_member<value_type, MemberHookType>
((const MemberHookType*)detail::get_pointer(n), P));
return const_pointer
(
parent_from_member<value_type, MemberHookType>
(detail::get_pointer(MemberHookType::to_hook_ptr(n)), P)
);
}
};
@@ -252,7 +253,7 @@ struct dispatcher
template<class Container>
void destructor_impl(Container &cont, dispatcher<safe_link>)
{ (void)cont; BOOST_INTRUSIVE_SAFE_MODE_HOOK_DESTRUCTOR_ASSERT(!cont.is_linked()); }
{ (void)cont; BOOST_INTRUSIVE_SAFE_HOOK_DESTRUCTOR_ASSERT(!cont.is_linked()); }
template<class Container>
void destructor_impl(Container &cont, dispatcher<auto_unlink>)

684
include/boost/intrusive/hashtable.hpp
View File

@@ -22,6 +22,9 @@
#include <boost/intrusive/detail/assert.hpp>
#include <boost/static_assert.hpp>
#include <boost/functional/hash.hpp>
#ifndef BOOST_INTRUSIVE_DISABLE_EXCEPTION_HANDLING
#include <boost/detail/no_exceptions_support.hpp>
#endif
//General intrusive utilities
#include <boost/intrusive/intrusive_fwd.hpp>
#include <boost/intrusive/detail/pointer_to_other.hpp>
@@ -179,6 +182,19 @@ class hashtable
public:
typedef insert_commit_data_impl insert_commit_data;
//! <b>Requires</b>: buckets must not be being used by any other resource.
//!
//! <b>Effects</b>: Constructs an empty unordered_set, storing a reference
//! to the bucket array and copies of the hasher and equal functors.
//!
//! <b>Complexity</b>: Constant.
//!
//! <b>Throws</b>: If value_traits::node_traits::node
//! constructor throws (this does not happen with predefined Boost.Intrusive hooks)
//! or the copy constructor or invocation of Hash or Equal throws.
//!
//! <b>Notes</b>: buckets array must be disposed only after
//! *this is disposed.
hashtable( bucket_ptr buckets
, size_type buckets_len
, const Hash & hasher = Hash()
@@ -193,9 +209,22 @@ class hashtable
size_traits::set_size(size_type(0));
}
//! <b>Effects</b>: Detaches all elements from this. The objects in the unordered_set
//! are not deleted (i.e. no destructors are called).
//!
//! <b>Complexity</b>: Linear to the number of elements in the unordered_set, if
//! it's a safe-mode or auto-unlink value. Otherwise constant.
//!
//! <b>Throws</b>: Nothing.
~hashtable()
{ this->clear(); }
//! <b>Effects</b>: Returns an iterator pointing to the beginning of the unordered_set.
//!
//! <b>Complexity</b>: Amortized constant time.
//! Worst case (empty unordered_set): O(this->bucket_count())
//!
//! <b>Throws</b>: Nothing.
iterator begin()
{
size_type bucket_num;
@@ -203,9 +232,23 @@ class hashtable
return iterator(local_it, const_bucket_info_ptr(&this->priv_bucket_info()));
}
//! <b>Effects</b>: Returns a const_iterator pointing to the beginning
//! of the unordered_set.
//!
//! <b>Complexity</b>: Amortized constant time.
//! Worst case (empty unordered_set): O(this->bucket_count())
//!
//! <b>Throws</b>: Nothing.
const_iterator begin() const
{ return cbegin(); }
//! <b>Effects</b>: Returns a const_iterator pointing to the beginning
//! of the unordered_set.
//!
//! <b>Complexity</b>: Amortized constant time.
//! Worst case (empty unordered_set): O(this->bucket_count())
//!
//! <b>Throws</b>: Nothing.
const_iterator cbegin() const
{
size_type bucket_num;
@@ -213,21 +256,53 @@ class hashtable
return const_iterator( local_it, const_bucket_info_ptr(&this->priv_bucket_info()));
}
//! <b>Effects</b>: Returns an iterator pointing to the end of the unordered_set.
//!
//! <b>Complexity</b>: Constant.
//!
//! <b>Throws</b>: Nothing.
iterator end()
{ return iterator(invalid_local_it(this->priv_bucket_info()), 0); }
//! <b>Effects</b>: Returns a const_iterator pointing to the end of the unordered_set.
//!
//! <b>Complexity</b>: Constant.
//!
//! <b>Throws</b>: Nothing.
const_iterator end() const
{ return cend(); }
//! <b>Effects</b>: Returns a const_iterator pointing to the end of the unordered_set.
//!
//! <b>Complexity</b>: Constant.
//!
//! <b>Throws</b>: Nothing.
const_iterator cend() const
{ return const_iterator(invalid_local_it(this->priv_bucket_info()), 0); }
//! <b>Effects</b>: Returns the hasher object used by the unordered_set.
//!
//! <b>Complexity</b>: Constant.
//!
//! <b>Throws</b>: If hasher copy-constructor throws.
hasher hash_function() const
{ return this->priv_hasher(); }
//! <b>Effects</b>: Returns the key_equal object used by the unordered_set.
//!
//! <b>Complexity</b>: Constant.
//!
//! <b>Throws</b>: If key_equal copy-constructor throws.
key_equal key_eq() const
{ return this->priv_equal(); }
//! <b>Effects</b>: Returns true is the container is empty.
//!
//! <b>Complexity</b>: if ConstantTimeSize is false, average constant time
//! (worst case, with empty() == true): O(this->bucket_count()).
//! Otherwise constant.
//!
//! <b>Throws</b>: Nothing.
bool empty() const
{
if(ConstantTimeSize){
@@ -245,6 +320,12 @@ class hashtable
}
}
//! <b>Effects</b>: Returns the number of elements stored in the unordered_set.
//!
//! <b>Complexity</b>: Linear to elements contained in *this if
//! ConstantTimeSize is false. Constant-time otherwise.
//!
//! <b>Throws</b>: Nothing.
size_type size() const
{
if(ConstantTimeSize)
@@ -260,6 +341,16 @@ class hashtable
}
}
//! <b>Requires</b>: the hasher and the equality function unqualified swap
//! call should not throw.
//!
//! <b>Effects</b>: Swaps the contents of two unordered_sets.
//! Swaps also the contained bucket array and equality and hasher functors.
//!
//! <b>Complexity</b>: Constant.
//!
//! <b>Throws</b>: If the swap() call for the comparison or hash functors
//! found using ADL throw. Basic guarantee.
void swap(hashtable& other)
{
using std::swap;
@@ -276,6 +367,19 @@ class hashtable
}
}
//! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw.
//!
//! <b>Effects</b>: Erases all the elements from *this
//! calling Disposer::operator()(pointer), clones all the
//! elements from src calling Cloner::operator()(const_reference )
//! and inserts them on *this.
//!
//! If cloner throws, all cloned elements are unlinked and disposed
//! calling Disposer::operator()(pointer).
//!
//! <b>Complexity</b>: Linear to erased plus inserted elements.
//!
//! <b>Throws</b>: If cloner throws. Basic guarantee.
template <class Cloner, class Disposer>
void clone_from(const hashtable &src, Cloner cloner, Disposer disposer)
{
@@ -290,7 +394,9 @@ class hashtable
const bucket_ptr src_buckets = src.priv_buckets();
const bucket_ptr dst_buckets = this->priv_buckets();
size_type constructed;
try{
#ifndef BOOST_INTRUSIVE_DISABLE_EXCEPTION_HANDLING
BOOST_TRY{
#endif
for( constructed = 0
; constructed < dst_bucket_count
; ++constructed){
@@ -310,28 +416,36 @@ class hashtable
}
}
}
#ifndef BOOST_INTRUSIVE_DISABLE_EXCEPTION_HANDLING
}
catch(...){
BOOST_CATCH(...){
while(constructed--){
dst_buckets[constructed].clear_and_dispose(disposer);
}
throw;
BOOST_RETHROW;
}
BOOST_CATCH_END
#endif
size_traits::set_size(src.get_size());
}
else{
//Unlike previous cloning algorithm, this can throw
//if cloner, the hasher or comparison functor throw
const_iterator b(src.begin()), e(src.end());
try{
#ifndef BOOST_INTRUSIVE_DISABLE_EXCEPTION_HANDLING
BOOST_TRY{
#endif
for(; b != e; ++b){
this->insert_equal(*cloner(*b));
}
#ifndef BOOST_INTRUSIVE_DISABLE_EXCEPTION_HANDLING
}
catch(...){
BOOST_CATCH(...){
this->clear_and_dispose(disposer);
throw;
BOOST_RETHROW;
}
BOOST_CATCH_END
#endif
}
}
}
@@ -355,15 +469,43 @@ class hashtable
this->insert_equal(*b);
}
//! <b>Requires</b>: value must be an lvalue
//!
//! <b>Effects</b>: Tries to inserts value into the unordered_set.
//!
//! <b>Returns</b>: If the value
//! is not already present inserts it and returns a pair containing the
//! iterator to the new value and true. If there is an equivalent value
//! returns a pair containing an iterator to the already present value
//! and false.
//!
//! <b>Complexity</b>: Average case O(1), worst case O(this->size()).
//!
//! <b>Throws</b>: If the internal hasher or the equality functor throws. Strong guarantee.
//!
//! <b>Note</b>: Does not affect the validity of iterators and references.
//! No copy-constructors are called.
std::pair<iterator, bool> insert_unique(reference value)
{
insert_commit_data commit_data;
std::pair<iterator, bool> ret = insert_unique_check(value, commit_data);
std::pair<iterator, bool> ret = insert_unique_check(value, this->priv_hasher(), this->priv_equal(), commit_data);
if(!ret.second)
return ret;
return std::pair<iterator, bool> (insert_unique_commit(value, commit_data), true);
}
//! <b>Requires</b>: Dereferencing iterator must yield an lvalue
//! of type value_type.
//!
//! <b>Effects</b>: Equivalent to this->insert(t) for each element in [b, e).
//!
//! <b>Complexity</b>: Average case O(N), where N is std::distance(b, e).
//! Worst case O(N*this->size()).
//!
//! <b>Throws</b>: If the internal hasher or the equality functor throws. Basic guarantee.
//!
//! <b>Note</b>: Does not affect the validity of iterators and references.
//! No copy-constructors are called.
template<class Iterator>
void insert_unique(Iterator b, Iterator e)
{
@@ -371,10 +513,41 @@ class hashtable
this->insert_unique(*b);
}
std::pair<iterator, bool> insert_unique_check
(const_reference value, insert_commit_data &commit_data)
{ return insert_unique_check(value, this->priv_hasher(), this->priv_equal(), commit_data); }
//! <b>Requires</b>: "hasher" must be a hash function that induces
//! the same hash values as the stored hasher. The difference is that
//! "hasher" hashes the given key instead of the value_type.
//!
//! "key_value_equal" must be a equality function that induces
//! the same equality as key_equal. The difference is that
//! "key_value_equal" compares an arbitrary key with the contained values.
//!
//! <b>Effects</b>: Checks if a value can be inserted in the unordered_set, using
//! a user provided key instead of the value itself.
//!
//! <b>Returns</b>: If there is an equivalent value
//! returns a pair containing an iterator to the already present value
//! and false. If the value can be inserted returns true in the returned
//! pair boolean and fills "commit_data" that is meant to be used with
//! the "insert_commit" function.
//!
//! <b>Complexity</b>: Average case O(1), worst case O(this->size()).
//!
//! <b>Throws</b>: If hasher or key_value_equal throw. Strong guarantee.
//!
//! <b>Notes</b>: This function is used to improve performance when constructing
//! a value_type is expensive: if there is an equivalent value
//! the constructed object must be discarded. Many times, the part of the
//! node that is used to impose the hash or the equality is much cheaper to
//! construct than the value_type and this function offers the possibility to
//! use that the part to check if the insertion will be successful.
//!
//! If the check is successful, the user can construct the value_type and use
//! "insert_commit" to insert the object in constant-time.
//!
//! "commit_data" remains valid for a subsequent "insert_commit" only if no more
//! objects are inserted or erased from the unordered_set.
//!
//! After a successful rehashing insert_commit_data remains valid.
template<class KeyType, class KeyHasher, class KeyValueEqual>
std::pair<iterator, bool> insert_unique_check
( const KeyType &key
@@ -394,6 +567,25 @@ class hashtable
,success);
}
//! <b>Requires</b>: value must be an lvalue of type value_type. commit_data
//! must have been obtained from a previous call to "insert_check".
//! No objects should have been inserted or erased from the unordered_set between
//! the "insert_check" that filled "commit_data" and the call to "insert_commit".
//!
//! <b>Effects</b>: Inserts the value in the unordered_set using the information obtained
//! from the "commit_data" that a previous "insert_check" filled.
//!
//! <b>Returns</b>: An iterator to the newly inserted object.
//!
//! <b>Complexity</b>: Constant time.
//!
//! <b>Throws</b>: Nothing.
//!
//! <b>Notes</b>: This function has only sense if a "insert_check" has been
//! previously executed to fill "commit_data". No value should be inserted or
//! erased between the "insert_check" and "insert_commit" calls.
//!
//! After a successful rehashing insert_commit_data remains valid.
iterator insert_unique_commit(reference value, const insert_commit_data &commit_data)
{
size_type bucket_num = commit_data.hash % this->priv_buckets_len();
@@ -403,19 +595,78 @@ class hashtable
, const_bucket_info_ptr(&this->priv_bucket_info()));
}
//! <b>Effects</b>: Erases the element pointed to by i.
//!
//! <b>Complexity</b>: Average case O(1), worst case O(this->size()).
//!
//! <b>Throws</b>: Nothing.
//!
//! <b>Note</b>: Invalidates the iterators (but not the references)
//! to the erased element. No destructors are called.
void erase(const_iterator i)
{ erase_and_dispose(i, detail::null_disposer()); }
//! <b>Effects</b>: Erases the range pointed to by b end e.
//!
//! <b>Complexity</b>: Average case O(std::distance(b, e)),
//! worst case O(this->size()).
//!
//! <b>Throws</b>: Nothing.
//!
//! <b>Note</b>: Invalidates the iterators (but not the references)
//! to the erased elements. No destructors are called.
void erase(const_iterator b, const_iterator e)
{ erase_and_dispose(b, e, detail::null_disposer()); }
//! <b>Effects</b>: Erases all the elements with the given value.
//!
//! <b>Returns</b>: The number of erased elements.
//!
//! <b>Complexity</b>: Average case O(this->count(value)).
//! Worst case O(this->size()).
//!
//! <b>Throws</b>: If the internal hasher or the equality functor throws. Basic guarantee.
//!
//! <b>Note</b>: Invalidates the iterators (but not the references)
//! to the erased elements. No destructors are called.
size_type erase(const_reference value)
{ return this->erase(value, this->priv_hasher(), this->priv_equal()); }
//! <b>Requires</b>: "hasher" must be a hash function that induces
//! the same hash values as the stored hasher. The difference is that
//! "hasher" hashes the given key instead of the value_type.
//!
//! "key_value_equal" must be a equality function that induces
//! the same equality as key_equal. The difference is that
//! "key_value_equal" compares an arbitrary key with the contained values.
//!
//! <b>Effects</b>: Erases all the elements that have the same hash and
//! compare equal with the given key.
//!
//! <b>Returns</b>: The number of erased elements.
//!
//! <b>Complexity</b>: Average case O(this->count(value)).
//! Worst case O(this->size()).
//!
//! <b>Throws</b>: If hasher or equal throw. Basic guarantee.
//!
//! <b>Note</b>: Invalidates the iterators (but not the references)
//! to the erased elements. No destructors are called.
template<class KeyType, class KeyHasher, class KeyValueEqual>
size_type erase(const KeyType& key, KeyHasher hasher, KeyValueEqual equal)
{ return erase_and_dispose(key, hasher, equal, detail::null_disposer()); }
//! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw.
//!
//! <b>Effects</b>: Erases the element pointed to by i.
//! Disposer::operator()(pointer) is called for the removed element.
//!
//! <b>Complexity</b>: Average case O(1), worst case O(this->size()).
//!
//! <b>Throws</b>: Nothing.
//!
//! <b>Note</b>: Invalidates the iterators
//! to the erased elements.
template<class Disposer>
void erase_and_dispose(const_iterator i, Disposer disposer)
{
@@ -426,6 +677,18 @@ class hashtable
size_traits::decrement();
}
//! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw.
//!
//! <b>Effects</b>: Erases the range pointed to by b end e.
//! Disposer::operator()(pointer) is called for the removed elements.
//!
//! <b>Complexity</b>: Average case O(std::distance(b, e)),
//! worst case O(this->size()).
//!
//! <b>Throws</b>: Nothing.
//!
//! <b>Note</b>: Invalidates the iterators
//! to the erased elements.
template<class Disposer>
void erase_and_dispose(const_iterator b, const_iterator e, Disposer disposer)
{
@@ -489,10 +752,39 @@ class hashtable
}
}
//! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw.
//!
//! <b>Effects</b>: Erases all the elements with the given value.
//! Disposer::operator()(pointer) is called for the removed elements.
//!
//! <b>Returns</b>: The number of erased elements.
//!
//! <b>Complexity</b>: Average case O(this->count(value)).
//! Worst case O(this->size()).
//!
//! <b>Throws</b>: If the internal hasher or the equality functor throws. Basic guarantee.
//!
//! <b>Note</b>: Invalidates the iterators (but not the references)
//! to the erased elements. No destructors are called.
template<class Disposer>
size_type erase_and_dispose(const_reference value, Disposer disposer)
{ return erase_and_dispose(value, priv_hasher(), priv_equal(), disposer); }
//! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw.
//!
//! <b>Effects</b>: Erases all the elements with the given key.
//! according to the comparison functor "equal".
//! Disposer::operator()(pointer) is called for the removed elements.
//!
//! <b>Returns</b>: The number of erased elements.
//!
//! <b>Complexity</b>: Average case O(this->count(value)).
//! Worst case O(this->size()).
//!
//! <b>Throws</b>: If hasher or key_value_equal throw. Basic guarantee.
//!
//! <b>Note</b>: Invalidates the iterators
//! to the erased elements.
template<class KeyType, class KeyHasher, class KeyValueEqual, class Disposer>
size_type erase_and_dispose(const KeyType& key, KeyHasher hasher
,KeyValueEqual equal, Disposer disposer)
@@ -529,6 +821,15 @@ class hashtable
return count;
}
//! <b>Effects</b>: Erases all of the elements.
//!
//! <b>Complexity</b>: Linear to the number of elements on the container.
//! if it's a safe-mode or auto-unlink value_type. Constant time otherwise.
//!
//! <b>Throws</b>: Nothing.
//!
//! <b>Note</b>: Invalidates the iterators (but not the references)
//! to the erased elements. No destructors are called.
void clear()
{
if(safemode_or_autounlink){
@@ -537,6 +838,17 @@ class hashtable
size_traits::set_size(size_type(0));
}
//! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw.
//!
//! <b>Effects</b>: Erases all of the elements.
//!
//! <b>Complexity</b>: Linear to the number of elements on the container.
//! Disposer::operator()(pointer) is called for the removed elements.
//!
//! <b>Throws</b>: Nothing.
//!
//! <b>Note</b>: Invalidates the iterators (but not the references)
//! to the erased elements. No destructors are called.
template<class Disposer>
void clear_and_dispose(Disposer disposer)
{
@@ -550,9 +862,27 @@ class hashtable
}
}
//! <b>Effects</b>: Returns the number of contained elements with the given value
//!
//! <b>Complexity</b>: Average case O(1), worst case O(this->size()).
//!
//! <b>Throws</b>: If the internal hasher or the equality functor throws.
size_type count(const_reference value) const
{ return this->count(value, this->priv_hasher(), this->priv_equal()); }
//! <b>Requires</b>: "hasher" must be a hash function that induces
//! the same hash values as the stored hasher. The difference is that
//! "hasher" hashes the given key instead of the value_type.
//!
//! "key_value_equal" must be a equality function that induces
//! the same equality as key_equal. The difference is that
//! "key_value_equal" compares an arbitrary key with the contained values.
//!
//! <b>Effects</b>: Returns the number of contained elements with the given key
//!
//! <b>Complexity</b>: Average case O(1), worst case O(this->size()).
//!
//! <b>Throws</b>: If hasher or equal throw.
template<class KeyType, class KeyHasher, class KeyValueEqual>
size_type count(const KeyType &key, const KeyHasher &hasher, const KeyValueEqual &equal) const
{
@@ -561,9 +891,34 @@ class hashtable
return count;
}
//! <b>Effects</b>: Finds an iterator to the first element is equal to
//! "value" or end() if that element does not exist.
//!
//! <b>Complexity</b>: Average case O(1), worst case O(this->size()).
//!
//! <b>Throws</b>: If the internal hasher or the equality functor throws.
iterator find(const_reference value)
{ return find(value, this->priv_hasher(), this->priv_equal()); }
//! <b>Requires</b>: "hasher" must be a hash function that induces
//! the same hash values as the stored hasher. The difference is that
//! "hasher" hashes the given key instead of the value_type.
//!
//! "key_value_equal" must be a equality function that induces
//! the same equality as key_equal. The difference is that
//! "key_value_equal" compares an arbitrary key with the contained values.
//!
//! <b>Effects</b>: Finds an iterator to the first element whose key is
//! "key" according to the given hasher and equality functor or end() if
//! that element does not exist.
//!
//! <b>Complexity</b>: Average case O(1), worst case O(this->size()).
//!
//! <b>Throws</b>: If hasher or equal throw.
//!
//! <b>Note</b>: This function is used when constructing a value_type
//! is expensive and the value_type can be compared with a cheaper
//! key type. Usually this key is part of the value_type.
template<class KeyType, class KeyHasher, class KeyValueEqual>
iterator find(const KeyType &key, KeyHasher hasher, KeyValueEqual equal)
{
@@ -573,9 +928,34 @@ class hashtable
, const_bucket_info_ptr(&this->priv_bucket_info()));
}
//! <b>Effects</b>: Finds a const_iterator to the first element whose key is
//! "key" or end() if that element does not exist.
//!
//! <b>Complexity</b>: Average case O(1), worst case O(this->size()).
//!
//! <b>Throws</b>: If the internal hasher or the equality functor throws.
const_iterator find(const_reference value) const
{ return find(value, this->priv_hasher(), this->priv_equal()); }
//! <b>Requires</b>: "hasher" must be a hash function that induces
//! the same hash values as the stored hasher. The difference is that
//! "hasher" hashes the given key instead of the value_type.
//!
//! "key_value_equal" must be a equality function that induces
//! the same equality as key_equal. The difference is that
//! "key_value_equal" compares an arbitrary key with the contained values.
//!
//! <b>Effects</b>: Finds an iterator to the first element whose key is
//! "key" according to the given hasher and equality functor or end() if
//! that element does not exist.
//!
//! <b>Complexity</b>: Average case O(1), worst case O(this->size()).
//!
//! <b>Throws</b>: If hasher or equal throw.
//!
//! <b>Note</b>: This function is used when constructing a value_type
//! is expensive and the value_type can be compared with a cheaper
//! key type. Usually this key is part of the value_type.
template<class KeyType, class KeyHasher, class KeyValueEqual>
const_iterator find
(const KeyType &key, KeyHasher hasher, KeyValueEqual equal) const
@@ -586,9 +966,35 @@ class hashtable
, const_bucket_info_ptr(&this->priv_bucket_info()));
}
//! <b>Effects</b>: Returns a range containing all elements with values equivalent
//! to value. Returns std::make_pair(this->end(), this->end()) if no such
//! elements exist.
//!
//! <b>Complexity</b>: Average case O(this->count(value)). Worst case O(this->size()).
//!
//! <b>Throws</b>: If the internal hasher or the equality functor throws.
std::pair<iterator,iterator> equal_range(const_reference value)
{ return this->equal_range(value, this->priv_hasher(), this->priv_equal()); }
//! <b>Requires</b>: "hasher" must be a hash function that induces
//! the same hash values as the stored hasher. The difference is that
//! "hasher" hashes the given key instead of the value_type.
//!
//! "key_value_equal" must be a equality function that induces
//! the same equality as key_equal. The difference is that
//! "key_value_equal" compares an arbitrary key with the contained values.
//!
//! <b>Effects</b>: Returns a range containing all elements with equivalent
//! keys. Returns std::make_pair(this->end(), this->end()) if no such
//! elements exist.
//!
//! <b>Complexity</b>: Average case O(this->count(key, hasher, equal)). Worst case O(this->size()).
//!
//! <b>Throws</b>: If hasher or the equal throw.
//!
//! <b>Note</b>: This function is used when constructing a value_type
//! is expensive and the value_type can be compared with a cheaper
//! key type. Usually this key is part of the value_type.
template<class KeyType, class KeyHasher, class KeyValueEqual>
std::pair<iterator,iterator> equal_range
(const KeyType &key, KeyHasher hasher, KeyValueEqual equal)
@@ -602,10 +1008,36 @@ class hashtable
, iterator( ret.second, info_ptr) );
}
//! <b>Effects</b>: Returns a range containing all elements with values equivalent
//! to value. Returns std::make_pair(this->end(), this->end()) if no such
//! elements exist.
//!
//! <b>Complexity</b>: Average case O(this->count(value)). Worst case O(this->size()).
//!
//! <b>Throws</b>: If the internal hasher or the equality functor throws.
std::pair<const_iterator, const_iterator>
equal_range(const_reference value) const
{ return this->equal_range(value, this->priv_hasher(), this->priv_equal()); }
//! <b>Requires</b>: "hasher" must be a hash function that induces
//! the same hash values as the stored hasher. The difference is that
//! "hasher" hashes the given key instead of the value_type.
//!
//! "key_value_equal" must be a equality function that induces
//! the same equality as key_equal. The difference is that
//! "key_value_equal" compares an arbitrary key with the contained values.
//!
//! <b>Effects</b>: Returns a range containing all elements with equivalent
//! keys. Returns std::make_pair(this->end(), this->end()) if no such
//! elements exist.
//!
//! <b>Complexity</b>: Average case O(this->count(key, hasher, equal)). Worst case O(this->size()).
//!
//! <b>Throws</b>: If the hasher or equal throw.
//!
//! <b>Note</b>: This function is used when constructing a value_type
//! is expensive and the value_type can be compared with a cheaper
//! key type. Usually this key is part of the value_type.
template<class KeyType, class KeyHasher, class KeyValueEqual>
std::pair<const_iterator,const_iterator> equal_range
(const KeyType &key, KeyHasher hasher, KeyValueEqual equal) const
@@ -619,46 +1051,217 @@ class hashtable
, const_iterator( ret.second, info_ptr) );
}
//! <b>Requires</b>: value must be an lvalue and shall be in a unordered_set of
//! appropriate type. Otherwise the behavior is undefined.
//!
//! <b>Effects</b>: Returns: a valid iterator belonging to the unordered_set
//! that points to the value
//!
//! <b>Complexity</b>: Constant.
//!
//! <b>Throws</b>: If the internal hash function throws.
iterator iterator_to(reference value)
{
return iterator( bucket_type::iterator_to(value)
, const_bucket_info_ptr(&this->priv_bucket_info()));
}
//! <b>Requires</b>: value must be an lvalue and shall be in a unordered_set of
//! appropriate type. Otherwise the behavior is undefined.
//!
//! <b>Effects</b>: Returns: a valid const_iterator belonging to the
//! unordered_set that points to the value
//!
//! <b>Complexity</b>: Constant.
//!
//! <b>Throws</b>: If the internal hash function throws.
const_iterator iterator_to(const_reference value) const
{
return const_iterator( bucket_type::iterator_to(const_cast<reference>(value))
, const_bucket_info_ptr(&this->priv_bucket_info()));
}
//! <b>Requires</b>: value must be an lvalue and shall be in a unordered_set of
//! appropriate type. Otherwise the behavior is undefined.
//!
//! <b>Effects</b>: Returns: a valid local_iterator belonging to the unordered_set
//! that points to the value
//!
//! <b>Complexity</b>: Constant.
//!
//! <b>Throws</b>: Nothing.
static local_iterator local_iterator_to(reference value)
{ return bucket_type::iterator_to(value); }
//! <b>Requires</b>: value must be an lvalue and shall be in a unordered_set of
//! appropriate type. Otherwise the behavior is undefined.
//!
//! <b>Effects</b>: Returns: a valid const_local_iterator belonging to
//! the unordered_set that points to the value
//!
//! <b>Complexity</b>: Constant.
//!
//! <b>Throws</b>: Nothing.
static const_local_iterator local_iterator_to(const_reference value)
{ return bucket_type::iterator_to(value); }
//! <b>Effects</b>: Returns the number of buckets passed in the constructor
//! or the last rehash function.
//!
//! <b>Complexity</b>: Constant.
//!
//! <b>Throws</b>: Nothing.
size_type bucket_count() const
{ return this->priv_buckets_len(); }
//! <b>Requires</b>: n is in the range [0, this->bucket_count()).
//!
//! <b>Effects</b>: Returns the number of elements in the nth bucket.
//!
//! <b>Complexity</b>: Constant.
//!
//! <b>Throws</b>: Nothing.
size_type bucket_size(size_type n) const
{ return this->priv_buckets()[n].size(); }
//! <b>Effects</b>: Returns the index of the bucket in which elements
//! with keys equivalent to k would be found, if any such element existed.
//!
//! <b>Complexity</b>: Constant.
//!
//! <b>Throws</b>: If the hash functor throws.
//!
//! <b>Note</b>: the return value is in the range [0, this->bucket_count()).
size_type bucket(const key_type& k) const
{ return this->bucket(k, this->priv_hasher()); }
//! <b>Requires</b>: "hasher" must be a hash function that induces
//! the same hash values as the stored hasher. The difference is that
//! "hasher" hashes the given key instead of the value_type.
//!
//! <b>Effects</b>: Returns the index of the bucket in which elements
//! with keys equivalent to k would be found, if any such element existed.
//!
//! <b>Complexity</b>: Constant.
//!
//! <b>Throws</b>: If hasher throws.
//!
//! <b>Note</b>: the return value is in the range [0, this->bucket_count()).
template<class KeyType, class KeyHasher>
size_type bucket(const KeyType& k, const KeyHasher &hasher) const
{ return hasher(k) % this->priv_buckets_len(); }
//! <b>Effects</b>: Returns the bucket array pointer passed in the constructor
//! or the last rehash function.
//!
//! <b>Complexity</b>: Constant.
//!
//! <b>Throws</b>: Nothing.
bucket_ptr bucket_pointer() const
{ return this->priv_buckets(); }
//! <b>Requires</b>: n is in the range [0, this->bucket_count()).
//!
//! <b>Effects</b>: Returns a local_iterator pointing to the beginning
//! of the sequence stored in the bucket n.
//!
//! <b>Complexity</b>: Constant.
//!
//! <b>Throws</b>: Nothing.
//!
//! <b>Note</b>: [this->begin(n), this->end(n)) is a valid range
//! containing all of the elements in the nth bucket.
local_iterator begin(size_type n)
{ return this->priv_buckets()[n].begin(); }
//! <b>Requires</b>: n is in the range [0, this->bucket_count()).
//!
//! <b>Effects</b>: Returns a const_local_iterator pointing to the beginning
//! of the sequence stored in the bucket n.
//!
//! <b>Complexity</b>: Constant.
//!
//! <b>Throws</b>: Nothing.
//!
//! <b>Note</b>: [this->begin(n), this->end(n)) is a valid range
//! containing all of the elements in the nth bucket.
const_local_iterator begin(size_type n) const
{ return this->cbegin(n); }
//! <b>Requires</b>: n is in the range [0, this->bucket_count()).
//!
//! <b>Effects</b>: Returns a const_local_iterator pointing to the beginning
//! of the sequence stored in the bucket n.
//!
//! <b>Complexity</b>: Constant.
//!
//! <b>Throws</b>: Nothing.
//!
//! <b>Note</b>: [this->begin(n), this->end(n)) is a valid range
//! containing all of the elements in the nth bucket.
const_local_iterator cbegin(size_type n) const
{ return const_cast<const bucket_type&>(this->priv_buckets()[n]).begin(); }
//! <b>Requires</b>: n is in the range [0, this->bucket_count()).
//!
//! <b>Effects</b>: Returns a local_iterator pointing to the end
//! of the sequence stored in the bucket n.
//!
//! <b>Complexity</b>: Constant.
//!
//! <b>Throws</b>: Nothing.
//!
//! <b>Note</b>: [this->begin(n), this->end(n)) is a valid range
//! containing all of the elements in the nth bucket.
local_iterator end(size_type n)
{ return this->priv_buckets()[n].end(); }
//! <b>Requires</b>: n is in the range [0, this->bucket_count()).
//!
//! <b>Effects</b>: Returns a const_local_iterator pointing to the end
//! of the sequence stored in the bucket n.
//!
//! <b>Complexity</b>: Constant.
//!
//! <b>Throws</b>: Nothing.
//!
//! <b>Note</b>: [this->begin(n), this->end(n)) is a valid range
//! containing all of the elements in the nth bucket.
const_local_iterator end(size_type n) const
{ return this->cend(n); }
//! <b>Requires</b>: n is in the range [0, this->bucket_count()).
//!
//! <b>Effects</b>: Returns a const_local_iterator pointing to the end
//! of the sequence stored in the bucket n.
//!
//! <b>Complexity</b>: Constant.
//!
//! <b>Throws</b>: Nothing.
//!
//! <b>Note</b>: [this->begin(n), this->end(n)) is a valid range
//! containing all of the elements in the nth bucket.
const_local_iterator cend(size_type n) const
{ return const_cast<const bucket_type&>(this->priv_buckets()[n]).end(); }
//! <b>Requires</b>: new_buckets must be a pointer to a new bucket array
//! or the same as the old bucket array. new_size is the length of the
//! the array pointed by new_buckets. If new_buckets == this->bucket_pointer()
//! n can be bigger or smaller than this->bucket_count().
//!
//! <b>Effects</b>: Updates the internal reference with the new bucket erases
//! the values from the old bucket and inserts then in the new one.
//!
//! <b>Complexity</b>: Average case linear in this->size(), worst case quadratic.
//!
//! <b>Throws</b>: If the hasher functor throws. Basic guarantee.
void rehash(bucket_ptr new_buckets, size_type new_buckets_len)
{
bucket_ptr old_buckets = this->priv_buckets();
size_type old_buckets_len = this->priv_buckets_len();
try{
#ifndef BOOST_INTRUSIVE_DISABLE_EXCEPTION_HANDLING
BOOST_TRY{
#endif
size_type n = 0;
const bool same_buffer = old_buckets == new_buckets;
//If the new bucket length is a common factor
@@ -701,36 +1304,29 @@ class hashtable
this->priv_buckets() = new_buckets;
this->priv_buckets_len() = new_buckets_len;
#ifndef BOOST_INTRUSIVE_DISABLE_EXCEPTION_HANDLING
}
catch(...){
BOOST_CATCH(...){
for(size_type n = 0; n < new_buckets_len; ++n){
new_buckets[n].clear();
old_buckets[n].clear();
}
size_traits::set_size(size_type(0));
throw;
BOOST_RETHROW;
}
BOOST_CATCH_END
#endif
}
iterator iterator_to(reference value)
{
return iterator( bucket_type::iterator_to(value)
, const_bucket_info_ptr(&this->priv_bucket_info()));
}
const_iterator iterator_to(const_reference value) const
{
return const_iterator( bucket_type::iterator_to(const_cast<reference>(value))
, const_bucket_info_ptr(&this->priv_bucket_info()));
}
static local_iterator local_iterator_to(reference value)
{ return bucket_type::iterator_to(value); }
static const_local_iterator local_iterator_to(const_reference value)
{ return bucket_type::iterator_to(value); }
// no throw
//! <b>Effects</b>: Returns the nearest new bucket count optimized for
//! the container that is bigger than n. This suggestion can be used
//! to create bucket arrays with a size that will usually improve
//! container's performance. If such value does not exist, the
//! higher possible value is returned.
//!
//! <b>Complexity</b>: Amortized constant time.
//!
//! <b>Throws</b>: Nothing.
static size_type suggested_upper_bucket_count(size_type n)
{
const std::size_t *primes = &detail::prime_list_holder<0>::prime_list[0];
@@ -742,7 +1338,15 @@ class hashtable
return size_type(*bound);
}
// no throw
//! <b>Effects</b>: Returns the nearest new bucket count optimized for
//! the container that is smaller than n. This suggestion can be used
//! to create bucket arrays with a size that will usually improve
//! container's performance. If such value does not exist, the
//! lower possible value is returned.
//!
//! <b>Complexity</b>: Amortized constant time.
//!
//! <b>Throws</b>: Nothing.
static size_type suggested_lower_bucket_count(size_type n)
{
const std::size_t *primes = &detail::prime_list_holder<0>::prime_list[0];
@@ -783,11 +1387,11 @@ class hashtable
template<class KeyType, class KeyHasher, class KeyValueEqual>
local_iterator priv_find
( const KeyType &key, KeyHasher hasher
, KeyValueEqual equal, size_type &bucket_number, size_type &hash) const
, KeyValueEqual equal, size_type &bucket_number, size_type &h) const
{
size_type b_len(this->priv_buckets_len());
hash = hasher(key);
bucket_number = hash % b_len;
h = hasher(key);
bucket_number = h % b_len;
if(ConstantTimeSize && this->empty()){
return invalid_local_it(this->priv_bucket_info());
@@ -815,11 +1419,11 @@ class hashtable
, size_type &bucket_number_second
, size_type &count) const
{
size_type hash;
size_type h;
count = 0;
//Let's see if the element is present
std::pair<local_iterator, local_iterator> to_return
( priv_find(key, hasher, equal, bucket_number_first, hash)
( priv_find(key, hasher, equal, bucket_number_first, h)
, invalid_local_it(this->priv_bucket_info()));
if(to_return.first == to_return.second){
bucket_number_second = bucket_number_first;

36
include/boost/intrusive/list.hpp
View File

@@ -22,6 +22,9 @@
#include <boost/intrusive/detail/pointer_to_other.hpp>
#include <boost/intrusive/linking_policy.hpp>
#include <boost/static_assert.hpp>
#ifndef BOOST_INTRUSIVE_DISABLE_EXCEPTION_HANDLING
#include <boost/detail/no_exceptions_support.hpp>
#endif
#include <iterator>
#include <algorithm>
#include <functional>
@@ -46,10 +49,10 @@ template< class ValueTraits
>
class list
: private detail::size_holder<ConstantTimeSize, SizeType>
, private ValueTraits::node_traits::node
{
/// @cond
private:
typename ValueTraits::node_traits::node root_;
typedef list<ValueTraits, ConstantTimeSize, SizeType> this_type;
typedef typename ValueTraits::node_traits node_traits;
typedef detail::size_holder<ConstantTimeSize, SizeType> size_traits;
@@ -99,10 +102,10 @@ class list
}
node_ptr get_root_node()
{ return node_ptr(&static_cast<node&>(*this)); }
{ return node_ptr(&root_); }
const_node_ptr get_root_node() const
{ return const_node_ptr(&static_cast<const node&>(*this)); }
{ return const_node_ptr(&root_); }
/// @endcond
public:
@@ -164,7 +167,7 @@ class list
{
node_ptr to_insert = ValueTraits::to_node_ptr(value);
if(safemode_or_autounlink)
BOOST_INTRUSIVE_SAFE_MODE_CONTAINER_INSERTION_ASSERT(node_algorithms::unique(to_insert));
BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert));
node_algorithms::link_before(this->get_root_node(), to_insert);
size_traits::increment();
}
@@ -183,7 +186,7 @@ class list
{
node_ptr to_insert = ValueTraits::to_node_ptr(value);
if(safemode_or_autounlink)
BOOST_INTRUSIVE_SAFE_MODE_CONTAINER_INSERTION_ASSERT(node_algorithms::unique(to_insert));
BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert));
node_algorithms::link_before(node_traits::get_next(this->get_root_node()), to_insert);
size_traits::increment();
}
@@ -409,7 +412,10 @@ class list
//!
//! <b>Complexity</b>: Constant.
static list &container_from_end_iterator(iterator end_iterator)
{ return static_cast<list&>(*end_iterator.pointed_node()); }
{
return *detail::parent_from_member<list, node>
( detail::get_pointer(end_iterator.pointed_node()), &list::root_);
}
//! <b>Precondition</b>: end_iterator must be a valid end const_iterator
//! of list.
@@ -420,7 +426,10 @@ class list
//!
//! <b>Complexity</b>: Constant.
static const list &container_from_end_iterator(const_iterator end_iterator)
{ return static_cast<const list&>(*end_iterator.pointed_node()); }
{
return *detail::parent_from_member<list, node>
( detail::get_pointer(end_iterator.pointed_node()), &list::root_);
}
//! <b>Effects</b>: Returns the number of the elements contained in the list.
//!
@@ -672,16 +681,21 @@ class list
void clone_from(const list &src, Cloner cloner, Disposer disposer)
{
this->clear_and_dispose(disposer);
try{
#ifndef BOOST_INTRUSIVE_DISABLE_EXCEPTION_HANDLING
BOOST_TRY{
#endif
const_iterator b(src.begin()), e(src.end());
for(; b != e; ++b){
this->push_back(*cloner(*b));
}
#ifndef BOOST_INTRUSIVE_DISABLE_EXCEPTION_HANDLING
}
catch(...){
BOOST_CATCH(...){
clear_and_dispose(disposer);
throw;
BOOST_RETHROW;
}
BOOST_CATCH_END
#endif
}
//! <b>Requires</b>: value must be an lvalue and p must be a valid iterator of *this.
@@ -699,7 +713,7 @@ class list
{
node_ptr to_insert = ValueTraits::to_node_ptr(value);
if(safemode_or_autounlink)
BOOST_INTRUSIVE_SAFE_MODE_CONTAINER_INSERTION_ASSERT(node_algorithms::unique(to_insert));
BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert));
node_algorithms::link_before(p.pointed_node(), to_insert);
size_traits::increment();
return iterator(to_insert);

6
include/boost/intrusive/list_hook.hpp
View File

@@ -53,7 +53,7 @@ class list_base_hook
/// @cond
private:
typedef circular_list_algorithms<node_traits> node_algorithms;
typedef circular_list_algorithms<node_traits> node_algorithms;
public:
typedef typename node_traits::node node;
@@ -174,7 +174,7 @@ class list_base_hook
//! copy-constructible or assignable.
template<class T>
struct value_traits
: detail::derivation_value_traits<T, this_type, Tag>
: detail::derivation_hook_value_traits<T, this_type, Tag>
{};
//! <b>Effects</b>: Converts a pointer to a node into
@@ -351,7 +351,7 @@ class list_member_hook
//! T doesn't need to be copy-constructible or assignable.
template<class T, this_type T::* M>
struct value_traits
: detail::member_value_traits<T, this_type, M>
: detail::member_hook_value_traits<T, this_type, M>
{};
//! <b>Effects</b>: Converts a pointer to a node into

66
include/boost/intrusive/member_value_traits.hpp Normal file
View File

@@ -0,0 +1,66 @@
/////////////////////////////////////////////////////////////////////////////
//
// (C) Copyright Ion Gaztanaga 2006-2007
//
// 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_MEMBER_VALUE_TRAITS_HPP
#define BOOST_INTRUSIVE_MEMBER_VALUE_TRAITS_HPP
#include <boost/intrusive/linking_policy.hpp>
#include <iterator>
#include <boost/intrusive/detail/parent_from_member.hpp>
namespace boost {
namespace intrusive {
//!This value traits template is used to create value traits
//!from user defined node traits where value_traits::value_type will
//!store a node_traits::node
template< class T, class NodeTraits
, typename NodeTraits::node T::* PtrToMember
, linking_policy Policy>
struct member_value_traits
{
public:
typedef NodeTraits node_traits;
typedef T value_type;
typedef typename node_traits::node node;
typedef typename node_traits::node_ptr node_ptr;
typedef typename node_traits::const_node_ptr const_node_ptr;
typedef typename boost::pointer_to_other<node_ptr, T>::type pointer;
typedef typename boost::pointer_to_other<node_ptr, const T>::type const_pointer;
typedef typename std::iterator_traits<pointer>::reference reference;
typedef typename std::iterator_traits<const_pointer>::reference const_reference;
enum { linking_policy = Policy };
static node_ptr to_node_ptr(reference value)
{ return node_ptr(&(value.*PtrToMember)); }
static const_node_ptr to_node_ptr(const_reference value)
{ return node_ptr(&(value.*PtrToMember)); }
static pointer to_value_ptr(node_ptr n)
{
return pointer(detail::parent_from_member<value_type, node>
(detail::get_pointer(n), PtrToMember));
}
static const_pointer to_value_ptr(const_node_ptr n)
{
return pointer(detail::parent_from_member<value_type, node>
(detail::get_pointer(n), PtrToMember));
}
};
} //namespace intrusive
} //namespace boost
#endif //BOOST_INTRUSIVE_MEMBER_VALUE_TRAITS_HPP

14
include/boost/intrusive/rbtree.hpp
View File

@@ -42,14 +42,14 @@ template < class ValueTraits
>
class rbtree
: private detail::size_holder<ConstantTimeSize, SizeType>
, private ValueTraits::node_traits::node
{
/// @cond
private:
typename ValueTraits::node_traits::node root_;
typedef rbtree<ValueTraits, Compare
,ConstantTimeSize, SizeType> this_type;
typedef typename ValueTraits::node_traits node_traits;
typedef detail::size_holder<ConstantTimeSize, SizeType> size_traits;
typedef detail::size_holder<ConstantTimeSize, SizeType> size_traits;
//noncopyable
rbtree (const rbtree&);
@@ -352,7 +352,7 @@ class rbtree
detail::key_node_ptr_compare<value_compare, ValueTraits> key_node_comp(priv_comp());
node_ptr to_insert(ValueTraits::to_node_ptr(value));
if(safemode_or_autounlink)
BOOST_INTRUSIVE_SAFE_MODE_CONTAINER_INSERTION_ASSERT(node_algorithms::unique(to_insert));
BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert));
size_traits::increment();
return iterator(node_algorithms::insert_equal_upper_bound
(node_ptr(&priv_header()), to_insert, key_node_comp));
@@ -374,7 +374,7 @@ class rbtree
detail::key_node_ptr_compare<value_compare, ValueTraits> key_node_comp(priv_comp());
node_ptr to_insert(ValueTraits::to_node_ptr(value));
if(safemode_or_autounlink)
BOOST_INTRUSIVE_SAFE_MODE_CONTAINER_INSERTION_ASSERT(node_algorithms::unique(to_insert));
BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert));
size_traits::increment();
return iterator(node_algorithms::insert_equal_lower_bound
(node_ptr(&priv_header()), to_insert, key_node_comp));
@@ -399,7 +399,7 @@ class rbtree
detail::key_node_ptr_compare<value_compare, ValueTraits> key_node_comp(priv_comp());
node_ptr to_insert(ValueTraits::to_node_ptr(value));
if(safemode_or_autounlink)
BOOST_INTRUSIVE_SAFE_MODE_CONTAINER_INSERTION_ASSERT(node_algorithms::unique(to_insert));
BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert));
size_traits::increment();
return iterator(node_algorithms::insert_equal
(node_ptr(&priv_header()), hint.pointed_node(), to_insert, key_node_comp));
@@ -539,7 +539,7 @@ class rbtree
{
node_ptr to_insert(ValueTraits::to_node_ptr(value));
if(safemode_or_autounlink)
BOOST_INTRUSIVE_SAFE_MODE_CONTAINER_INSERTION_ASSERT(node_algorithms::unique(to_insert));
BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert));
size_traits::increment();
node_algorithms::insert_unique_commit
(node_ptr(&priv_header()), to_insert, commit_data);
@@ -560,7 +560,7 @@ class rbtree
++ret;
node_ptr to_erase(i.pointed_node());
if(safemode_or_autounlink)
BOOST_INTRUSIVE_SAFE_MODE_CONTAINER_INSERTION_ASSERT(!node_algorithms::unique(to_erase));
BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(!node_algorithms::unique(to_erase));
node_algorithms::erase(&priv_header(), to_erase);
size_traits::decrement();
if(safemode_or_autounlink)

7
include/boost/intrusive/rbtree_algorithms.hpp
View File

@@ -43,7 +43,9 @@
#include <boost/intrusive/detail/assert.hpp>
#include <boost/intrusive/intrusive_fwd.hpp>
#include <cstddef>
#ifndef BOOST_INTRUSIVE_DISABLE_EXCEPTION_HANDLING
#include <boost/detail/no_exceptions_support.hpp>
#endif
#include <boost/intrusive/detail/utilities.hpp>
@@ -1112,8 +1114,9 @@ class rbtree_algorithms
// structural copy. source_root and new_parent must be non-null.
node_ptr top = cloner(source_root);
NodeTraits::set_parent(top, new_parent);
#ifndef BOOST_INTRUSIVE_DISABLE_EXCEPTION_HANDLING
BOOST_TRY {
#endif
if(NodeTraits::get_right(source_root)){
NodeTraits::set_right
(top, deep_clone_node(NodeTraits::get_right(source_root), top
@@ -1134,12 +1137,14 @@ class rbtree_algorithms
new_parent = y;
source_root = NodeTraits::get_left(source_root);
}
#ifndef BOOST_INTRUSIVE_DISABLE_EXCEPTION_HANDLING
}
BOOST_CATCH(...){
deep_dispose_node(top, disposer);
BOOST_RETHROW;
}
BOOST_CATCH_END
#endif
return top;
}

11
include/boost/intrusive/set.hpp
View File

@@ -1412,6 +1412,15 @@ class multiset
void clear_and_dispose(Disposer disposer)
{ return tree_.clear_and_dispose(disposer); }
//! <b>Effects</b>: Returns the number of contained elements with the given key
//!
//! <b>Complexity</b>: Logarithmic to the number of elements contained plus lineal
//! to number of objects with the given key.
//!
//! <b>Throws</b>: If the internal Compare ordering function throws.
size_type count(const_reference value) const
{ return tree_.count(value); }
//! <b>Effects</b>: Returns the number of contained elements with the same key
//! compared with the given comparison functor.
//!
@@ -1421,7 +1430,7 @@ class multiset
//! <b>Throws</b>: If comp ordering function throws.
template<class KeyType, class KeyValueCompare>
size_type count(const KeyType& key, KeyValueCompare comp) const
{ return tree_.find(key, comp) != end(); }
{ return tree_.count(key, comp); }
//! <b>Effects</b>: Returns an iterator to the first element whose
//! key is not less than k or end() if that element does not exist.

4
include/boost/intrusive/set_hook.hpp
View File

@@ -162,7 +162,7 @@ class set_base_hook
//! copy-constructible or assignable.
template<class T>
struct value_traits
: detail::derivation_value_traits<T, this_type, Tag>
: detail::derivation_hook_value_traits<T, this_type, Tag>
{};
//! <b>Effects</b>: Converts a pointer to a node into
@@ -318,7 +318,7 @@ class set_member_hook
//! T don't need to be copy-constructible or assignable.
template<class T, this_type T::* P>
struct value_traits
: detail::member_value_traits<T, this_type, P>
: detail::member_hook_value_traits<T, this_type, P>
{};
//! <b>Effects</b>: Converts a pointer to a node into

39
include/boost/intrusive/slist.hpp
View File

@@ -16,6 +16,9 @@
#include <boost/intrusive/detail/config_begin.hpp>
#include <boost/static_assert.hpp>
#ifndef BOOST_INTRUSIVE_DISABLE_EXCEPTION_HANDLING
#include <boost/detail/no_exceptions_support.hpp>
#endif
#include <boost/intrusive/detail/assert.hpp>
#include <boost/intrusive/intrusive_fwd.hpp>
#include <boost/intrusive/slist_hook.hpp>
@@ -56,11 +59,12 @@ template < class ValueTraits
>
class slist
: private detail::size_holder<ConstantTimeSize, SizeType>
, private ValueTraits::node_traits::node
{
/// @cond
private:
typedef slist<ValueTraits, ConstantTimeSize, SizeType> this_type;
typename ValueTraits::node_traits::node root_;
typedef slist<ValueTraits, ConstantTimeSize, SizeType> this_type;
typedef typename ValueTraits::node_traits node_traits;
typedef detail::size_holder<ConstantTimeSize, SizeType> size_traits;
@@ -102,10 +106,10 @@ class slist
BOOST_STATIC_ASSERT(!(ConstantTimeSize && ((int)ValueTraits::linking_policy == (int)auto_unlink)));
node_ptr get_root_node()
{ return node_ptr(&static_cast<node&>(*this)); }
{ return node_ptr(&root_); }
const_node_ptr get_root_node() const
{ return const_node_ptr(&static_cast<const node&>(*this)); }
{ return const_node_ptr(&root_); }
static node_ptr uncast(const_node_ptr ptr)
{
@@ -213,7 +217,7 @@ class slist
{
node_ptr to_insert = ValueTraits::to_node_ptr(value);
if(safemode_or_autounlink)
BOOST_INTRUSIVE_SAFE_MODE_CONTAINER_INSERTION_ASSERT(node_algorithms::unique(to_insert));
BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert));
node_algorithms::link_after(this->get_root_node(), to_insert);
size_traits::increment();
}
@@ -353,7 +357,10 @@ class slist
//!
//! <b>Complexity</b>: Constant.
static slist &container_from_end_iterator(iterator end_iterator)
{ return static_cast<slist&>(*end_iterator.pointed_node()); }
{
return *detail::parent_from_member<slist, node>
( detail::get_pointer(end_iterator.pointed_node()), &slist::root_);
}
//! <b>Precondition</b>: end_iterator must be a valid end const_iterator
//! of slist.
@@ -364,7 +371,10 @@ class slist
//!
//! <b>Complexity</b>: Constant.
static const slist &container_from_end_iterator(const_iterator end_iterator)
{ return static_cast<const slist&>(*end_iterator.pointed_node()); }
{
return *detail::parent_from_member<slist, node>
( detail::get_pointer(end_iterator.pointed_node()), &slist::root_);
}
//! <b>Effects</b>: Returns the number of the elements contained in the list.
//!
@@ -526,17 +536,22 @@ class slist
void clone_from(const slist &src, Cloner cloner, Disposer disposer)
{
this->clear_and_dispose(disposer);
try{
#ifndef BOOST_INTRUSIVE_DISABLE_EXCEPTION_HANDLING
BOOST_TRY{
#endif
iterator prev = this->before_begin();
const_iterator b(src.begin()), e(src.end());
for(; b != e; ++b, ++prev){
this->insert_after(prev, *cloner(*b));
}
#ifndef BOOST_INTRUSIVE_DISABLE_EXCEPTION_HANDLING
}
catch(...){
clear_and_dispose(disposer);
throw;
BOOST_CATCH(...){
this->clear_and_dispose(disposer);
BOOST_RETHROW;
}
BOOST_CATCH_END
#endif
}
//! <b>Requires</b>: value must be an lvalue and prev_p must point to an element
@@ -556,7 +571,7 @@ class slist
{
node_ptr n = ValueTraits::to_node_ptr(value);
if(safemode_or_autounlink)
BOOST_INTRUSIVE_SAFE_MODE_CONTAINER_INSERTION_ASSERT(node_algorithms::unique(n));
BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(n));
node_algorithms::link_after(prev_p.pointed_node(), n);
size_traits::increment();
return iterator (n);

4
include/boost/intrusive/slist_hook.hpp
View File

@@ -177,7 +177,7 @@ class slist_base_hook
//! copy-constructible or assignable.
template<class T>
struct value_traits
: detail::derivation_value_traits<T, this_type, Tag>
: detail::derivation_hook_value_traits<T, this_type, Tag>
{};
//! <b>Effects</b>: Converts a pointer to a node into
@@ -358,7 +358,7 @@ class slist_member_hook
//! T doesn't need to be copy-constructible or assignable.
template<class T, this_type T::* M>
struct value_traits
: detail::member_value_traits<T, this_type, M>
: detail::member_hook_value_traits<T, this_type, M>
{};
//! <b>Effects</b>: Converts a pointer to a node into

43
include/boost/intrusive/trivial_value_traits.hpp Normal file
View File

@@ -0,0 +1,43 @@
/////////////////////////////////////////////////////////////////////////////
//
// (C) Copyright Ion Gaztanaga 2006-2007
//
// 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_TRIVIAL_VALUE_TRAITS_HPP
#define BOOST_INTRUSIVE_TRIVIAL_VALUE_TRAITS_HPP
#include <boost/intrusive/linking_policy.hpp>
namespace boost {
namespace intrusive {
//!This value traits template is used to create value traits
//!from user defined node traits where value_traits::value_type and
//!node_traits::node should be equal
template<class NodeTraits, linking_policy LinkingPolicy = safe_link>
struct trivial_value_traits
{
typedef NodeTraits node_traits;
typedef typename node_traits::node_ptr node_ptr;
typedef typename node_traits::const_node_ptr const_node_ptr;
typedef typename node_traits::node value_type;
typedef node_ptr pointer;
typedef const_node_ptr const_pointer;
enum { linking_policy = LinkingPolicy };
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); }
};
} //namespace intrusive
} //namespace boost
#endif //BOOST_INTRUSIVE_TRIVIAL_VALUE_TRAITS_HPP

52
include/boost/intrusive/unordered_set.hpp
View File

@@ -302,6 +302,22 @@ class unordered_set
std::pair<iterator, bool> insert(reference value)
{ return table_.insert_unique(value); }
//! <b>Requires</b>: Dereferencing iterator must yield an lvalue
//! of type value_type.
//!
//! <b>Effects</b>: Equivalent to this->insert(t) for each element in [b, e).
//!
//! <b>Complexity</b>: Average case O(N), where N is std::distance(b, e).
//! Worst case O(N*this->size()).
//!
//! <b>Throws</b>: If the internal hasher or the equality functor throws. Basic guarantee.
//!
//! <b>Note</b>: Does not affect the validity of iterators and references.
//! No copy-constructors are called.
template<class Iterator>
void insert(Iterator b, Iterator e)
{ table_.insert_unique(b, e); }
//! <b>Requires</b>: "hasher" must be a hash function that induces
//! the same hash values as the stored hasher. The difference is that
//! "hasher" hashes the given key instead of the value_type.
@@ -364,22 +380,6 @@ class unordered_set
iterator insert_commit(reference value, const insert_commit_data &commit_data)
{ return table_.insert_unique_commit(value, commit_data); }
//! <b>Requires</b>: Dereferencing iterator must yield an lvalue
//! of type value_type.
//!
//! <b>Effects</b>: Equivalent to this->insert(t) for each element in [b, e).
//!
//! <b>Complexity</b>: Average case O(N), where N is std::distance(b, e).
//! Worst case O(N*this->size()).
//!
//! <b>Throws</b>: If the internal hasher or the equality functor throws. Basic guarantee.
//!
//! <b>Note</b>: Does not affect the validity of iterators and references.
//! No copy-constructors are called.
template<class Iterator>
void insert(Iterator b, Iterator e)
{ table_.insert_unique(b, e); }
//! <b>Effects</b>: Erases the element pointed to by i.
//!
//! <b>Complexity</b>: Average case O(1), worst case O(this->size()).
@@ -696,7 +696,7 @@ class unordered_set
//! <b>Requires</b>: value must be an lvalue and shall be in a unordered_set of
//! appropriate type. Otherwise the behavior is undefined.
//!
//! <b>Effects</b>: Returns: a valid iterator i belonging to the unordered_set
//! <b>Effects</b>: Returns: a valid iterator belonging to the unordered_set
//! that points to the value
//!
//! <b>Complexity</b>: Constant.
@@ -708,7 +708,7 @@ class unordered_set
//! <b>Requires</b>: value must be an lvalue and shall be in a unordered_set of
//! appropriate type. Otherwise the behavior is undefined.
//!
//! <b>Effects</b>: Returns: a valid const_iterator i belonging to the
//! <b>Effects</b>: Returns: a valid const_iterator belonging to the
//! unordered_set that points to the value
//!
//! <b>Complexity</b>: Constant.
@@ -720,7 +720,7 @@ class unordered_set
//! <b>Requires</b>: value must be an lvalue and shall be in a unordered_set of
//! appropriate type. Otherwise the behavior is undefined.
//!
//! <b>Effects</b>: Returns: a valid local_iterator i belonging to the unordered_set
//! <b>Effects</b>: Returns: a valid local_iterator belonging to the unordered_set
//! that points to the value
//!
//! <b>Complexity</b>: Constant.
@@ -732,7 +732,7 @@ class unordered_set
//! <b>Requires</b>: value must be an lvalue and shall be in a unordered_set of
//! appropriate type. Otherwise the behavior is undefined.
//!
//! <b>Effects</b>: Returns: a valid const_local_iterator i belonging to
//! <b>Effects</b>: Returns: a valid const_local_iterator belonging to
//! the unordered_set that points to the value
//!
//! <b>Complexity</b>: Constant.
@@ -768,7 +768,7 @@ class unordered_set
//! <b>Throws</b>: If the hash functor throws.
//!
//! <b>Note</b>: the return value is in the range [0, this->bucket_count()).
size_type bucket(const key_type& k) const
size_type bucket(const value_type& k) const
{ return table_.bucket(k); }
//! <b>Requires</b>: "hasher" must be a hash function that induces
@@ -1530,7 +1530,7 @@ class unordered_multiset
//! <b>Requires</b>: value must be an lvalue and shall be in a unordered_multiset of
//! appropriate type. Otherwise the behavior is undefined.
//!
//! <b>Effects</b>: Returns: a valid iterator i belonging to the unordered_multiset
//! <b>Effects</b>: Returns: a valid iterator belonging to the unordered_multiset
//! that points to the value
//!
//! <b>Complexity</b>: Constant.
@@ -1542,7 +1542,7 @@ class unordered_multiset
//! <b>Requires</b>: value must be an lvalue and shall be in a unordered_multiset of
//! appropriate type. Otherwise the behavior is undefined.
//!
//! <b>Effects</b>: Returns: a valid const_iterator i belonging to the
//! <b>Effects</b>: Returns: a valid const_iterator belonging to the
//! unordered_multiset that points to the value
//!
//! <b>Complexity</b>: Constant.
@@ -1554,7 +1554,7 @@ class unordered_multiset
//! <b>Requires</b>: value must be an lvalue and shall be in a unordered_multiset of
//! appropriate type. Otherwise the behavior is undefined.
//!
//! <b>Effects</b>: Returns: a valid local_iterator i belonging to the unordered_multiset
//! <b>Effects</b>: Returns: a valid local_iterator belonging to the unordered_multiset
//! that points to the value
//!
//! <b>Complexity</b>: Constant.
@@ -1566,7 +1566,7 @@ class unordered_multiset
//! <b>Requires</b>: value must be an lvalue and shall be in a unordered_multiset of
//! appropriate type. Otherwise the behavior is undefined.
//!
//! <b>Effects</b>: Returns: a valid const_local_iterator i belonging to
//! <b>Effects</b>: Returns: a valid const_local_iterator belonging to
//! the unordered_multiset that points to the value
//!
//! <b>Complexity</b>: Constant.
@@ -1602,7 +1602,7 @@ class unordered_multiset
//! <b>Throws</b>: If the hash functor throws.
//!
//! <b>Note</b>: the return value is in the range [0, this->bucket_count()).
size_type bucket(const key_type& k) const
size_type bucket(const value_type& k) const
{ return table_.bucket(k); }
//! <b>Requires</b>: "hasher" must be a hash function that induces

4
include/boost/intrusive/unordered_set_hook.hpp
View File

@@ -121,7 +121,7 @@ class unordered_set_base_hook
//! copy-constructible or assignable.
template<class T>
struct value_traits
: detail::derivation_value_traits<T, this_type, Tag>
: detail::derivation_hook_value_traits<T, this_type, Tag>
{};
//! <b>Effects</b>: Converts a pointer to a node into
@@ -241,7 +241,7 @@ class unordered_set_member_hook
//! T doesn't need to be copy-constructible or assignable.
template<class T, this_type T::* M>
struct value_traits
: detail::member_value_traits<T, this_type, M>
: detail::member_hook_value_traits<T, this_type, M>
{};
//! <b>Effects</b>: Removes the node if it's inserted in a container.