forked from boostorg/intrusive
- Implemented map and multimap-like interfaces.
- Refactored hashtable containers to reduce template instantiations.
This commit is contained in:
Ion Gaztañaga committed
1 parent
9ddcfa8e7d
commit
51de75799b
57 files changed
+5962
-8937
No files matched your search
+215
-175
@@ -40,15 +40,15 @@ namespace intrusive {
|
||||
#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED)
|
||||
template<class T, class ...Options>
|
||||
#else
|
||||
template<class ValueTraits, class Compare, class SizeType, bool ConstantTimeSize, typename HeaderHolder>
|
||||
template<class ValueTraits, class VoidOrKeyOfValue, class Compare, class SizeType, bool ConstantTimeSize, typename HeaderHolder>
|
||||
#endif
|
||||
class avl_set_impl
|
||||
#ifndef BOOST_INTRUSIVE_DOXYGEN_INVOKED
|
||||
: public bstree_impl<ValueTraits, Compare, SizeType, ConstantTimeSize, AvlTreeAlgorithms, HeaderHolder>
|
||||
: public bstree_impl<ValueTraits, VoidOrKeyOfValue, Compare, SizeType, ConstantTimeSize, AvlTreeAlgorithms, HeaderHolder>
|
||||
#endif
|
||||
{
|
||||
/// @cond
|
||||
typedef bstree_impl<ValueTraits, Compare, SizeType, ConstantTimeSize, AvlTreeAlgorithms, HeaderHolder> tree_type;
|
||||
typedef bstree_impl<ValueTraits, VoidOrKeyOfValue, Compare, SizeType, ConstantTimeSize, AvlTreeAlgorithms, HeaderHolder> tree_type;
|
||||
BOOST_MOVABLE_BUT_NOT_COPYABLE(avl_set_impl)
|
||||
|
||||
typedef tree_type implementation_defined;
|
||||
@@ -56,6 +56,8 @@ class avl_set_impl
|
||||
|
||||
public:
|
||||
typedef typename implementation_defined::value_type value_type;
|
||||
typedef typename implementation_defined::key_type key_type;
|
||||
typedef typename implementation_defined::key_of_value key_of_value;
|
||||
typedef typename implementation_defined::value_traits value_traits;
|
||||
typedef typename implementation_defined::pointer pointer;
|
||||
typedef typename implementation_defined::const_pointer const_pointer;
|
||||
@@ -80,16 +82,16 @@ class avl_set_impl
|
||||
|
||||
public:
|
||||
|
||||
//! @copydoc ::boost::intrusive::avltree::avltree(const value_compare &,const value_traits &)
|
||||
explicit avl_set_impl( const value_compare &cmp = value_compare()
|
||||
//! @copydoc ::boost::intrusive::avltree::avltree(const key_compare &,const value_traits &)
|
||||
explicit avl_set_impl( const key_compare &cmp = key_compare()
|
||||
, const value_traits &v_traits = value_traits())
|
||||
: tree_type(cmp, v_traits)
|
||||
{}
|
||||
|
||||
//! @copydoc ::boost::intrusive::avltree::avltree(bool,Iterator,Iterator,const value_compare &,const value_traits &)
|
||||
//! @copydoc ::boost::intrusive::avltree::avltree(bool,Iterator,Iterator,const key_compare &,const value_traits &)
|
||||
template<class Iterator>
|
||||
avl_set_impl( Iterator b, Iterator e
|
||||
, const value_compare &cmp = value_compare()
|
||||
, const key_compare &cmp = key_compare()
|
||||
, const value_traits &v_traits = value_traits())
|
||||
: tree_type(true, b, e, cmp, v_traits)
|
||||
{}
|
||||
@@ -171,11 +173,20 @@ class avl_set_impl
|
||||
//! @copydoc ::boost::intrusive::avltree::swap
|
||||
void swap(avl_set_impl& other);
|
||||
|
||||
//! @copydoc ::boost::intrusive::avltree::clone_from
|
||||
//! @copydoc ::boost::intrusive::avltree::clone_from(const avltree&,Cloner,Disposer)
|
||||
template <class Cloner, class Disposer>
|
||||
void clone_from(const avl_set_impl &src, Cloner cloner, Disposer disposer);
|
||||
|
||||
#endif //#ifdef BOOST_iNTRUSIVE_DOXYGEN_INVOKED
|
||||
#else
|
||||
|
||||
using tree_type::clone_from;
|
||||
|
||||
#endif //#ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
|
||||
|
||||
//! @copydoc ::boost::intrusive::avltree::clone_from(avltree&&,Cloner,Disposer)
|
||||
template <class Cloner, class Disposer>
|
||||
void clone_from(BOOST_RV_REF(avl_set_impl) src, Cloner cloner, Disposer disposer)
|
||||
{ tree_type::clone_from(BOOST_MOVE_BASE(tree_type, src), cloner, disposer); }
|
||||
|
||||
//! @copydoc ::boost::intrusive::avltree::insert_unique(reference)
|
||||
std::pair<iterator, bool> insert(reference value)
|
||||
@@ -185,18 +196,18 @@ class avl_set_impl
|
||||
iterator insert(const_iterator hint, reference value)
|
||||
{ return tree_type::insert_unique(hint, value); }
|
||||
|
||||
//! @copydoc ::boost::intrusive::avltree::insert_unique_check(const KeyType&,KeyValueCompare,insert_commit_data&)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
//! @copydoc ::boost::intrusive::avltree::insert_unique_check(const KeyType&,KeyTypeKeyCompare,insert_commit_data&)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
std::pair<iterator, bool> insert_check
|
||||
(const KeyType &key, KeyValueCompare key_value_comp, insert_commit_data &commit_data)
|
||||
{ return tree_type::insert_unique_check(key, key_value_comp, commit_data); }
|
||||
(const KeyType &key, KeyTypeKeyCompare comp, insert_commit_data &commit_data)
|
||||
{ return tree_type::insert_unique_check(key, comp, commit_data); }
|
||||
|
||||
//! @copydoc ::boost::intrusive::avltree::insert_unique_check(const_iterator,const KeyType&,KeyValueCompare,insert_commit_data&)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
//! @copydoc ::boost::intrusive::avltree::insert_unique_check(const_iterator,const KeyType&,KeyTypeKeyCompare,insert_commit_data&)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
std::pair<iterator, bool> insert_check
|
||||
(const_iterator hint, const KeyType &key
|
||||
,KeyValueCompare key_value_comp, insert_commit_data &commit_data)
|
||||
{ return tree_type::insert_unique_check(hint, key, key_value_comp, commit_data); }
|
||||
,KeyTypeKeyCompare comp, insert_commit_data &commit_data)
|
||||
{ return tree_type::insert_unique_check(hint, key, comp, commit_data); }
|
||||
|
||||
//! @copydoc ::boost::intrusive::avltree::insert_unique(Iterator,Iterator)
|
||||
template<class Iterator>
|
||||
@@ -223,12 +234,12 @@ class avl_set_impl
|
||||
//! @copydoc ::boost::intrusive::avltree::erase(const_iterator,const_iterator)
|
||||
iterator erase(const_iterator b, const_iterator e);
|
||||
|
||||
//! @copydoc ::boost::intrusive::avltree::erase(const_reference)
|
||||
size_type erase(const_reference value);
|
||||
//! @copydoc ::boost::intrusive::avltree::erase(const key_type &key)
|
||||
size_type erase(const key_type &key);
|
||||
|
||||
//! @copydoc ::boost::intrusive::avltree::erase(const KeyType&,KeyValueCompare)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
size_type erase(const KeyType& key, KeyValueCompare comp);
|
||||
//! @copydoc ::boost::intrusive::avltree::erase(const KeyType&,KeyTypeKeyCompare)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
size_type erase(const KeyType& key, KeyTypeKeyCompare comp);
|
||||
|
||||
//! @copydoc ::boost::intrusive::avltree::erase_and_dispose(const_iterator,Disposer)
|
||||
template<class Disposer>
|
||||
@@ -238,13 +249,13 @@ class avl_set_impl
|
||||
template<class Disposer>
|
||||
iterator erase_and_dispose(const_iterator b, const_iterator e, Disposer disposer);
|
||||
|
||||
//! @copydoc ::boost::intrusive::avltree::erase_and_dispose(const_reference, Disposer)
|
||||
//! @copydoc ::boost::intrusive::avltree::erase_and_dispose(const key_type &, Disposer)
|
||||
template<class Disposer>
|
||||
size_type erase_and_dispose(const_reference value, Disposer disposer);
|
||||
size_type erase_and_dispose(const key_type &key, Disposer disposer);
|
||||
|
||||
//! @copydoc ::boost::intrusive::avltree::erase_and_dispose(const KeyType&,KeyValueCompare,Disposer)
|
||||
template<class KeyType, class KeyValueCompare, class Disposer>
|
||||
size_type erase_and_dispose(const KeyType& key, KeyValueCompare comp, Disposer disposer);
|
||||
//! @copydoc ::boost::intrusive::avltree::erase_and_dispose(const KeyType&,KeyTypeKeyCompare,Disposer)
|
||||
template<class KeyType, class KeyTypeKeyCompare, class Disposer>
|
||||
size_type erase_and_dispose(const KeyType& key, KeyTypeKeyCompare comp, Disposer disposer);
|
||||
|
||||
//! @copydoc ::boost::intrusive::avltree::clear
|
||||
void clear();
|
||||
@@ -255,100 +266,100 @@ class avl_set_impl
|
||||
|
||||
#endif // #ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
|
||||
|
||||
//! @copydoc ::boost::intrusive::avltree::count(const_reference)const
|
||||
size_type count(const_reference value) const
|
||||
{ return static_cast<size_type>(this->tree_type::find(value) != this->tree_type::cend()); }
|
||||
//! @copydoc ::boost::intrusive::avltree::count(const key_type &)const
|
||||
size_type count(const key_type &key) const
|
||||
{ return static_cast<size_type>(this->tree_type::find(key) != this->tree_type::cend()); }
|
||||
|
||||
//! @copydoc ::boost::intrusive::avltree::count(const KeyType&,KeyValueCompare)const
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
size_type count(const KeyType& key, KeyValueCompare comp) const
|
||||
//! @copydoc ::boost::intrusive::avltree::count(const KeyType&,KeyTypeKeyCompare)const
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
size_type count(const KeyType& key, KeyTypeKeyCompare comp) const
|
||||
{ return static_cast<size_type>(this->tree_type::find(key, comp) != this->tree_type::cend()); }
|
||||
|
||||
#ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
|
||||
|
||||
//! @copydoc ::boost::intrusive::avltree::lower_bound(const_reference)
|
||||
iterator lower_bound(const_reference value);
|
||||
//! @copydoc ::boost::intrusive::avltree::lower_bound(const key_type &)
|
||||
iterator lower_bound(const key_type &key);
|
||||
|
||||
//! @copydoc ::boost::intrusive::avltree::lower_bound(const KeyType&,KeyValueCompare)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
iterator lower_bound(const KeyType& key, KeyValueCompare comp);
|
||||
//! @copydoc ::boost::intrusive::avltree::lower_bound(const KeyType&,KeyTypeKeyCompare)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
iterator lower_bound(const KeyType& key, KeyTypeKeyCompare comp);
|
||||
|
||||
//! @copydoc ::boost::intrusive::avltree::lower_bound(const_reference)const
|
||||
const_iterator lower_bound(const_reference value) const;
|
||||
//! @copydoc ::boost::intrusive::avltree::lower_bound(const key_type &)const
|
||||
const_iterator lower_bound(const key_type &key) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::avltree::lower_bound(const KeyType&,KeyValueCompare)const
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
const_iterator lower_bound(const KeyType& key, KeyValueCompare comp) const;
|
||||
//! @copydoc ::boost::intrusive::avltree::lower_bound(const KeyType&,KeyTypeKeyCompare)const
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
const_iterator lower_bound(const KeyType& key, KeyTypeKeyCompare comp) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::avltree::upper_bound(const_reference)
|
||||
iterator upper_bound(const_reference value);
|
||||
//! @copydoc ::boost::intrusive::avltree::upper_bound(const key_type &)
|
||||
iterator upper_bound(const key_type &key);
|
||||
|
||||
//! @copydoc ::boost::intrusive::avltree::upper_bound(const KeyType&,KeyValueCompare)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
iterator upper_bound(const KeyType& key, KeyValueCompare comp);
|
||||
//! @copydoc ::boost::intrusive::avltree::upper_bound(const KeyType&,KeyTypeKeyCompare)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
iterator upper_bound(const KeyType& key, KeyTypeKeyCompare comp);
|
||||
|
||||
//! @copydoc ::boost::intrusive::avltree::upper_bound(const_reference)const
|
||||
const_iterator upper_bound(const_reference value) const;
|
||||
//! @copydoc ::boost::intrusive::avltree::upper_bound(const key_type &)const
|
||||
const_iterator upper_bound(const key_type &key) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::avltree::upper_bound(const KeyType&,KeyValueCompare)const
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
const_iterator upper_bound(const KeyType& key, KeyValueCompare comp) const;
|
||||
//! @copydoc ::boost::intrusive::avltree::upper_bound(const KeyType&,KeyTypeKeyCompare)const
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
const_iterator upper_bound(const KeyType& key, KeyTypeKeyCompare comp) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::avltree::find(const_reference)
|
||||
iterator find(const_reference value);
|
||||
//! @copydoc ::boost::intrusive::avltree::find(const key_type &)
|
||||
iterator find(const key_type &key);
|
||||
|
||||
//! @copydoc ::boost::intrusive::avltree::find(const KeyType&,KeyValueCompare)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
iterator find(const KeyType& key, KeyValueCompare comp);
|
||||
//! @copydoc ::boost::intrusive::avltree::find(const KeyType&,KeyTypeKeyCompare)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
iterator find(const KeyType& key, KeyTypeKeyCompare comp);
|
||||
|
||||
//! @copydoc ::boost::intrusive::avltree::find(const_reference)const
|
||||
const_iterator find(const_reference value) const;
|
||||
//! @copydoc ::boost::intrusive::avltree::find(const key_type &)const
|
||||
const_iterator find(const key_type &key) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::avltree::find(const KeyType&,KeyValueCompare)const
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
const_iterator find(const KeyType& key, KeyValueCompare comp) const;
|
||||
//! @copydoc ::boost::intrusive::avltree::find(const KeyType&,KeyTypeKeyCompare)const
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
const_iterator find(const KeyType& key, KeyTypeKeyCompare comp) const;
|
||||
|
||||
#endif // #ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
|
||||
|
||||
//! @copydoc ::boost::intrusive::rbtree::equal_range(const_reference)
|
||||
std::pair<iterator,iterator> equal_range(const_reference value)
|
||||
{ return this->tree_type::lower_bound_range(value); }
|
||||
//! @copydoc ::boost::intrusive::rbtree::equal_range(const key_type &)
|
||||
std::pair<iterator,iterator> equal_range(const key_type &key)
|
||||
{ return this->tree_type::lower_bound_range(key); }
|
||||
|
||||
//! @copydoc ::boost::intrusive::rbtree::equal_range(const KeyType&,KeyValueCompare)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
std::pair<iterator,iterator> equal_range(const KeyType& key, KeyValueCompare comp)
|
||||
//! @copydoc ::boost::intrusive::rbtree::equal_range(const KeyType&,KeyTypeKeyCompare)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
std::pair<iterator,iterator> equal_range(const KeyType& key, KeyTypeKeyCompare comp)
|
||||
{ return this->tree_type::lower_bound_range(key, comp); }
|
||||
|
||||
//! @copydoc ::boost::intrusive::rbtree::equal_range(const_reference)const
|
||||
//! @copydoc ::boost::intrusive::rbtree::equal_range(const key_type &)const
|
||||
std::pair<const_iterator, const_iterator>
|
||||
equal_range(const_reference value) const
|
||||
{ return this->tree_type::lower_bound_range(value); }
|
||||
equal_range(const key_type &key) const
|
||||
{ return this->tree_type::lower_bound_range(key); }
|
||||
|
||||
//! @copydoc ::boost::intrusive::rbtree::equal_range(const KeyType&,KeyValueCompare)const
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
//! @copydoc ::boost::intrusive::rbtree::equal_range(const KeyType&,KeyTypeKeyCompare)const
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
std::pair<const_iterator, const_iterator>
|
||||
equal_range(const KeyType& key, KeyValueCompare comp) const
|
||||
equal_range(const KeyType& key, KeyTypeKeyCompare comp) const
|
||||
{ return this->tree_type::lower_bound_range(key, comp); }
|
||||
|
||||
#ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
|
||||
|
||||
//! @copydoc ::boost::intrusive::avltree::bounded_range(const_reference,const_reference,bool,bool)
|
||||
//! @copydoc ::boost::intrusive::avltree::bounded_range(const key_type &,const key_type &,bool,bool)
|
||||
std::pair<iterator,iterator> bounded_range
|
||||
(const_reference lower_value, const_reference upper_value, bool left_closed, bool right_closed);
|
||||
(const key_type &lower_key, const key_type &upper_key, bool left_closed, bool right_closed);
|
||||
|
||||
//! @copydoc ::boost::intrusive::avltree::bounded_range(const KeyType&,const KeyType&,KeyValueCompare,bool,bool)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
//! @copydoc ::boost::intrusive::avltree::bounded_range(const KeyType&,const KeyType&,KeyTypeKeyCompare,bool,bool)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
std::pair<iterator,iterator> bounded_range
|
||||
(const KeyType& lower_key, const KeyType& upper_key, KeyValueCompare comp, bool left_closed, bool right_closed);
|
||||
(const KeyType& lower_key, const KeyType& upper_key, KeyTypeKeyCompare comp, bool left_closed, bool right_closed);
|
||||
|
||||
//! @copydoc ::boost::intrusive::avltree::bounded_range(const_reference,const_reference,bool,bool)const
|
||||
//! @copydoc ::boost::intrusive::avltree::bounded_range(const key_type &,const key_type &,bool,bool)const
|
||||
std::pair<const_iterator, const_iterator>
|
||||
bounded_range(const_reference lower_value, const_reference upper_value, bool left_closed, bool right_closed) const;
|
||||
bounded_range(const key_type &lower_key, const key_type &upper_key, bool left_closed, bool right_closed) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::avltree::bounded_range(const KeyType&,const KeyType&,KeyValueCompare,bool,bool)const
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
//! @copydoc ::boost::intrusive::avltree::bounded_range(const KeyType&,const KeyType&,KeyTypeKeyCompare,bool,bool)const
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
std::pair<const_iterator, const_iterator> bounded_range
|
||||
(const KeyType& lower_key, const KeyType& upper_key, KeyValueCompare comp, bool left_closed, bool right_closed) const;
|
||||
(const KeyType& lower_key, const KeyType& upper_key, KeyTypeKeyCompare comp, bool left_closed, bool right_closed) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::avltree::s_iterator_to(reference)
|
||||
static iterator s_iterator_to(reference value);
|
||||
@@ -402,7 +413,7 @@ template<class T, class ...Options>
|
||||
#else
|
||||
template<class T, class O1 = void, class O2 = void
|
||||
, class O3 = void, class O4 = void
|
||||
, class O5 = void>
|
||||
, class O5 = void, class O6 = void>
|
||||
#endif
|
||||
struct make_avl_set
|
||||
{
|
||||
@@ -410,7 +421,7 @@ struct make_avl_set
|
||||
typedef typename pack_options
|
||||
< avltree_defaults,
|
||||
#if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
|
||||
O1, O2, O3, O4, O5
|
||||
O1, O2, O3, O4, O5, O6
|
||||
#else
|
||||
Options...
|
||||
#endif
|
||||
@@ -421,6 +432,7 @@ struct make_avl_set
|
||||
|
||||
typedef avl_set_impl
|
||||
< value_traits
|
||||
, typename packed_options::key_of_value
|
||||
, typename packed_options::compare
|
||||
, typename packed_options::size_type
|
||||
, packed_options::constant_time_size
|
||||
@@ -432,14 +444,14 @@ struct make_avl_set
|
||||
|
||||
#ifndef BOOST_INTRUSIVE_DOXYGEN_INVOKED
|
||||
#if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
|
||||
template<class T, class O1, class O2, class O3, class O4, class O5>
|
||||
template<class T, class O1, class O2, class O3, class O4, class O5, class O6>
|
||||
#else
|
||||
template<class T, class ...Options>
|
||||
#endif
|
||||
class avl_set
|
||||
: public make_avl_set<T,
|
||||
#if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
|
||||
O1, O2, O3, O4, O5
|
||||
O1, O2, O3, O4, O5, O6
|
||||
#else
|
||||
Options...
|
||||
#endif
|
||||
@@ -448,7 +460,7 @@ class avl_set
|
||||
typedef typename make_avl_set
|
||||
<T,
|
||||
#if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
|
||||
O1, O2, O3, O4, O5
|
||||
O1, O2, O3, O4, O5, O6
|
||||
#else
|
||||
Options...
|
||||
#endif
|
||||
@@ -456,7 +468,7 @@ class avl_set
|
||||
|
||||
BOOST_MOVABLE_BUT_NOT_COPYABLE(avl_set)
|
||||
public:
|
||||
typedef typename Base::value_compare value_compare;
|
||||
typedef typename Base::key_compare key_compare;
|
||||
typedef typename Base::value_traits value_traits;
|
||||
typedef typename Base::iterator iterator;
|
||||
typedef typename Base::const_iterator const_iterator;
|
||||
@@ -464,14 +476,14 @@ class avl_set
|
||||
//Assert if passed value traits are compatible with the type
|
||||
BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value));
|
||||
|
||||
explicit avl_set( const value_compare &cmp = value_compare()
|
||||
explicit avl_set( const key_compare &cmp = key_compare()
|
||||
, const value_traits &v_traits = value_traits())
|
||||
: Base(cmp, v_traits)
|
||||
{}
|
||||
|
||||
template<class Iterator>
|
||||
avl_set( Iterator b, Iterator e
|
||||
, const value_compare &cmp = value_compare()
|
||||
, const key_compare &cmp = key_compare()
|
||||
, const value_traits &v_traits = value_traits())
|
||||
: Base(b, e, cmp, v_traits)
|
||||
{}
|
||||
@@ -483,6 +495,14 @@ class avl_set
|
||||
avl_set& operator=(BOOST_RV_REF(avl_set) x)
|
||||
{ return static_cast<avl_set &>(this->Base::operator=(BOOST_MOVE_BASE(Base, x))); }
|
||||
|
||||
template <class Cloner, class Disposer>
|
||||
void clone_from(const avl_set &src, Cloner cloner, Disposer disposer)
|
||||
{ Base::clone_from(src, cloner, disposer); }
|
||||
|
||||
template <class Cloner, class Disposer>
|
||||
void clone_from(BOOST_RV_REF(avl_set) src, Cloner cloner, Disposer disposer)
|
||||
{ Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer); }
|
||||
|
||||
static avl_set &container_from_end_iterator(iterator end_iterator)
|
||||
{ return static_cast<avl_set &>(Base::container_from_end_iterator(end_iterator)); }
|
||||
|
||||
@@ -512,15 +532,15 @@ class avl_set
|
||||
#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED)
|
||||
template<class T, class ...Options>
|
||||
#else
|
||||
template<class ValueTraits, class Compare, class SizeType, bool ConstantTimeSize, typename HeaderHolder>
|
||||
template<class ValueTraits, class VoidOrKeyOfValue, class Compare, class SizeType, bool ConstantTimeSize, typename HeaderHolder>
|
||||
#endif
|
||||
class avl_multiset_impl
|
||||
#ifndef BOOST_INTRUSIVE_DOXYGEN_INVOKED
|
||||
: public bstree_impl<ValueTraits, Compare, SizeType, ConstantTimeSize, AvlTreeAlgorithms, HeaderHolder>
|
||||
: public bstree_impl<ValueTraits, VoidOrKeyOfValue, Compare, SizeType, ConstantTimeSize, AvlTreeAlgorithms, HeaderHolder>
|
||||
#endif
|
||||
{
|
||||
/// @cond
|
||||
typedef bstree_impl<ValueTraits, Compare, SizeType, ConstantTimeSize, AvlTreeAlgorithms, HeaderHolder> tree_type;
|
||||
typedef bstree_impl<ValueTraits, VoidOrKeyOfValue, Compare, SizeType, ConstantTimeSize, AvlTreeAlgorithms, HeaderHolder> tree_type;
|
||||
|
||||
BOOST_MOVABLE_BUT_NOT_COPYABLE(avl_multiset_impl)
|
||||
typedef tree_type implementation_defined;
|
||||
@@ -528,6 +548,8 @@ class avl_multiset_impl
|
||||
|
||||
public:
|
||||
typedef typename implementation_defined::value_type value_type;
|
||||
typedef typename implementation_defined::key_type key_type;
|
||||
typedef typename implementation_defined::key_of_value key_of_value;
|
||||
typedef typename implementation_defined::value_traits value_traits;
|
||||
typedef typename implementation_defined::pointer pointer;
|
||||
typedef typename implementation_defined::const_pointer const_pointer;
|
||||
@@ -551,16 +573,16 @@ class avl_multiset_impl
|
||||
static const bool constant_time_size = tree_type::constant_time_size;
|
||||
|
||||
public:
|
||||
//! @copydoc ::boost::intrusive::avltree::avltree(const value_compare &,const value_traits &)
|
||||
explicit avl_multiset_impl( const value_compare &cmp = value_compare()
|
||||
//! @copydoc ::boost::intrusive::avltree::avltree(const key_compare &,const value_traits &)
|
||||
explicit avl_multiset_impl( const key_compare &cmp = key_compare()
|
||||
, const value_traits &v_traits = value_traits())
|
||||
: tree_type(cmp, v_traits)
|
||||
{}
|
||||
|
||||
//! @copydoc ::boost::intrusive::avltree::avltree(bool,Iterator,Iterator,const value_compare &,const value_traits &)
|
||||
//! @copydoc ::boost::intrusive::avltree::avltree(bool,Iterator,Iterator,const key_compare &,const value_traits &)
|
||||
template<class Iterator>
|
||||
avl_multiset_impl( Iterator b, Iterator e
|
||||
, const value_compare &cmp = value_compare()
|
||||
, const key_compare &cmp = key_compare()
|
||||
, const value_traits &v_traits = value_traits())
|
||||
: tree_type(false, b, e, cmp, v_traits)
|
||||
{}
|
||||
@@ -641,11 +663,20 @@ class avl_multiset_impl
|
||||
//! @copydoc ::boost::intrusive::avltree::swap
|
||||
void swap(avl_multiset_impl& other);
|
||||
|
||||
//! @copydoc ::boost::intrusive::avltree::clone_from
|
||||
//! @copydoc ::boost::intrusive::avltree::clone_from(const avltree&,Cloner,Disposer)
|
||||
template <class Cloner, class Disposer>
|
||||
void clone_from(const avl_multiset_impl &src, Cloner cloner, Disposer disposer);
|
||||
|
||||
#endif //#ifdef BOOST_iNTRUSIVE_DOXYGEN_INVOKED
|
||||
#else
|
||||
|
||||
using tree_type::clone_from;
|
||||
|
||||
#endif //#ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
|
||||
|
||||
//! @copydoc ::boost::intrusive::avltree::clone_from(avltree&&,Cloner,Disposer)
|
||||
template <class Cloner, class Disposer>
|
||||
void clone_from(BOOST_RV_REF(avl_multiset_impl) src, Cloner cloner, Disposer disposer)
|
||||
{ tree_type::clone_from(BOOST_MOVE_BASE(tree_type, src), cloner, disposer); }
|
||||
|
||||
//! @copydoc ::boost::intrusive::avltree::insert_equal(reference)
|
||||
iterator insert(reference value)
|
||||
@@ -676,12 +707,12 @@ class avl_multiset_impl
|
||||
//! @copydoc ::boost::intrusive::avltree::erase(const_iterator,const_iterator)
|
||||
iterator erase(const_iterator b, const_iterator e);
|
||||
|
||||
//! @copydoc ::boost::intrusive::avltree::erase(const_reference)
|
||||
size_type erase(const_reference value);
|
||||
//! @copydoc ::boost::intrusive::avltree::erase(const key_type &)
|
||||
size_type erase(const key_type &key);
|
||||
|
||||
//! @copydoc ::boost::intrusive::avltree::erase(const KeyType&,KeyValueCompare)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
size_type erase(const KeyType& key, KeyValueCompare comp);
|
||||
//! @copydoc ::boost::intrusive::avltree::erase(const KeyType&,KeyTypeKeyCompare)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
size_type erase(const KeyType& key, KeyTypeKeyCompare comp);
|
||||
|
||||
//! @copydoc ::boost::intrusive::avltree::erase_and_dispose(const_iterator,Disposer)
|
||||
template<class Disposer>
|
||||
@@ -691,13 +722,13 @@ class avl_multiset_impl
|
||||
template<class Disposer>
|
||||
iterator erase_and_dispose(const_iterator b, const_iterator e, Disposer disposer);
|
||||
|
||||
//! @copydoc ::boost::intrusive::avltree::erase_and_dispose(const_reference, Disposer)
|
||||
//! @copydoc ::boost::intrusive::avltree::erase_and_dispose(const key_type &, Disposer)
|
||||
template<class Disposer>
|
||||
size_type erase_and_dispose(const_reference value, Disposer disposer);
|
||||
size_type erase_and_dispose(const key_type &key, Disposer disposer);
|
||||
|
||||
//! @copydoc ::boost::intrusive::avltree::erase_and_dispose(const KeyType&,KeyValueCompare,Disposer)
|
||||
template<class KeyType, class KeyValueCompare, class Disposer>
|
||||
size_type erase_and_dispose(const KeyType& key, KeyValueCompare comp, Disposer disposer);
|
||||
//! @copydoc ::boost::intrusive::avltree::erase_and_dispose(const KeyType&,KeyTypeKeyCompare,Disposer)
|
||||
template<class KeyType, class KeyTypeKeyCompare, class Disposer>
|
||||
size_type erase_and_dispose(const KeyType& key, KeyTypeKeyCompare comp, Disposer disposer);
|
||||
|
||||
//! @copydoc ::boost::intrusive::avltree::clear
|
||||
void clear();
|
||||
@@ -706,88 +737,88 @@ class avl_multiset_impl
|
||||
template<class Disposer>
|
||||
void clear_and_dispose(Disposer disposer);
|
||||
|
||||
//! @copydoc ::boost::intrusive::avltree::count(const_reference)const
|
||||
size_type count(const_reference value) const;
|
||||
//! @copydoc ::boost::intrusive::avltree::count(const key_type &)const
|
||||
size_type count(const key_type &key) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::avltree::count(const KeyType&,KeyValueCompare)const
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
size_type count(const KeyType& key, KeyValueCompare comp) const;
|
||||
//! @copydoc ::boost::intrusive::avltree::count(const KeyType&,KeyTypeKeyCompare)const
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
size_type count(const KeyType& key, KeyTypeKeyCompare comp) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::avltree::lower_bound(const_reference)
|
||||
iterator lower_bound(const_reference value);
|
||||
//! @copydoc ::boost::intrusive::avltree::lower_bound(const key_type &)
|
||||
iterator lower_bound(const key_type &key);
|
||||
|
||||
//! @copydoc ::boost::intrusive::avltree::lower_bound(const KeyType&,KeyValueCompare)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
iterator lower_bound(const KeyType& key, KeyValueCompare comp);
|
||||
//! @copydoc ::boost::intrusive::avltree::lower_bound(const KeyType&,KeyTypeKeyCompare)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
iterator lower_bound(const KeyType& key, KeyTypeKeyCompare comp);
|
||||
|
||||
//! @copydoc ::boost::intrusive::avltree::lower_bound(const_reference)const
|
||||
const_iterator lower_bound(const_reference value) const;
|
||||
//! @copydoc ::boost::intrusive::avltree::lower_bound(const key_type &)const
|
||||
const_iterator lower_bound(const key_type &key) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::avltree::lower_bound(const KeyType&,KeyValueCompare)const
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
const_iterator lower_bound(const KeyType& key, KeyValueCompare comp) const;
|
||||
//! @copydoc ::boost::intrusive::avltree::lower_bound(const KeyType&,KeyTypeKeyCompare)const
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
const_iterator lower_bound(const KeyType& key, KeyTypeKeyCompare comp) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::avltree::upper_bound(const_reference)
|
||||
iterator upper_bound(const_reference value);
|
||||
//! @copydoc ::boost::intrusive::avltree::upper_bound(const key_type &)
|
||||
iterator upper_bound(const key_type &key);
|
||||
|
||||
//! @copydoc ::boost::intrusive::avltree::upper_bound(const KeyType&,KeyValueCompare)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
iterator upper_bound(const KeyType& key, KeyValueCompare comp);
|
||||
//! @copydoc ::boost::intrusive::avltree::upper_bound(const KeyType&,KeyTypeKeyCompare)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
iterator upper_bound(const KeyType& key, KeyTypeKeyCompare comp);
|
||||
|
||||
//! @copydoc ::boost::intrusive::avltree::upper_bound(const_reference)const
|
||||
const_iterator upper_bound(const_reference value) const;
|
||||
//! @copydoc ::boost::intrusive::avltree::upper_bound(const key_type &)const
|
||||
const_iterator upper_bound(const key_type &key) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::avltree::upper_bound(const KeyType&,KeyValueCompare)const
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
const_iterator upper_bound(const KeyType& key, KeyValueCompare comp) const;
|
||||
//! @copydoc ::boost::intrusive::avltree::upper_bound(const KeyType&,KeyTypeKeyCompare)const
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
const_iterator upper_bound(const KeyType& key, KeyTypeKeyCompare comp) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::avltree::find(const_reference)
|
||||
iterator find(const_reference value);
|
||||
//! @copydoc ::boost::intrusive::avltree::find(const key_type &)
|
||||
iterator find(const key_type &key);
|
||||
|
||||
//! @copydoc ::boost::intrusive::avltree::find(const KeyType&,KeyValueCompare)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
iterator find(const KeyType& key, KeyValueCompare comp);
|
||||
//! @copydoc ::boost::intrusive::avltree::find(const KeyType&,KeyTypeKeyCompare)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
iterator find(const KeyType& key, KeyTypeKeyCompare comp);
|
||||
|
||||
//! @copydoc ::boost::intrusive::avltree::find(const_reference)const
|
||||
const_iterator find(const_reference value) const;
|
||||
//! @copydoc ::boost::intrusive::avltree::find(const key_type &)const
|
||||
const_iterator find(const key_type &key) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::avltree::find(const KeyType&,KeyValueCompare)const
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
const_iterator find(const KeyType& key, KeyValueCompare comp) const;
|
||||
//! @copydoc ::boost::intrusive::avltree::find(const KeyType&,KeyTypeKeyCompare)const
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
const_iterator find(const KeyType& key, KeyTypeKeyCompare comp) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::avltree::equal_range(const_reference)
|
||||
std::pair<iterator,iterator> equal_range(const_reference value);
|
||||
//! @copydoc ::boost::intrusive::avltree::equal_range(const key_type &)
|
||||
std::pair<iterator,iterator> equal_range(const key_type &key);
|
||||
|
||||
//! @copydoc ::boost::intrusive::avltree::equal_range(const KeyType&,KeyValueCompare)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
std::pair<iterator,iterator> equal_range(const KeyType& key, KeyValueCompare comp);
|
||||
//! @copydoc ::boost::intrusive::avltree::equal_range(const KeyType&,KeyTypeKeyCompare)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
std::pair<iterator,iterator> equal_range(const KeyType& key, KeyTypeKeyCompare comp);
|
||||
|
||||
//! @copydoc ::boost::intrusive::avltree::equal_range(const_reference)const
|
||||
//! @copydoc ::boost::intrusive::avltree::equal_range(const key_type &)const
|
||||
std::pair<const_iterator, const_iterator>
|
||||
equal_range(const_reference value) const;
|
||||
equal_range(const key_type &key) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::avltree::equal_range(const KeyType&,KeyValueCompare)const
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
//! @copydoc ::boost::intrusive::avltree::equal_range(const KeyType&,KeyTypeKeyCompare)const
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
std::pair<const_iterator, const_iterator>
|
||||
equal_range(const KeyType& key, KeyValueCompare comp) const;
|
||||
equal_range(const KeyType& key, KeyTypeKeyCompare comp) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::avltree::bounded_range(const_reference,const_reference,bool,bool)
|
||||
//! @copydoc ::boost::intrusive::avltree::bounded_range(const key_type &,const key_type &,bool,bool)
|
||||
std::pair<iterator,iterator> bounded_range
|
||||
(const_reference lower_value, const_reference upper_value, bool left_closed, bool right_closed);
|
||||
(const key_type &lower_key, const key_type &upper_key, bool left_closed, bool right_closed);
|
||||
|
||||
//! @copydoc ::boost::intrusive::avltree::bounded_range(const KeyType&,const KeyType&,KeyValueCompare,bool,bool)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
//! @copydoc ::boost::intrusive::avltree::bounded_range(const KeyType&,const KeyType&,KeyTypeKeyCompare,bool,bool)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
std::pair<iterator,iterator> bounded_range
|
||||
(const KeyType& lower_key, const KeyType& upper_key, KeyValueCompare comp, bool left_closed, bool right_closed);
|
||||
(const KeyType& lower_key, const KeyType& upper_key, KeyTypeKeyCompare comp, bool left_closed, bool right_closed);
|
||||
|
||||
//! @copydoc ::boost::intrusive::avltree::bounded_range(const_reference,const_reference,bool,bool)const
|
||||
//! @copydoc ::boost::intrusive::avltree::bounded_range(const key_type &,const key_type &,bool,bool)const
|
||||
std::pair<const_iterator, const_iterator>
|
||||
bounded_range(const_reference lower_value, const_reference upper_value, bool left_closed, bool right_closed) const;
|
||||
bounded_range(const key_type &lower_key, const key_type &key upper_key, bool left_closed, bool right_closed) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::avltree::bounded_range(const KeyType&,const KeyType&,KeyValueCompare,bool,bool)const
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
//! @copydoc ::boost::intrusive::avltree::bounded_range(const KeyType&,const KeyType&,KeyTypeKeyCompare,bool,bool)const
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
std::pair<const_iterator, const_iterator> bounded_range
|
||||
(const KeyType& lower_key, const KeyType& upper_key, KeyValueCompare comp, bool left_closed, bool right_closed) const;
|
||||
(const KeyType& lower_key, const KeyType& upper_key, KeyTypeKeyCompare comp, bool left_closed, bool right_closed) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::avltree::s_iterator_to(reference)
|
||||
static iterator s_iterator_to(reference value);
|
||||
@@ -841,7 +872,7 @@ template<class T, class ...Options>
|
||||
#else
|
||||
template<class T, class O1 = void, class O2 = void
|
||||
, class O3 = void, class O4 = void
|
||||
, class O5 = void>
|
||||
, class O5 = void, class O6 = void>
|
||||
#endif
|
||||
struct make_avl_multiset
|
||||
{
|
||||
@@ -849,7 +880,7 @@ struct make_avl_multiset
|
||||
typedef typename pack_options
|
||||
< avltree_defaults,
|
||||
#if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
|
||||
O1, O2, O3, O4, O5
|
||||
O1, O2, O3, O4, O5, O6
|
||||
#else
|
||||
Options...
|
||||
#endif
|
||||
@@ -860,6 +891,7 @@ struct make_avl_multiset
|
||||
|
||||
typedef avl_multiset_impl
|
||||
< value_traits
|
||||
, typename packed_options::key_of_value
|
||||
, typename packed_options::compare
|
||||
, typename packed_options::size_type
|
||||
, packed_options::constant_time_size
|
||||
@@ -872,14 +904,14 @@ struct make_avl_multiset
|
||||
#ifndef BOOST_INTRUSIVE_DOXYGEN_INVOKED
|
||||
|
||||
#if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
|
||||
template<class T, class O1, class O2, class O3, class O4, class O5>
|
||||
template<class T, class O1, class O2, class O3, class O4, class O5, class O6>
|
||||
#else
|
||||
template<class T, class ...Options>
|
||||
#endif
|
||||
class avl_multiset
|
||||
: public make_avl_multiset<T,
|
||||
#if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
|
||||
O1, O2, O3, O4, O5
|
||||
O1, O2, O3, O4, O5, O6
|
||||
#else
|
||||
Options...
|
||||
#endif
|
||||
@@ -887,7 +919,7 @@ class avl_multiset
|
||||
{
|
||||
typedef typename make_avl_multiset<T,
|
||||
#if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
|
||||
O1, O2, O3, O4, O5
|
||||
O1, O2, O3, O4, O5, O6
|
||||
#else
|
||||
Options...
|
||||
#endif
|
||||
@@ -896,7 +928,7 @@ class avl_multiset
|
||||
BOOST_MOVABLE_BUT_NOT_COPYABLE(avl_multiset)
|
||||
|
||||
public:
|
||||
typedef typename Base::value_compare value_compare;
|
||||
typedef typename Base::key_compare key_compare;
|
||||
typedef typename Base::value_traits value_traits;
|
||||
typedef typename Base::iterator iterator;
|
||||
typedef typename Base::const_iterator const_iterator;
|
||||
@@ -904,14 +936,14 @@ class avl_multiset
|
||||
//Assert if passed value traits are compatible with the type
|
||||
BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value));
|
||||
|
||||
explicit avl_multiset( const value_compare &cmp = value_compare()
|
||||
explicit avl_multiset( const key_compare &cmp = key_compare()
|
||||
, const value_traits &v_traits = value_traits())
|
||||
: Base(cmp, v_traits)
|
||||
{}
|
||||
|
||||
template<class Iterator>
|
||||
avl_multiset( Iterator b, Iterator e
|
||||
, const value_compare &cmp = value_compare()
|
||||
, const key_compare &cmp = key_compare()
|
||||
, const value_traits &v_traits = value_traits())
|
||||
: Base(b, e, cmp, v_traits)
|
||||
{}
|
||||
@@ -923,6 +955,14 @@ class avl_multiset
|
||||
avl_multiset& operator=(BOOST_RV_REF(avl_multiset) x)
|
||||
{ return static_cast<avl_multiset &>(this->Base::operator=(BOOST_MOVE_BASE(Base, x))); }
|
||||
|
||||
template <class Cloner, class Disposer>
|
||||
void clone_from(const avl_multiset &src, Cloner cloner, Disposer disposer)
|
||||
{ Base::clone_from(src, cloner, disposer); }
|
||||
|
||||
template <class Cloner, class Disposer>
|
||||
void clone_from(BOOST_RV_REF(avl_multiset) src, Cloner cloner, Disposer disposer)
|
||||
{ Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer); }
|
||||
|
||||
static avl_multiset &container_from_end_iterator(iterator end_iterator)
|
||||
{ return static_cast<avl_multiset &>(Base::container_from_end_iterator(end_iterator)); }
|
||||
|
||||
|
||||
@@ -48,19 +48,16 @@ struct is_default_hook_tag<default_avltree_hook_applier>
|
||||
{ static const bool value = true; };
|
||||
|
||||
struct avltree_defaults
|
||||
: bstree_defaults
|
||||
{
|
||||
typedef default_avltree_hook_applier proto_value_traits;
|
||||
static const bool constant_time_size = true;
|
||||
typedef std::size_t size_type;
|
||||
typedef void compare;
|
||||
typedef void header_holder_type;
|
||||
};
|
||||
|
||||
/// @endcond
|
||||
|
||||
//! The class template avltree is an intrusive AVL tree container, that
|
||||
//! is used to construct intrusive avl_set and avl_multiset containers.
|
||||
//! The no-throw guarantee holds only, if the value_compare object
|
||||
//! The no-throw guarantee holds only, if the key_compare object
|
||||
//! doesn't throw.
|
||||
//!
|
||||
//! The template parameter \c T is the type to be managed by the container.
|
||||
@@ -74,17 +71,17 @@ struct avltree_defaults
|
||||
#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED)
|
||||
template<class T, class ...Options>
|
||||
#else
|
||||
template<class ValueTraits, class VoidOrKeyComp, class SizeType, bool ConstantTimeSize, typename HeaderHolder>
|
||||
template<class ValueTraits, class VoidOrKeyOfValue, class VoidOrKeyComp, class SizeType, bool ConstantTimeSize, typename HeaderHolder>
|
||||
#endif
|
||||
class avltree_impl
|
||||
/// @cond
|
||||
: public bstree_impl<ValueTraits, VoidOrKeyComp, SizeType, ConstantTimeSize, AvlTreeAlgorithms, HeaderHolder>
|
||||
: public bstree_impl<ValueTraits, VoidOrKeyOfValue, VoidOrKeyComp, SizeType, ConstantTimeSize, AvlTreeAlgorithms, HeaderHolder>
|
||||
/// @endcond
|
||||
{
|
||||
public:
|
||||
typedef ValueTraits value_traits;
|
||||
/// @cond
|
||||
typedef bstree_impl< ValueTraits, VoidOrKeyComp, SizeType
|
||||
typedef bstree_impl< ValueTraits, VoidOrKeyOfValue, VoidOrKeyComp, SizeType
|
||||
, ConstantTimeSize, AvlTreeAlgorithms
|
||||
, HeaderHolder> tree_type;
|
||||
typedef tree_type implementation_defined;
|
||||
@@ -94,6 +91,7 @@ class avltree_impl
|
||||
typedef typename implementation_defined::const_pointer const_pointer;
|
||||
typedef typename implementation_defined::value_type value_type;
|
||||
typedef typename implementation_defined::key_type key_type;
|
||||
typedef typename implementation_defined::key_of_value key_of_value;
|
||||
typedef typename implementation_defined::reference reference;
|
||||
typedef typename implementation_defined::const_reference const_reference;
|
||||
typedef typename implementation_defined::difference_type difference_type;
|
||||
@@ -124,16 +122,16 @@ class avltree_impl
|
||||
typedef typename implementation_defined::insert_commit_data insert_commit_data;
|
||||
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::bstree(const value_compare &,const value_traits &)
|
||||
explicit avltree_impl( const value_compare &cmp = value_compare()
|
||||
//! @copydoc ::boost::intrusive::bstree::bstree(const key_compare &,const value_traits &)
|
||||
explicit avltree_impl( const key_compare &cmp = key_compare()
|
||||
, const value_traits &v_traits = value_traits())
|
||||
: tree_type(cmp, v_traits)
|
||||
{}
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::bstree(bool,Iterator,Iterator,const value_compare &,const value_traits &)
|
||||
//! @copydoc ::boost::intrusive::bstree::bstree(bool,Iterator,Iterator,const key_compare &,const value_traits &)
|
||||
template<class Iterator>
|
||||
avltree_impl( bool unique, Iterator b, Iterator e
|
||||
, const value_compare &cmp = value_compare()
|
||||
, const key_compare &cmp = key_compare()
|
||||
, const value_traits &v_traits = value_traits())
|
||||
: tree_type(unique, b, e, cmp, v_traits)
|
||||
{}
|
||||
@@ -215,10 +213,23 @@ class avltree_impl
|
||||
//! @copydoc ::boost::intrusive::bstree::swap
|
||||
void swap(avltree_impl& other);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::clone_from
|
||||
//! @copydoc ::boost::intrusive::bstree::clone_from(const bstree&,Cloner,Disposer)
|
||||
template <class Cloner, class Disposer>
|
||||
void clone_from(const avltree_impl &src, Cloner cloner, Disposer disposer);
|
||||
|
||||
#else //BOOST_INTRUSIVE_DOXYGEN_INVOKED
|
||||
|
||||
using tree_type::clone_from;
|
||||
|
||||
#endif //#ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::clone_from(bstree&&,Cloner,Disposer)
|
||||
template <class Cloner, class Disposer>
|
||||
void clone_from(BOOST_RV_REF(avltree_impl) src, Cloner cloner, Disposer disposer)
|
||||
{ tree_type::clone_from(BOOST_MOVE_BASE(tree_type, src), cloner, disposer); }
|
||||
|
||||
#ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::insert_equal(reference)
|
||||
iterator insert_equal(reference value);
|
||||
|
||||
@@ -235,16 +246,16 @@ class avltree_impl
|
||||
//! @copydoc ::boost::intrusive::bstree::insert_unique(const_iterator,reference)
|
||||
iterator insert_unique(const_iterator hint, reference value);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::insert_unique_check(const KeyType&,KeyValueCompare,insert_commit_data&)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
//! @copydoc ::boost::intrusive::bstree::insert_unique_check(const KeyType&,KeyTypeKeyCompare,insert_commit_data&)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
std::pair<iterator, bool> insert_unique_check
|
||||
(const KeyType &key, KeyValueCompare key_value_comp, insert_commit_data &commit_data);
|
||||
(const KeyType &key, KeyTypeKeyCompare comp, insert_commit_data &commit_data);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::insert_unique_check(const_iterator,const KeyType&,KeyValueCompare,insert_commit_data&)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
//! @copydoc ::boost::intrusive::bstree::insert_unique_check(const_iterator,const KeyType&,KeyTypeKeyCompare,insert_commit_data&)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
std::pair<iterator, bool> insert_unique_check
|
||||
(const_iterator hint, const KeyType &key
|
||||
,KeyValueCompare key_value_comp, insert_commit_data &commit_data);
|
||||
,KeyTypeKeyCompare comp, insert_commit_data &commit_data);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::insert_unique_commit
|
||||
iterator insert_unique_commit(reference value, const insert_commit_data &commit_data);
|
||||
@@ -268,12 +279,12 @@ class avltree_impl
|
||||
//! @copydoc ::boost::intrusive::bstree::erase(const_iterator,const_iterator)
|
||||
iterator erase(const_iterator b, const_iterator e);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::erase(const_reference)
|
||||
size_type erase(const_reference value);
|
||||
//! @copydoc ::boost::intrusive::bstree::erase(const key_type &)
|
||||
size_type erase(const key_type &key);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::erase(const KeyType&,KeyValueCompare)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
size_type erase(const KeyType& key, KeyValueCompare comp);
|
||||
//! @copydoc ::boost::intrusive::bstree::erase(const KeyType&,KeyTypeKeyCompare)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
size_type erase(const KeyType& key, KeyTypeKeyCompare comp);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::erase_and_dispose(const_iterator,Disposer)
|
||||
template<class Disposer>
|
||||
@@ -283,13 +294,13 @@ class avltree_impl
|
||||
template<class Disposer>
|
||||
iterator erase_and_dispose(const_iterator b, const_iterator e, Disposer disposer);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::erase_and_dispose(const_reference, Disposer)
|
||||
//! @copydoc ::boost::intrusive::bstree::erase_and_dispose(const key_type &, Disposer)
|
||||
template<class Disposer>
|
||||
size_type erase_and_dispose(const_reference value, Disposer disposer);
|
||||
size_type erase_and_dispose(const key_type &key, Disposer disposer);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::erase_and_dispose(const KeyType&,KeyValueCompare,Disposer)
|
||||
template<class KeyType, class KeyValueCompare, class Disposer>
|
||||
size_type erase_and_dispose(const KeyType& key, KeyValueCompare comp, Disposer disposer);
|
||||
//! @copydoc ::boost::intrusive::bstree::erase_and_dispose(const KeyType&,KeyTypeKeyCompare,Disposer)
|
||||
template<class KeyType, class KeyTypeKeyCompare, class Disposer>
|
||||
size_type erase_and_dispose(const KeyType& key, KeyTypeKeyCompare comp, Disposer disposer);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::clear
|
||||
void clear();
|
||||
@@ -298,88 +309,88 @@ class avltree_impl
|
||||
template<class Disposer>
|
||||
void clear_and_dispose(Disposer disposer);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::count(const_reference)const
|
||||
size_type count(const_reference value) const;
|
||||
//! @copydoc ::boost::intrusive::bstree::count(const key_type &ke)const
|
||||
size_type count(const key_type &key) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::count(const KeyType&,KeyValueCompare)const
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
size_type count(const KeyType& key, KeyValueCompare comp) const;
|
||||
//! @copydoc ::boost::intrusive::bstree::count(const KeyType&,KeyTypeKeyCompare)const
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
size_type count(const KeyType& key, KeyTypeKeyCompare comp) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::lower_bound(const_reference)
|
||||
iterator lower_bound(const_reference value);
|
||||
//! @copydoc ::boost::intrusive::bstree::lower_bound(const key_type &)
|
||||
iterator lower_bound(const key_type &key);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::lower_bound(const KeyType&,KeyValueCompare)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
iterator lower_bound(const KeyType& key, KeyValueCompare comp);
|
||||
//! @copydoc ::boost::intrusive::bstree::lower_bound(const KeyType&,KeyTypeKeyCompare)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
iterator lower_bound(const KeyType& key, KeyTypeKeyCompare comp);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::lower_bound(const_reference)const
|
||||
const_iterator lower_bound(const_reference value) const;
|
||||
//! @copydoc ::boost::intrusive::bstree::lower_bound(const key_type &)const
|
||||
const_iterator lower_bound(const key_type &key) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::lower_bound(const KeyType&,KeyValueCompare)const
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
const_iterator lower_bound(const KeyType& key, KeyValueCompare comp) const;
|
||||
//! @copydoc ::boost::intrusive::bstree::lower_bound(const KeyType&,KeyTypeKeyCompare)const
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
const_iterator lower_bound(const KeyType& key, KeyTypeKeyCompare comp) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::upper_bound(const_reference)
|
||||
iterator upper_bound(const_reference value);
|
||||
//! @copydoc ::boost::intrusive::bstree::upper_bound(const key_type &key)
|
||||
iterator upper_bound(const key_type &key);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::upper_bound(const KeyType&,KeyValueCompare)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
iterator upper_bound(const KeyType& key, KeyValueCompare comp);
|
||||
//! @copydoc ::boost::intrusive::bstree::upper_bound(const KeyType&,KeyTypeKeyCompare)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
iterator upper_bound(const KeyType& key, KeyTypeKeyCompare comp);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::upper_bound(const_reference)const
|
||||
const_iterator upper_bound(const_reference value) const;
|
||||
//! @copydoc ::boost::intrusive::bstree::upper_bound(const key_type &)const
|
||||
const_iterator upper_bound(const key_type &key) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::upper_bound(const KeyType&,KeyValueCompare)const
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
const_iterator upper_bound(const KeyType& key, KeyValueCompare comp) const;
|
||||
//! @copydoc ::boost::intrusive::bstree::upper_bound(const KeyType&,KeyTypeKeyCompare)const
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
const_iterator upper_bound(const KeyType& key, KeyTypeKeyCompare comp) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::find(const_reference)
|
||||
iterator find(const_reference value);
|
||||
//! @copydoc ::boost::intrusive::bstree::find(const key_type &)
|
||||
iterator find(const key_type &key);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::find(const KeyType&,KeyValueCompare)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
iterator find(const KeyType& key, KeyValueCompare comp);
|
||||
//! @copydoc ::boost::intrusive::bstree::find(const KeyType&,KeyTypeKeyCompare)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
iterator find(const KeyType& key, KeyTypeKeyCompare comp);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::find(const_reference)const
|
||||
const_iterator find(const_reference value) const;
|
||||
//! @copydoc ::boost::intrusive::bstree::find(const key_type &)const
|
||||
const_iterator find(const key_type &key) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::find(const KeyType&,KeyValueCompare)const
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
const_iterator find(const KeyType& key, KeyValueCompare comp) const;
|
||||
//! @copydoc ::boost::intrusive::bstree::find(const KeyType&,KeyTypeKeyCompare)const
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
const_iterator find(const KeyType& key, KeyTypeKeyCompare comp) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::equal_range(const_reference)
|
||||
std::pair<iterator,iterator> equal_range(const_reference value);
|
||||
//! @copydoc ::boost::intrusive::bstree::equal_range(const key_type &)
|
||||
std::pair<iterator,iterator> equal_range(const key_type &key);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::equal_range(const KeyType&,KeyValueCompare)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
std::pair<iterator,iterator> equal_range(const KeyType& key, KeyValueCompare comp);
|
||||
//! @copydoc ::boost::intrusive::bstree::equal_range(const KeyType&,KeyTypeKeyCompare)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
std::pair<iterator,iterator> equal_range(const KeyType& key, KeyTypeKeyCompare comp);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::equal_range(const_reference)const
|
||||
//! @copydoc ::boost::intrusive::bstree::equal_range(const key_type &)const
|
||||
std::pair<const_iterator, const_iterator>
|
||||
equal_range(const_reference value) const;
|
||||
equal_range(const key_type &key) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::equal_range(const KeyType&,KeyValueCompare)const
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
//! @copydoc ::boost::intrusive::bstree::equal_range(const KeyType&,KeyTypeKeyCompare)const
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
std::pair<const_iterator, const_iterator>
|
||||
equal_range(const KeyType& key, KeyValueCompare comp) const;
|
||||
equal_range(const KeyType& key, KeyTypeKeyCompare comp) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::bounded_range(const_reference,const_reference,bool,bool)
|
||||
//! @copydoc ::boost::intrusive::bstree::bounded_range(const key_type &,const key_type &,bool,bool)
|
||||
std::pair<iterator,iterator> bounded_range
|
||||
(const_reference lower_value, const_reference upper_value, bool left_closed, bool right_closed);
|
||||
(const key_type &lower, const key_type &upper_key, bool left_closed, bool right_closed);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::bounded_range(const KeyType&,const KeyType&,KeyValueCompare,bool,bool)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
//! @copydoc ::boost::intrusive::bstree::bounded_range(const KeyType&,const KeyType&,KeyTypeKeyCompare,bool,bool)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
std::pair<iterator,iterator> bounded_range
|
||||
(const KeyType& lower_key, const KeyType& upper_key, KeyValueCompare comp, bool left_closed, bool right_closed);
|
||||
(const KeyType& lower_key, const KeyType& upper_key, KeyTypeKeyCompare comp, bool left_closed, bool right_closed);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::bounded_range(const_reference,const_reference,bool,bool)const
|
||||
//! @copydoc ::boost::intrusive::bstree::bounded_range(const key_type &,const key_type &,bool,bool)const
|
||||
std::pair<const_iterator, const_iterator>
|
||||
bounded_range(const_reference lower_value, const_reference upper_value, bool left_closed, bool right_closed) const;
|
||||
bounded_range(const key_type &lower_key, const key_type &upper_key, bool left_closed, bool right_closed) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::bounded_range(const KeyType&,const KeyType&,KeyValueCompare,bool,bool)const
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
//! @copydoc ::boost::intrusive::bstree::bounded_range(const KeyType&,const KeyType&,KeyTypeKeyCompare,bool,bool)const
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
std::pair<const_iterator, const_iterator> bounded_range
|
||||
(const KeyType& lower_key, const KeyType& upper_key, KeyValueCompare comp, bool left_closed, bool right_closed) const;
|
||||
(const KeyType& lower_key, const KeyType& upper_key, KeyTypeKeyCompare comp, bool left_closed, bool right_closed) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::s_iterator_to(reference)
|
||||
static iterator s_iterator_to(reference value);
|
||||
@@ -429,7 +440,7 @@ template<class T, class ...Options>
|
||||
#else
|
||||
template<class T, class O1 = void, class O2 = void
|
||||
, class O3 = void, class O4 = void
|
||||
, class O5 = void>
|
||||
, class O5 = void, class O6 = void>
|
||||
#endif
|
||||
struct make_avltree
|
||||
{
|
||||
@@ -437,7 +448,7 @@ struct make_avltree
|
||||
typedef typename pack_options
|
||||
< avltree_defaults,
|
||||
#if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
|
||||
O1, O2, O3, O4, O5
|
||||
O1, O2, O3, O4, O5, O6
|
||||
#else
|
||||
Options...
|
||||
#endif
|
||||
@@ -448,6 +459,7 @@ struct make_avltree
|
||||
|
||||
typedef avltree_impl
|
||||
< value_traits
|
||||
, typename packed_options::key_of_value
|
||||
, typename packed_options::compare
|
||||
, typename packed_options::size_type
|
||||
, packed_options::constant_time_size
|
||||
@@ -461,14 +473,14 @@ struct make_avltree
|
||||
#ifndef BOOST_INTRUSIVE_DOXYGEN_INVOKED
|
||||
|
||||
#if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
|
||||
template<class T, class O1, class O2, class O3, class O4, class O5>
|
||||
template<class T, class O1, class O2, class O3, class O4, class O5, class O6>
|
||||
#else
|
||||
template<class T, class ...Options>
|
||||
#endif
|
||||
class avltree
|
||||
: public make_avltree<T,
|
||||
#if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
|
||||
O1, O2, O3, O4, O5
|
||||
O1, O2, O3, O4, O5, O6
|
||||
#else
|
||||
Options...
|
||||
#endif
|
||||
@@ -477,7 +489,7 @@ class avltree
|
||||
typedef typename make_avltree
|
||||
<T,
|
||||
#if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
|
||||
O1, O2, O3, O4, O5
|
||||
O1, O2, O3, O4, O5, O6
|
||||
#else
|
||||
Options...
|
||||
#endif
|
||||
@@ -485,7 +497,7 @@ class avltree
|
||||
BOOST_MOVABLE_BUT_NOT_COPYABLE(avltree)
|
||||
|
||||
public:
|
||||
typedef typename Base::value_compare value_compare;
|
||||
typedef typename Base::key_compare key_compare;
|
||||
typedef typename Base::value_traits value_traits;
|
||||
typedef typename Base::iterator iterator;
|
||||
typedef typename Base::const_iterator const_iterator;
|
||||
@@ -495,14 +507,14 @@ class avltree
|
||||
//Assert if passed value traits are compatible with the type
|
||||
BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value));
|
||||
|
||||
explicit avltree( const value_compare &cmp = value_compare()
|
||||
explicit avltree( const key_compare &cmp = key_compare()
|
||||
, const value_traits &v_traits = value_traits())
|
||||
: Base(cmp, v_traits)
|
||||
{}
|
||||
|
||||
template<class Iterator>
|
||||
avltree( bool unique, Iterator b, Iterator e
|
||||
, const value_compare &cmp = value_compare()
|
||||
, const key_compare &cmp = key_compare()
|
||||
, const value_traits &v_traits = value_traits())
|
||||
: Base(unique, b, e, cmp, v_traits)
|
||||
{}
|
||||
@@ -514,6 +526,14 @@ class avltree
|
||||
avltree& operator=(BOOST_RV_REF(avltree) x)
|
||||
{ return static_cast<avltree &>(this->Base::operator=(BOOST_MOVE_BASE(Base, x))); }
|
||||
|
||||
template <class Cloner, class Disposer>
|
||||
void clone_from(const avltree &src, Cloner cloner, Disposer disposer)
|
||||
{ Base::clone_from(src, cloner, disposer); }
|
||||
|
||||
template <class Cloner, class Disposer>
|
||||
void clone_from(BOOST_RV_REF(avltree) src, Cloner cloner, Disposer disposer)
|
||||
{ Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer); }
|
||||
|
||||
static avltree &container_from_end_iterator(iterator end_iterator)
|
||||
{ return static_cast<avltree &>(Base::container_from_end_iterator(end_iterator)); }
|
||||
|
||||
|
||||
+214
-176
@@ -40,15 +40,15 @@ namespace intrusive {
|
||||
#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED)
|
||||
template<class T, class ...Options>
|
||||
#else
|
||||
template<class ValueTraits, class Compare, class SizeType, bool ConstantTimeSize, typename HeaderHolder>
|
||||
template<class ValueTraits, class VoidOrKeyOfValue, class Compare, class SizeType, bool ConstantTimeSize, typename HeaderHolder>
|
||||
#endif
|
||||
class bs_set_impl
|
||||
#ifndef BOOST_INTRUSIVE_DOXYGEN_INVOKED
|
||||
: public bstree_impl<ValueTraits, Compare, SizeType, ConstantTimeSize, BsTreeAlgorithms, HeaderHolder>
|
||||
: public bstree_impl<ValueTraits, VoidOrKeyOfValue, Compare, SizeType, ConstantTimeSize, BsTreeAlgorithms, HeaderHolder>
|
||||
#endif
|
||||
{
|
||||
/// @cond
|
||||
typedef bstree_impl<ValueTraits, Compare, SizeType, ConstantTimeSize, BsTreeAlgorithms, HeaderHolder> tree_type;
|
||||
typedef bstree_impl<ValueTraits, VoidOrKeyOfValue, Compare, SizeType, ConstantTimeSize, BsTreeAlgorithms, HeaderHolder> tree_type;
|
||||
BOOST_MOVABLE_BUT_NOT_COPYABLE(bs_set_impl)
|
||||
|
||||
typedef tree_type implementation_defined;
|
||||
@@ -56,6 +56,7 @@ class bs_set_impl
|
||||
|
||||
public:
|
||||
typedef typename implementation_defined::value_type value_type;
|
||||
typedef typename implementation_defined::key_type key_type;
|
||||
typedef typename implementation_defined::value_traits value_traits;
|
||||
typedef typename implementation_defined::pointer pointer;
|
||||
typedef typename implementation_defined::const_pointer const_pointer;
|
||||
@@ -79,16 +80,16 @@ class bs_set_impl
|
||||
static const bool constant_time_size = tree_type::constant_time_size;
|
||||
|
||||
public:
|
||||
//! @copydoc ::boost::intrusive::bstree::bstree(const value_compare &,const value_traits &)
|
||||
explicit bs_set_impl( const value_compare &cmp = value_compare()
|
||||
//! @copydoc ::boost::intrusive::bstree::bstree(const key_compare &,const value_traits &)
|
||||
explicit bs_set_impl( const key_compare &cmp = key_compare()
|
||||
, const value_traits &v_traits = value_traits())
|
||||
: tree_type(cmp, v_traits)
|
||||
{}
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::bstree(bool,Iterator,Iterator,const value_compare &,const value_traits &)
|
||||
//! @copydoc ::boost::intrusive::bstree::bstree(bool,Iterator,Iterator,const key_compare &,const value_traits &)
|
||||
template<class Iterator>
|
||||
bs_set_impl( Iterator b, Iterator e
|
||||
, const value_compare &cmp = value_compare()
|
||||
, const key_compare &cmp = key_compare()
|
||||
, const value_traits &v_traits = value_traits())
|
||||
: tree_type(true, b, e, cmp, v_traits)
|
||||
{}
|
||||
@@ -169,11 +170,20 @@ class bs_set_impl
|
||||
//! @copydoc ::boost::intrusive::bstree::swap
|
||||
void swap(bs_set_impl& other);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::clone_from
|
||||
//! @copydoc ::boost::intrusive::bstree::clone_from(const bstree&,Cloner,Disposer)
|
||||
template <class Cloner, class Disposer>
|
||||
void clone_from(const bs_set_impl &src, Cloner cloner, Disposer disposer);
|
||||
|
||||
#endif //#ifdef BOOST_iNTRUSIVE_DOXYGEN_INVOKED
|
||||
#else
|
||||
|
||||
using tree_type::clone_from;
|
||||
|
||||
#endif //#ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::clone_from(bstree&&,Cloner,Disposer)
|
||||
template <class Cloner, class Disposer>
|
||||
void clone_from(BOOST_RV_REF(bs_set_impl) src, Cloner cloner, Disposer disposer)
|
||||
{ tree_type::clone_from(BOOST_MOVE_BASE(tree_type, src), cloner, disposer); }
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::insert_unique(reference)
|
||||
std::pair<iterator, bool> insert(reference value)
|
||||
@@ -183,18 +193,18 @@ class bs_set_impl
|
||||
iterator insert(const_iterator hint, reference value)
|
||||
{ return tree_type::insert_unique(hint, value); }
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::insert_unique_check(const KeyType&,KeyValueCompare,insert_commit_data&)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
//! @copydoc ::boost::intrusive::bstree::insert_unique_check(const KeyType&,KeyTypeKeyCompare,insert_commit_data&)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
std::pair<iterator, bool> insert_check
|
||||
(const KeyType &key, KeyValueCompare key_value_comp, insert_commit_data &commit_data)
|
||||
{ return tree_type::insert_unique_check(key, key_value_comp, commit_data); }
|
||||
(const KeyType &key, KeyTypeKeyCompare comp, insert_commit_data &commit_data)
|
||||
{ return tree_type::insert_unique_check(key, comp, commit_data); }
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::insert_unique_check(const_iterator,const KeyType&,KeyValueCompare,insert_commit_data&)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
//! @copydoc ::boost::intrusive::bstree::insert_unique_check(const_iterator,const KeyType&,KeyTypeKeyCompare,insert_commit_data&)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
std::pair<iterator, bool> insert_check
|
||||
(const_iterator hint, const KeyType &key
|
||||
,KeyValueCompare key_value_comp, insert_commit_data &commit_data)
|
||||
{ return tree_type::insert_unique_check(hint, key, key_value_comp, commit_data); }
|
||||
,KeyTypeKeyCompare comp, insert_commit_data &commit_data)
|
||||
{ return tree_type::insert_unique_check(hint, key, comp, commit_data); }
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::insert_unique(Iterator,Iterator)
|
||||
template<class Iterator>
|
||||
@@ -221,12 +231,12 @@ class bs_set_impl
|
||||
//! @copydoc ::boost::intrusive::bstree::erase(const_iterator,const_iterator)
|
||||
iterator erase(const_iterator b, const_iterator e);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::erase(const_reference)
|
||||
size_type erase(const_reference value);
|
||||
//! @copydoc ::boost::intrusive::bstree::erase(const key_type &)
|
||||
size_type erase(const key_type &key);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::erase(const KeyType&,KeyValueCompare)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
size_type erase(const KeyType& key, KeyValueCompare comp);
|
||||
//! @copydoc ::boost::intrusive::bstree::erase(const KeyType&,KeyTypeKeyCompare)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
size_type erase(const KeyType& key, KeyTypeKeyCompare comp);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::erase_and_dispose(const_iterator,Disposer)
|
||||
template<class Disposer>
|
||||
@@ -236,13 +246,13 @@ class bs_set_impl
|
||||
template<class Disposer>
|
||||
iterator erase_and_dispose(const_iterator b, const_iterator e, Disposer disposer);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::erase_and_dispose(const_reference, Disposer)
|
||||
//! @copydoc ::boost::intrusive::bstree::erase_and_dispose(const key_type &, Disposer)
|
||||
template<class Disposer>
|
||||
size_type erase_and_dispose(const_reference value, Disposer disposer);
|
||||
size_type erase_and_dispose(const key_type &key, Disposer disposer);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::erase_and_dispose(const KeyType&,KeyValueCompare,Disposer)
|
||||
template<class KeyType, class KeyValueCompare, class Disposer>
|
||||
size_type erase_and_dispose(const KeyType& key, KeyValueCompare comp, Disposer disposer);
|
||||
//! @copydoc ::boost::intrusive::bstree::erase_and_dispose(const KeyType&,KeyTypeKeyCompare,Disposer)
|
||||
template<class KeyType, class KeyTypeKeyCompare, class Disposer>
|
||||
size_type erase_and_dispose(const KeyType& key, KeyTypeKeyCompare comp, Disposer disposer);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::clear
|
||||
void clear();
|
||||
@@ -253,100 +263,100 @@ class bs_set_impl
|
||||
|
||||
#endif // #ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::count(const_reference)const
|
||||
size_type count(const_reference value) const
|
||||
{ return static_cast<size_type>(this->tree_type::find(value) == this->tree_type::cend()); }
|
||||
//! @copydoc ::boost::intrusive::bstree::count(const key_type &)const
|
||||
size_type count(const key_type &key) const
|
||||
{ return static_cast<size_type>(this->tree_type::find(key) != this->tree_type::cend()); }
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::count(const KeyType&,KeyValueCompare)const
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
size_type count(const KeyType& key, KeyValueCompare comp) const
|
||||
{ return static_cast<size_type>(this->tree_type::find(key, comp) == this->tree_type::cend()); }
|
||||
//! @copydoc ::boost::intrusive::bstree::count(const KeyType&,KeyTypeKeyCompare)const
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
size_type count(const KeyType& key, KeyTypeKeyCompare comp) const
|
||||
{ return static_cast<size_type>(this->tree_type::find(key, comp) != this->tree_type::cend()); }
|
||||
|
||||
#ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::lower_bound(const_reference)
|
||||
iterator lower_bound(const_reference value);
|
||||
//! @copydoc ::boost::intrusive::bstree::lower_bound(const key_type &)
|
||||
iterator lower_bound(const key_type &);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::lower_bound(const KeyType&,KeyValueCompare)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
iterator lower_bound(const KeyType& key, KeyValueCompare comp);
|
||||
//! @copydoc ::boost::intrusive::bstree::lower_bound(const KeyType&,KeyTypeKeyCompare)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
iterator lower_bound(const KeyType& key, KeyTypeKeyCompare comp);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::lower_bound(const_reference)const
|
||||
const_iterator lower_bound(const_reference value) const;
|
||||
//! @copydoc ::boost::intrusive::bstree::lower_bound(const key_type &)const
|
||||
const_iterator lower_bound(const key_type &key) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::lower_bound(const KeyType&,KeyValueCompare)const
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
const_iterator lower_bound(const KeyType& key, KeyValueCompare comp) const;
|
||||
//! @copydoc ::boost::intrusive::bstree::lower_bound(const KeyType&,KeyTypeKeyCompare)const
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
const_iterator lower_bound(const KeyType& key, KeyTypeKeyCompare comp) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::upper_bound(const_reference)
|
||||
iterator upper_bound(const_reference value);
|
||||
//! @copydoc ::boost::intrusive::bstree::upper_bound(const key_type &)
|
||||
iterator upper_bound(const key_type &key);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::upper_bound(const KeyType&,KeyValueCompare)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
iterator upper_bound(const KeyType& key, KeyValueCompare comp);
|
||||
//! @copydoc ::boost::intrusive::bstree::upper_bound(const KeyType&,KeyTypeKeyCompare)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
iterator upper_bound(const KeyType& key, KeyTypeKeyCompare comp);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::upper_bound(const_reference)const
|
||||
const_iterator upper_bound(const_reference value) const;
|
||||
//! @copydoc ::boost::intrusive::bstree::upper_bound(const key_type &)const
|
||||
const_iterator upper_bound(const key_type &key) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::upper_bound(const KeyType&,KeyValueCompare)const
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
const_iterator upper_bound(const KeyType& key, KeyValueCompare comp) const;
|
||||
//! @copydoc ::boost::intrusive::bstree::upper_bound(const KeyType&,KeyTypeKeyCompare)const
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
const_iterator upper_bound(const KeyType& key, KeyTypeKeyCompare comp) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::find(const_reference)
|
||||
iterator find(const_reference value);
|
||||
//! @copydoc ::boost::intrusive::bstree::find(const key_type &)
|
||||
iterator find(const key_type &key);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::find(const KeyType&,KeyValueCompare)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
iterator find(const KeyType& key, KeyValueCompare comp);
|
||||
//! @copydoc ::boost::intrusive::bstree::find(const KeyType&,KeyTypeKeyCompare)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
iterator find(const KeyType& key, KeyTypeKeyCompare comp);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::find(const_reference)const
|
||||
const_iterator find(const_reference value) const;
|
||||
//! @copydoc ::boost::intrusive::bstree::find(const key_type &)const
|
||||
const_iterator find(const key_type &key) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::find(const KeyType&,KeyValueCompare)const
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
const_iterator find(const KeyType& key, KeyValueCompare comp) const;
|
||||
//! @copydoc ::boost::intrusive::bstree::find(const KeyType&,KeyTypeKeyCompare)const
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
const_iterator find(const KeyType& key, KeyTypeKeyCompare comp) const;
|
||||
|
||||
#endif // #ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
|
||||
|
||||
//! @copydoc ::boost::intrusive::rbtree::equal_range(const_reference)
|
||||
std::pair<iterator,iterator> equal_range(const_reference value)
|
||||
{ return this->tree_type::lower_bound_range(value); }
|
||||
//! @copydoc ::boost::intrusive::bstree::equal_range(const key_type &)
|
||||
std::pair<iterator,iterator> equal_range(const key_type &key)
|
||||
{ return this->tree_type::lower_bound_range(key); }
|
||||
|
||||
//! @copydoc ::boost::intrusive::rbtree::equal_range(const KeyType&,KeyValueCompare)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
std::pair<iterator,iterator> equal_range(const KeyType& key, KeyValueCompare comp)
|
||||
//! @copydoc ::boost::intrusive::bstree::equal_range(const KeyType&,KeyTypeKeyCompare)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
std::pair<iterator,iterator> equal_range(const KeyType& key, KeyTypeKeyCompare comp)
|
||||
{ return this->tree_type::lower_bound_range(key, comp); }
|
||||
|
||||
//! @copydoc ::boost::intrusive::rbtree::equal_range(const_reference)const
|
||||
//! @copydoc ::boost::intrusive::bstree::equal_range(const key_type &)const
|
||||
std::pair<const_iterator, const_iterator>
|
||||
equal_range(const_reference value) const
|
||||
{ return this->tree_type::lower_bound_range(value); }
|
||||
equal_range(const key_type &key) const
|
||||
{ return this->tree_type::lower_bound_range(key); }
|
||||
|
||||
//! @copydoc ::boost::intrusive::rbtree::equal_range(const KeyType&,KeyValueCompare)const
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
//! @copydoc ::boost::intrusive::bstree::equal_range(const KeyType&,KeyTypeKeyCompare)const
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
std::pair<const_iterator, const_iterator>
|
||||
equal_range(const KeyType& key, KeyValueCompare comp) const
|
||||
equal_range(const KeyType& key, KeyTypeKeyCompare comp) const
|
||||
{ return this->tree_type::lower_bound_range(key, comp); }
|
||||
|
||||
#ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::bounded_range(const_reference,const_reference,bool,bool)
|
||||
//! @copydoc ::boost::intrusive::bstree::bounded_range(const key_type&,const key_type&,bool,bool)
|
||||
std::pair<iterator,iterator> bounded_range
|
||||
(const_reference lower_value, const_reference upper_value, bool left_closed, bool right_closed);
|
||||
(const key_type& lower_key, const key_type& upper_key, bool left_closed, bool right_closed);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::bounded_range(const KeyType&,const KeyType&,KeyValueCompare,bool,bool)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
//! @copydoc ::boost::intrusive::bstree::bounded_range(const KeyType&,const KeyType&,KeyTypeKeyCompare,bool,bool)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
std::pair<iterator,iterator> bounded_range
|
||||
(const KeyType& lower_key, const KeyType& upper_key, KeyValueCompare comp, bool left_closed, bool right_closed);
|
||||
(const KeyType& lower_key, const KeyType& upper_key, KeyTypeKeyCompare comp, bool left_closed, bool right_closed);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::bounded_range(const_reference,const_reference,bool,bool)const
|
||||
//! @copydoc ::boost::intrusive::bstree::bounded_range(const key_type&,const key_type&,bool,bool)const
|
||||
std::pair<const_iterator, const_iterator>
|
||||
bounded_range(const_reference lower_value, const_reference upper_value, bool left_closed, bool right_closed) const;
|
||||
bounded_range(const key_type& lower_key, const key_type& upper_key, bool left_closed, bool right_closed) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::bounded_range(const KeyType&,const KeyType&,KeyValueCompare,bool,bool)const
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
//! @copydoc ::boost::intrusive::bstree::bounded_range(const KeyType&,const KeyType&,KeyTypeKeyCompare,bool,bool)const
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
std::pair<const_iterator, const_iterator> bounded_range
|
||||
(const KeyType& lower_key, const KeyType& upper_key, KeyValueCompare comp, bool left_closed, bool right_closed) const;
|
||||
(const KeyType& lower_key, const KeyType& upper_key, KeyTypeKeyCompare comp, bool left_closed, bool right_closed) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::s_iterator_to(reference)
|
||||
static iterator s_iterator_to(reference value);
|
||||
@@ -400,7 +410,7 @@ template<class T, class ...Options>
|
||||
#else
|
||||
template<class T, class O1 = void, class O2 = void
|
||||
, class O3 = void, class O4 = void
|
||||
, class O5 = void>
|
||||
, class O5 = void, class O6 = void>
|
||||
#endif
|
||||
struct make_bs_set
|
||||
{
|
||||
@@ -408,7 +418,7 @@ struct make_bs_set
|
||||
typedef typename pack_options
|
||||
< bstree_defaults,
|
||||
#if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
|
||||
O1, O2, O3, O4, O5
|
||||
O1, O2, O3, O4, O5, O6
|
||||
#else
|
||||
Options...
|
||||
#endif
|
||||
@@ -419,6 +429,7 @@ struct make_bs_set
|
||||
|
||||
typedef bs_set_impl
|
||||
< value_traits
|
||||
, typename packed_options::key_of_value
|
||||
, typename packed_options::compare
|
||||
, typename packed_options::size_type
|
||||
, packed_options::constant_time_size
|
||||
@@ -430,14 +441,14 @@ struct make_bs_set
|
||||
|
||||
#ifndef BOOST_INTRUSIVE_DOXYGEN_INVOKED
|
||||
#if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
|
||||
template<class T, class O1, class O2, class O3, class O4, class O5>
|
||||
template<class T, class O1, class O2, class O3, class O4, class O5, class O6>
|
||||
#else
|
||||
template<class T, class ...Options>
|
||||
#endif
|
||||
class bs_set
|
||||
: public make_bs_set<T,
|
||||
#if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
|
||||
O1, O2, O3, O4, O5
|
||||
O1, O2, O3, O4, O5, O6
|
||||
#else
|
||||
Options...
|
||||
#endif
|
||||
@@ -446,7 +457,7 @@ class bs_set
|
||||
typedef typename make_bs_set
|
||||
<T,
|
||||
#if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
|
||||
O1, O2, O3, O4, O5
|
||||
O1, O2, O3, O4, O5, O6
|
||||
#else
|
||||
Options...
|
||||
#endif
|
||||
@@ -454,22 +465,22 @@ class bs_set
|
||||
|
||||
BOOST_MOVABLE_BUT_NOT_COPYABLE(bs_set)
|
||||
public:
|
||||
typedef typename Base::value_compare value_compare;
|
||||
typedef typename Base::value_traits value_traits;
|
||||
typedef typename Base::key_compare key_compare;
|
||||
typedef typename Base::iterator iterator;
|
||||
typedef typename Base::const_iterator const_iterator;
|
||||
|
||||
//Assert if passed value traits are compatible with the type
|
||||
BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value));
|
||||
|
||||
explicit bs_set( const value_compare &cmp = value_compare()
|
||||
explicit bs_set( const key_compare &cmp = key_compare()
|
||||
, const value_traits &v_traits = value_traits())
|
||||
: Base(cmp, v_traits)
|
||||
{}
|
||||
|
||||
template<class Iterator>
|
||||
bs_set( Iterator b, Iterator e
|
||||
, const value_compare &cmp = value_compare()
|
||||
, const key_compare &cmp = key_compare()
|
||||
, const value_traits &v_traits = value_traits())
|
||||
: Base(b, e, cmp, v_traits)
|
||||
{}
|
||||
@@ -481,6 +492,14 @@ class bs_set
|
||||
bs_set& operator=(BOOST_RV_REF(bs_set) x)
|
||||
{ return static_cast<bs_set &>(this->Base::operator=(BOOST_MOVE_BASE(Base, x))); }
|
||||
|
||||
template <class Cloner, class Disposer>
|
||||
void clone_from(const bs_set &src, Cloner cloner, Disposer disposer)
|
||||
{ Base::clone_from(src, cloner, disposer); }
|
||||
|
||||
template <class Cloner, class Disposer>
|
||||
void clone_from(BOOST_RV_REF(bs_set) src, Cloner cloner, Disposer disposer)
|
||||
{ Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer); }
|
||||
|
||||
static bs_set &container_from_end_iterator(iterator end_iterator)
|
||||
{ return static_cast<bs_set &>(Base::container_from_end_iterator(end_iterator)); }
|
||||
|
||||
@@ -510,15 +529,15 @@ class bs_set
|
||||
#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED)
|
||||
template<class T, class ...Options>
|
||||
#else
|
||||
template<class ValueTraits, class Compare, class SizeType, bool ConstantTimeSize, typename HeaderHolder>
|
||||
template<class ValueTraits, class VoidOrKeyOfValue, class Compare, class SizeType, bool ConstantTimeSize, typename HeaderHolder>
|
||||
#endif
|
||||
class bs_multiset_impl
|
||||
#ifndef BOOST_INTRUSIVE_DOXYGEN_INVOKED
|
||||
: public bstree_impl<ValueTraits, Compare, SizeType, ConstantTimeSize, RbTreeAlgorithms, HeaderHolder>
|
||||
: public bstree_impl<ValueTraits, VoidOrKeyOfValue, Compare, SizeType, ConstantTimeSize, BsTreeAlgorithms, HeaderHolder>
|
||||
#endif
|
||||
{
|
||||
/// @cond
|
||||
typedef bstree_impl<ValueTraits, Compare, SizeType, ConstantTimeSize, RbTreeAlgorithms, HeaderHolder> tree_type;
|
||||
typedef bstree_impl<ValueTraits, VoidOrKeyOfValue, Compare, SizeType, ConstantTimeSize, BsTreeAlgorithms, HeaderHolder> tree_type;
|
||||
|
||||
BOOST_MOVABLE_BUT_NOT_COPYABLE(bs_multiset_impl)
|
||||
typedef tree_type implementation_defined;
|
||||
@@ -526,6 +545,7 @@ class bs_multiset_impl
|
||||
|
||||
public:
|
||||
typedef typename implementation_defined::value_type value_type;
|
||||
typedef typename implementation_defined::key_type key_type;
|
||||
typedef typename implementation_defined::value_traits value_traits;
|
||||
typedef typename implementation_defined::pointer pointer;
|
||||
typedef typename implementation_defined::const_pointer const_pointer;
|
||||
@@ -549,16 +569,16 @@ class bs_multiset_impl
|
||||
static const bool constant_time_size = tree_type::constant_time_size;
|
||||
|
||||
public:
|
||||
//! @copydoc ::boost::intrusive::bstree::bstree(const value_compare &,const value_traits &)
|
||||
explicit bs_multiset_impl( const value_compare &cmp = value_compare()
|
||||
//! @copydoc ::boost::intrusive::bstree::bstree(const key_compare &,const value_traits &)
|
||||
explicit bs_multiset_impl( const key_compare &cmp = key_compare()
|
||||
, const value_traits &v_traits = value_traits())
|
||||
: tree_type(cmp, v_traits)
|
||||
{}
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::bstree(bool,Iterator,Iterator,const value_compare &,const value_traits &)
|
||||
//! @copydoc ::boost::intrusive::bstree::bstree(bool,Iterator,Iterator,const key_compare &,const value_traits &)
|
||||
template<class Iterator>
|
||||
bs_multiset_impl( Iterator b, Iterator e
|
||||
, const value_compare &cmp = value_compare()
|
||||
, const key_compare &cmp = key_compare()
|
||||
, const value_traits &v_traits = value_traits())
|
||||
: tree_type(false, b, e, cmp, v_traits)
|
||||
{}
|
||||
@@ -639,11 +659,20 @@ class bs_multiset_impl
|
||||
//! @copydoc ::boost::intrusive::bstree::swap
|
||||
void swap(bs_multiset_impl& other);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::clone_from
|
||||
//! @copydoc ::boost::intrusive::bstree::clone_from(const bstree&,Cloner,Disposer)
|
||||
template <class Cloner, class Disposer>
|
||||
void clone_from(const bs_multiset_impl &src, Cloner cloner, Disposer disposer);
|
||||
|
||||
#endif //#ifdef BOOST_iNTRUSIVE_DOXYGEN_INVOKED
|
||||
#else
|
||||
|
||||
using tree_type::clone_from;
|
||||
|
||||
#endif //#ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::clone_from(bstree&&,Cloner,Disposer)
|
||||
template <class Cloner, class Disposer>
|
||||
void clone_from(BOOST_RV_REF(bs_multiset_impl) src, Cloner cloner, Disposer disposer)
|
||||
{ tree_type::clone_from(BOOST_MOVE_BASE(tree_type, src), cloner, disposer); }
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::insert_equal(reference)
|
||||
iterator insert(reference value)
|
||||
@@ -674,12 +703,12 @@ class bs_multiset_impl
|
||||
//! @copydoc ::boost::intrusive::bstree::erase(const_iterator,const_iterator)
|
||||
iterator erase(const_iterator b, const_iterator e);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::erase(const_reference)
|
||||
size_type erase(const_reference value);
|
||||
//! @copydoc ::boost::intrusive::bstree::erase(const key_type &)
|
||||
size_type erase(const key_type &key);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::erase(const KeyType&,KeyValueCompare)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
size_type erase(const KeyType& key, KeyValueCompare comp);
|
||||
//! @copydoc ::boost::intrusive::bstree::erase(const KeyType&,KeyTypeKeyCompare)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
size_type erase(const KeyType& key, KeyTypeKeyCompare comp);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::erase_and_dispose(const_iterator,Disposer)
|
||||
template<class Disposer>
|
||||
@@ -689,13 +718,13 @@ class bs_multiset_impl
|
||||
template<class Disposer>
|
||||
iterator erase_and_dispose(const_iterator b, const_iterator e, Disposer disposer);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::erase_and_dispose(const_reference, Disposer)
|
||||
//! @copydoc ::boost::intrusive::bstree::erase_and_dispose(const key_type &, Disposer)
|
||||
template<class Disposer>
|
||||
size_type erase_and_dispose(const_reference value, Disposer disposer);
|
||||
size_type erase_and_dispose(const key_type &key, Disposer disposer);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::erase_and_dispose(const KeyType&,KeyValueCompare,Disposer)
|
||||
template<class KeyType, class KeyValueCompare, class Disposer>
|
||||
size_type erase_and_dispose(const KeyType& key, KeyValueCompare comp, Disposer disposer);
|
||||
//! @copydoc ::boost::intrusive::bstree::erase_and_dispose(const KeyType&,KeyTypeKeyCompare,Disposer)
|
||||
template<class KeyType, class KeyTypeKeyCompare, class Disposer>
|
||||
size_type erase_and_dispose(const KeyType& key, KeyTypeKeyCompare comp, Disposer disposer);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::clear
|
||||
void clear();
|
||||
@@ -704,88 +733,88 @@ class bs_multiset_impl
|
||||
template<class Disposer>
|
||||
void clear_and_dispose(Disposer disposer);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::count(const_reference)const
|
||||
size_type count(const_reference value) const;
|
||||
//! @copydoc ::boost::intrusive::bstree::count(const key_type &)const
|
||||
size_type count(const key_type &key) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::count(const KeyType&,KeyValueCompare)const
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
size_type count(const KeyType& key, KeyValueCompare comp) const;
|
||||
//! @copydoc ::boost::intrusive::bstree::count(const KeyType&,KeyTypeKeyCompare)const
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
size_type count(const KeyType& key, KeyTypeKeyCompare comp) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::lower_bound(const_reference)
|
||||
iterator lower_bound(const_reference value);
|
||||
//! @copydoc ::boost::intrusive::bstree::lower_bound(const key_type &)
|
||||
iterator lower_bound(const key_type &key);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::lower_bound(const KeyType&,KeyValueCompare)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
iterator lower_bound(const KeyType& key, KeyValueCompare comp);
|
||||
//! @copydoc ::boost::intrusive::bstree::lower_bound(const KeyType&,KeyTypeKeyCompare)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
iterator lower_bound(const KeyType& key, KeyTypeKeyCompare comp);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::lower_bound(const_reference)const
|
||||
const_iterator lower_bound(const_reference value) const;
|
||||
//! @copydoc ::boost::intrusive::bstree::lower_bound(const key_type &)const
|
||||
const_iterator lower_bound(const key_type &key) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::lower_bound(const KeyType&,KeyValueCompare)const
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
const_iterator lower_bound(const KeyType& key, KeyValueCompare comp) const;
|
||||
//! @copydoc ::boost::intrusive::bstree::lower_bound(const KeyType&,KeyTypeKeyCompare)const
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
const_iterator lower_bound(const KeyType& key, KeyTypeKeyCompare comp) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::upper_bound(const_reference)
|
||||
iterator upper_bound(const_reference value);
|
||||
//! @copydoc ::boost::intrusive::bstree::upper_bound(const key_type &)
|
||||
iterator upper_bound(const key_type &key);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::upper_bound(const KeyType&,KeyValueCompare)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
iterator upper_bound(const KeyType& key, KeyValueCompare comp);
|
||||
//! @copydoc ::boost::intrusive::bstree::upper_bound(const KeyType&,KeyTypeKeyCompare)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
iterator upper_bound(const KeyType& key, KeyTypeKeyCompare comp);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::upper_bound(const_reference)const
|
||||
const_iterator upper_bound(const_reference value) const;
|
||||
//! @copydoc ::boost::intrusive::bstree::upper_bound(const key_type &)const
|
||||
const_iterator upper_bound(const key_type &key) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::upper_bound(const KeyType&,KeyValueCompare)const
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
const_iterator upper_bound(const KeyType& key, KeyValueCompare comp) const;
|
||||
//! @copydoc ::boost::intrusive::bstree::upper_bound(const KeyType&,KeyTypeKeyCompare)const
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
const_iterator upper_bound(const KeyType& key, KeyTypeKeyCompare comp) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::find(const_reference)
|
||||
iterator find(const_reference value);
|
||||
//! @copydoc ::boost::intrusive::bstree::find(const key_type &)
|
||||
iterator find(const key_type &key);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::find(const KeyType&,KeyValueCompare)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
iterator find(const KeyType& key, KeyValueCompare comp);
|
||||
//! @copydoc ::boost::intrusive::bstree::find(const KeyType&,KeyTypeKeyCompare)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
iterator find(const KeyType& key, KeyTypeKeyCompare comp);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::find(const_reference)const
|
||||
const_iterator find(const_reference value) const;
|
||||
//! @copydoc ::boost::intrusive::bstree::find(const key_type &)const
|
||||
const_iterator find(const key_type &key) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::find(const KeyType&,KeyValueCompare)const
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
const_iterator find(const KeyType& key, KeyValueCompare comp) const;
|
||||
//! @copydoc ::boost::intrusive::bstree::find(const KeyType&,KeyTypeKeyCompare)const
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
const_iterator find(const KeyType& key, KeyTypeKeyCompare comp) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::equal_range(const_reference)
|
||||
std::pair<iterator,iterator> equal_range(const_reference value);
|
||||
//! @copydoc ::boost::intrusive::bstree::equal_range(const key_type &)
|
||||
std::pair<iterator,iterator> equal_range(const key_type &key);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::equal_range(const KeyType&,KeyValueCompare)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
std::pair<iterator,iterator> equal_range(const KeyType& key, KeyValueCompare comp);
|
||||
//! @copydoc ::boost::intrusive::bstree::equal_range(const KeyType&,KeyTypeKeyCompare)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
std::pair<iterator,iterator> equal_range(const KeyType& key, KeyTypeKeyCompare comp);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::equal_range(const_reference)const
|
||||
//! @copydoc ::boost::intrusive::bstree::equal_range(const key_type &)const
|
||||
std::pair<const_iterator, const_iterator>
|
||||
equal_range(const_reference value) const;
|
||||
equal_range(const key_type &key) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::equal_range(const KeyType&,KeyValueCompare)const
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
//! @copydoc ::boost::intrusive::bstree::equal_range(const KeyType&,KeyTypeKeyCompare)const
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
std::pair<const_iterator, const_iterator>
|
||||
equal_range(const KeyType& key, KeyValueCompare comp) const;
|
||||
equal_range(const KeyType& key, KeyTypeKeyCompare comp) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::bounded_range(const_reference,const_reference,bool,bool)
|
||||
//! @copydoc ::boost::intrusive::bstree::bounded_range(const key_type &,const key_type &,bool,bool)
|
||||
std::pair<iterator,iterator> bounded_range
|
||||
(const_reference lower_value, const_reference upper_value, bool left_closed, bool right_closed);
|
||||
(const key_type & lower_key, const key_type & upper_key, bool left_closed, bool right_closed);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::bounded_range(const KeyType&,const KeyType&,KeyValueCompare,bool,bool)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
//! @copydoc ::boost::intrusive::bstree::bounded_range(const KeyType&,const KeyType&,KeyTypeKeyCompare,bool,bool)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
std::pair<iterator,iterator> bounded_range
|
||||
(const KeyType& lower_key, const KeyType& upper_key, KeyValueCompare comp, bool left_closed, bool right_closed);
|
||||
(const KeyType& lower_key, const KeyType& upper_key, KeyTypeKeyCompare comp, bool left_closed, bool right_closed);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::bounded_range(const_reference,const_reference,bool,bool)const
|
||||
//! @copydoc ::boost::intrusive::bstree::bounded_range(const key_type &,const key_type &,bool,bool)const
|
||||
std::pair<const_iterator, const_iterator>
|
||||
bounded_range(const_reference lower_value, const_reference upper_value, bool left_closed, bool right_closed) const;
|
||||
bounded_range(const key_type & lower_key, const key_type & upper_key, bool left_closed, bool right_closed) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::bounded_range(const KeyType&,const KeyType&,KeyValueCompare,bool,bool)const
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
//! @copydoc ::boost::intrusive::bstree::bounded_range(const KeyType&,const KeyType&,KeyTypeKeyCompare,bool,bool)const
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
std::pair<const_iterator, const_iterator> bounded_range
|
||||
(const KeyType& lower_key, const KeyType& upper_key, KeyValueCompare comp, bool left_closed, bool right_closed) const;
|
||||
(const KeyType& lower_key, const KeyType& upper_key, KeyTypeKeyCompare comp, bool left_closed, bool right_closed) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::s_iterator_to(reference)
|
||||
static iterator s_iterator_to(reference value);
|
||||
@@ -839,7 +868,7 @@ template<class T, class ...Options>
|
||||
#else
|
||||
template<class T, class O1 = void, class O2 = void
|
||||
, class O3 = void, class O4 = void
|
||||
, class O5 = void>
|
||||
, class O5 = void, class O6 = void>
|
||||
#endif
|
||||
struct make_bs_multiset
|
||||
{
|
||||
@@ -847,7 +876,7 @@ struct make_bs_multiset
|
||||
typedef typename pack_options
|
||||
< bstree_defaults,
|
||||
#if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
|
||||
O1, O2, O3, O4, O5
|
||||
O1, O2, O3, O4, O5, O6
|
||||
#else
|
||||
Options...
|
||||
#endif
|
||||
@@ -858,6 +887,7 @@ struct make_bs_multiset
|
||||
|
||||
typedef bs_multiset_impl
|
||||
< value_traits
|
||||
, typename packed_options::key_of_value
|
||||
, typename packed_options::compare
|
||||
, typename packed_options::size_type
|
||||
, packed_options::constant_time_size
|
||||
@@ -870,14 +900,14 @@ struct make_bs_multiset
|
||||
#ifndef BOOST_INTRUSIVE_DOXYGEN_INVOKED
|
||||
|
||||
#if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
|
||||
template<class T, class O1, class O2, class O3, class O4, class O5>
|
||||
template<class T, class O1, class O2, class O3, class O4, class O5, class O6>
|
||||
#else
|
||||
template<class T, class ...Options>
|
||||
#endif
|
||||
class bs_multiset
|
||||
: public make_bs_multiset<T,
|
||||
#if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
|
||||
O1, O2, O3, O4, O5
|
||||
O1, O2, O3, O4, O5, O6
|
||||
#else
|
||||
Options...
|
||||
#endif
|
||||
@@ -885,7 +915,7 @@ class bs_multiset
|
||||
{
|
||||
typedef typename make_bs_multiset<T,
|
||||
#if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
|
||||
O1, O2, O3, O4, O5
|
||||
O1, O2, O3, O4, O5, O6
|
||||
#else
|
||||
Options...
|
||||
#endif
|
||||
@@ -894,7 +924,7 @@ class bs_multiset
|
||||
BOOST_MOVABLE_BUT_NOT_COPYABLE(bs_multiset)
|
||||
|
||||
public:
|
||||
typedef typename Base::value_compare value_compare;
|
||||
typedef typename Base::key_compare key_compare;
|
||||
typedef typename Base::value_traits value_traits;
|
||||
typedef typename Base::iterator iterator;
|
||||
typedef typename Base::const_iterator const_iterator;
|
||||
@@ -902,14 +932,14 @@ class bs_multiset
|
||||
//Assert if passed value traits are compatible with the type
|
||||
BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value));
|
||||
|
||||
explicit bs_multiset( const value_compare &cmp = value_compare()
|
||||
explicit bs_multiset( const key_compare &cmp = key_compare()
|
||||
, const value_traits &v_traits = value_traits())
|
||||
: Base(cmp, v_traits)
|
||||
{}
|
||||
|
||||
template<class Iterator>
|
||||
bs_multiset( Iterator b, Iterator e
|
||||
, const value_compare &cmp = value_compare()
|
||||
, const key_compare &cmp = key_compare()
|
||||
, const value_traits &v_traits = value_traits())
|
||||
: Base(b, e, cmp, v_traits)
|
||||
{}
|
||||
@@ -921,6 +951,14 @@ class bs_multiset
|
||||
bs_multiset& operator=(BOOST_RV_REF(bs_multiset) x)
|
||||
{ return static_cast<bs_multiset &>(this->Base::operator=(BOOST_MOVE_BASE(Base, x))); }
|
||||
|
||||
template <class Cloner, class Disposer>
|
||||
void clone_from(const bs_multiset &src, Cloner cloner, Disposer disposer)
|
||||
{ Base::clone_from(src, cloner, disposer); }
|
||||
|
||||
template <class Cloner, class Disposer>
|
||||
void clone_from(BOOST_RV_REF(bs_multiset) src, Cloner cloner, Disposer disposer)
|
||||
{ Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer); }
|
||||
|
||||
static bs_multiset &container_from_end_iterator(iterator end_iterator)
|
||||
{ return static_cast<bs_multiset &>(Base::container_from_end_iterator(end_iterator)); }
|
||||
|
||||
|
||||
+263
-240
File diff suppressed because it is too large.
Load diff
@@ -46,7 +46,7 @@ class common_slist_algorithms
|
||||
; this_node != (p_next = NodeTraits::get_next(p))
|
||||
; p = p_next){
|
||||
//Logic error: possible use of linear lists with
|
||||
//operations only permitted with lists
|
||||
//operations only permitted with circular lists
|
||||
BOOST_INTRUSIVE_INVARIANT_ASSERT(p);
|
||||
}
|
||||
return p;
|
||||
|
||||
@@ -51,15 +51,15 @@ struct default_header_holder : public NodeTraits::node
|
||||
};
|
||||
|
||||
// type function producing the header node holder
|
||||
template < typename Value_Traits, typename HeaderHolder >
|
||||
template < typename ValueTraits, typename HeaderHolder >
|
||||
struct get_header_holder_type
|
||||
{
|
||||
typedef HeaderHolder type;
|
||||
};
|
||||
template < typename Value_Traits >
|
||||
struct get_header_holder_type< Value_Traits, void >
|
||||
template < typename ValueTraits >
|
||||
struct get_header_holder_type< ValueTraits, void >
|
||||
{
|
||||
typedef default_header_holder< typename Value_Traits::node_traits > type;
|
||||
typedef default_header_holder< typename ValueTraits::node_traits > type;
|
||||
};
|
||||
|
||||
} //namespace detail
|
||||
|
||||
@@ -203,6 +203,7 @@ class ebo_functor_holder
|
||||
typedef ebo_functor_holder_impl<T, is_unary_or_binary_function<T>::value> super;
|
||||
|
||||
public:
|
||||
typedef T functor_type;
|
||||
ebo_functor_holder(){}
|
||||
explicit ebo_functor_holder(const T& t)
|
||||
: super(t)
|
||||
|
||||
@@ -28,18 +28,27 @@ namespace boost {
|
||||
namespace intrusive {
|
||||
namespace detail {
|
||||
|
||||
template<class KeyValueCompare, class ValueTraits>
|
||||
template < class KeyTypeKeyCompare
|
||||
, class ValueTraits
|
||||
, class KeyOfValue = void
|
||||
>
|
||||
struct key_nodeptr_comp
|
||||
//Use public inheritance to avoid MSVC bugs with closures
|
||||
: public ebo_functor_holder<KeyValueCompare>
|
||||
: public ebo_functor_holder<KeyTypeKeyCompare>
|
||||
{
|
||||
typedef ValueTraits value_traits;
|
||||
typedef typename value_traits::value_type value_type;
|
||||
typedef typename value_traits::node_ptr node_ptr;
|
||||
typedef typename value_traits::const_node_ptr const_node_ptr;
|
||||
typedef ebo_functor_holder<KeyValueCompare> base_t;
|
||||
typedef ebo_functor_holder<KeyTypeKeyCompare> base_t;
|
||||
typedef typename detail::if_c
|
||||
< detail::is_same<KeyOfValue, void>::value
|
||||
, detail::identity<value_type>
|
||||
, KeyOfValue
|
||||
>::type key_of_value;
|
||||
typedef typename key_of_value::type key_type;
|
||||
|
||||
key_nodeptr_comp(KeyValueCompare kcomp, const ValueTraits *traits)
|
||||
key_nodeptr_comp(KeyTypeKeyCompare kcomp, const ValueTraits *traits)
|
||||
: base_t(kcomp), traits_(traits)
|
||||
{}
|
||||
|
||||
@@ -51,9 +60,9 @@ struct key_nodeptr_comp
|
||||
|
||||
//key_forward
|
||||
template<class T>
|
||||
typename enable_if<is_node_ptr<T>, const value_type &>::type
|
||||
typename enable_if<is_node_ptr<T>, const key_type &>::type
|
||||
key_forward(const T &node) const
|
||||
{ return *traits_->to_value_ptr(node); }
|
||||
{ return key_of_value()(*traits_->to_value_ptr(node)); }
|
||||
|
||||
template<class T>
|
||||
typename disable_if<is_node_ptr<T>, const T &>::type
|
||||
|
||||
@@ -47,6 +47,7 @@ using boost::move_detail::disable_if;
|
||||
using boost::move_detail::is_convertible;
|
||||
using boost::move_detail::if_c;
|
||||
using boost::move_detail::if_;
|
||||
using boost::move_detail::is_const;
|
||||
using boost::move_detail::identity;
|
||||
using boost::move_detail::alignment_of;
|
||||
using boost::move_detail::is_empty;
|
||||
@@ -163,10 +164,10 @@ struct TRAITS_PREFIX##_bool_is_true\
|
||||
private: \
|
||||
template<Signature> struct helper;\
|
||||
template<typename T> \
|
||||
static ::boost::intrusive::detail::yes_type check(helper<&T::FUNC_NAME>*); \
|
||||
template<typename T> static ::boost::intrusive::detail::no_type check(...); \
|
||||
static ::boost::intrusive::detail::yes_type test(helper<&T::FUNC_NAME>*); \
|
||||
template<typename T> static ::boost::intrusive::detail::no_type test(...); \
|
||||
public: \
|
||||
static const bool value = sizeof(check<U>(0)) == sizeof(::boost::intrusive::detail::yes_type); \
|
||||
static const bool value = sizeof(test<U>(0)) == sizeof(::boost::intrusive::detail::yes_type); \
|
||||
}; \
|
||||
//
|
||||
|
||||
@@ -181,9 +182,9 @@ struct TRAITS_NAME \
|
||||
struct Base : public Type, public BaseMixin { Base(); }; \
|
||||
template <typename T, T t> class Helper{}; \
|
||||
template <typename U> \
|
||||
static ::boost::intrusive::detail::no_type check(U*, Helper<void (BaseMixin::*)(), &U::FUNC_NAME>* = 0); \
|
||||
static ::boost::intrusive::detail::yes_type check(...); \
|
||||
static const bool value = sizeof(::boost::intrusive::detail::yes_type) == sizeof(check((Base*)(0))); \
|
||||
static ::boost::intrusive::detail::no_type test(U*, Helper<void (BaseMixin::*)(), &U::FUNC_NAME>* = 0); \
|
||||
static ::boost::intrusive::detail::yes_type test(...); \
|
||||
static const bool value = sizeof(::boost::intrusive::detail::yes_type) == sizeof(test((Base*)(0))); \
|
||||
};\
|
||||
//
|
||||
|
||||
|
||||
@@ -36,21 +36,22 @@ struct node_cloner
|
||||
//Use public inheritance to avoid MSVC bugs with closures
|
||||
: public ebo_functor_holder<F>
|
||||
{
|
||||
typedef ValueTraits value_traits;
|
||||
typedef typename value_traits::node_traits node_traits;
|
||||
typedef typename node_traits::node_ptr node_ptr;
|
||||
typedef ebo_functor_holder<F> base_t;
|
||||
typedef ValueTraits value_traits;
|
||||
typedef typename value_traits::node_traits node_traits;
|
||||
typedef typename node_traits::node_ptr node_ptr;
|
||||
typedef ebo_functor_holder<F> base_t;
|
||||
typedef typename get_algo< AlgoType
|
||||
, node_traits>::type node_algorithms;
|
||||
, node_traits>::type node_algorithms;
|
||||
static const bool safemode_or_autounlink =
|
||||
is_safe_autounlink<value_traits::link_mode>::value;
|
||||
typedef typename value_traits::value_type value_type;
|
||||
typedef typename value_traits::pointer pointer;
|
||||
typedef typename node_traits::node node;
|
||||
typedef typename value_traits::const_node_ptr const_node_ptr;
|
||||
typedef typename value_traits::reference reference;
|
||||
typedef typename value_traits::const_reference const_reference;
|
||||
|
||||
typedef typename value_traits::value_type value_type;
|
||||
typedef typename value_traits::pointer pointer;
|
||||
typedef typename value_traits::const_pointer const_pointer;
|
||||
typedef typename node_traits::node node;
|
||||
typedef typename value_traits::const_node_ptr const_node_ptr;
|
||||
typedef typename pointer_traits<pointer>::reference reference;
|
||||
typedef typename pointer_traits
|
||||
<const_pointer>::reference const_reference;
|
||||
typedef typename if_c<IsConst, const_reference, reference>::type reference_type;
|
||||
|
||||
node_cloner(F f, const ValueTraits *traits)
|
||||
@@ -63,21 +64,7 @@ struct node_cloner
|
||||
reference_type v = *traits_->to_value_ptr(p);
|
||||
node_ptr n = traits_->to_node_ptr(*base_t::get()(v));
|
||||
//Cloned node must be in default mode if the linking mode requires it
|
||||
if(safemode_or_autounlink)
|
||||
BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(n));
|
||||
return n;
|
||||
}
|
||||
|
||||
// hashtables use this method, which is proxy-reference unfriendly
|
||||
node_ptr operator()(const node &to_clone)
|
||||
{
|
||||
reference_type v =
|
||||
*traits_->to_value_ptr
|
||||
(pointer_traits<const_node_ptr>::pointer_to(to_clone));
|
||||
node_ptr n = traits_->to_node_ptr(*base_t::get()(v));
|
||||
//Cloned node must be in default mode if the linking mode requires it
|
||||
if(safemode_or_autounlink)
|
||||
BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(n));
|
||||
BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(!safemode_or_autounlink || node_algorithms::unique(n));
|
||||
return n;
|
||||
}
|
||||
|
||||
|
||||
@@ -0,0 +1,78 @@
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// (C) Copyright Ion Gaztanaga 2015-2015. 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/container for documentation.
|
||||
//
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
#ifndef BOOST_INTRUSIVE_DETAIL_TREE_VALUE_COMPARE_HPP
|
||||
#define BOOST_INTRUSIVE_DETAIL_TREE_VALUE_COMPARE_HPP
|
||||
|
||||
#ifndef BOOST_CONFIG_HPP
|
||||
# include <boost/config.hpp>
|
||||
#endif
|
||||
|
||||
#if defined(BOOST_HAS_PRAGMA_ONCE)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
#include <boost/intrusive/detail/mpl.hpp>
|
||||
#include <boost/intrusive/detail/ebo_functor_holder.hpp>
|
||||
|
||||
namespace boost{
|
||||
namespace intrusive{
|
||||
|
||||
template<class Key, class T, class KeyCompare, class KeyOfValue>
|
||||
struct tree_value_compare
|
||||
: public boost::intrusive::detail::ebo_functor_holder<KeyCompare>
|
||||
{
|
||||
typedef boost::intrusive::detail::ebo_functor_holder<KeyCompare> base_t;
|
||||
typedef T value_type;
|
||||
typedef KeyCompare key_compare;
|
||||
typedef KeyOfValue key_of_value;
|
||||
typedef Key key_type;
|
||||
|
||||
explicit tree_value_compare(const key_compare &kcomp)
|
||||
: base_t(kcomp)
|
||||
{}
|
||||
|
||||
tree_value_compare()
|
||||
: base_t()
|
||||
{}
|
||||
|
||||
const key_compare &key_comp() const
|
||||
{ return static_cast<const key_compare &>(*this); }
|
||||
|
||||
key_compare &key_comp()
|
||||
{ return static_cast<key_compare &>(*this); }
|
||||
|
||||
template<class U>
|
||||
struct is_key
|
||||
: boost::intrusive::detail::is_same<const U, const key_type>
|
||||
{};
|
||||
|
||||
template<class U>
|
||||
typename boost::intrusive::detail::enable_if<is_key<U>, const key_type &>::type
|
||||
key_forward(const U &key) const
|
||||
{ return key; }
|
||||
|
||||
template<class U>
|
||||
typename boost::intrusive::detail::disable_if<is_key<U>, const key_type &>::type
|
||||
key_forward(const U &key) const
|
||||
{ return KeyOfValue()(key); }
|
||||
|
||||
template<class KeyType, class KeyType2>
|
||||
bool operator()(const KeyType &key1, const KeyType2 &key2) const
|
||||
{ return key_compare::operator()(this->key_forward(key1), this->key_forward(key2)); }
|
||||
|
||||
template<class KeyType, class KeyType2>
|
||||
bool operator()(const KeyType &key1, const KeyType2 &key2)
|
||||
{ return key_compare::operator()(this->key_forward(key1), this->key_forward(key2)); }
|
||||
};
|
||||
|
||||
} //namespace intrusive{
|
||||
} //namespace boost{
|
||||
|
||||
#endif //#ifdef BOOST_INTRUSIVE_DETAIL_TREE_VALUE_COMPARE_HPP
|
||||
+1270
-1109
File diff suppressed because it is too large.
Load diff
@@ -184,6 +184,7 @@ template
|
||||
, class O3 = void
|
||||
, class O4 = void
|
||||
, class O5 = void
|
||||
, class O6 = void
|
||||
>
|
||||
#else
|
||||
template<class T, class ...Options>
|
||||
@@ -198,6 +199,7 @@ template
|
||||
, class O3 = void
|
||||
, class O4 = void
|
||||
, class O5 = void
|
||||
, class O6 = void
|
||||
>
|
||||
#else
|
||||
template<class T, class ...Options>
|
||||
@@ -212,6 +214,7 @@ template
|
||||
, class O3 = void
|
||||
, class O4 = void
|
||||
, class O5 = void
|
||||
, class O6 = void
|
||||
>
|
||||
#else
|
||||
template<class T, class ...Options>
|
||||
@@ -251,6 +254,7 @@ template
|
||||
, class O3 = void
|
||||
, class O4 = void
|
||||
, class O5 = void
|
||||
, class O6 = void
|
||||
>
|
||||
#else
|
||||
template<class T, class ...Options>
|
||||
@@ -265,6 +269,7 @@ template
|
||||
, class O3 = void
|
||||
, class O4 = void
|
||||
, class O5 = void
|
||||
, class O6 = void
|
||||
>
|
||||
#else
|
||||
template<class T, class ...Options>
|
||||
@@ -279,6 +284,7 @@ template
|
||||
, class O3 = void
|
||||
, class O4 = void
|
||||
, class O5 = void
|
||||
, class O6 = void
|
||||
>
|
||||
#else
|
||||
template<class T, class ...Options>
|
||||
@@ -294,6 +300,7 @@ template
|
||||
, class O3 = void
|
||||
, class O4 = void
|
||||
, class O5 = void
|
||||
, class O6 = void
|
||||
>
|
||||
#else
|
||||
template<class T, class ...Options>
|
||||
@@ -308,6 +315,7 @@ template
|
||||
, class O3 = void
|
||||
, class O4 = void
|
||||
, class O5 = void
|
||||
, class O6 = void
|
||||
>
|
||||
#else
|
||||
template<class T, class ...Options>
|
||||
@@ -322,6 +330,7 @@ template
|
||||
, class O3 = void
|
||||
, class O4 = void
|
||||
, class O5 = void
|
||||
, class O6 = void
|
||||
>
|
||||
#else
|
||||
template<class T, class ...Options>
|
||||
@@ -362,6 +371,7 @@ template
|
||||
, class O3 = void
|
||||
, class O4 = void
|
||||
, class O5 = void
|
||||
, class O6 = void
|
||||
>
|
||||
#else
|
||||
template<class T, class ...Options>
|
||||
@@ -376,6 +386,7 @@ template
|
||||
, class O3 = void
|
||||
, class O4 = void
|
||||
, class O5 = void
|
||||
, class O6 = void
|
||||
>
|
||||
#else
|
||||
template<class T, class ...Options>
|
||||
@@ -390,6 +401,7 @@ template
|
||||
, class O3 = void
|
||||
, class O4 = void
|
||||
, class O5 = void
|
||||
, class O6 = void
|
||||
>
|
||||
#else
|
||||
template<class T, class ...Options>
|
||||
@@ -405,6 +417,7 @@ template
|
||||
, class O3 = void
|
||||
, class O4 = void
|
||||
, class O5 = void
|
||||
, class O6 = void
|
||||
>
|
||||
#else
|
||||
template<class T, class ...Options>
|
||||
@@ -419,6 +432,7 @@ template
|
||||
, class O3 = void
|
||||
, class O4 = void
|
||||
, class O5 = void
|
||||
, class O6 = void
|
||||
>
|
||||
#else
|
||||
template<class T, class ...Options>
|
||||
@@ -433,6 +447,7 @@ template
|
||||
, class O3 = void
|
||||
, class O4 = void
|
||||
, class O5 = void
|
||||
, class O6 = void
|
||||
>
|
||||
#else
|
||||
template<class T, class ...Options>
|
||||
@@ -447,6 +462,7 @@ template
|
||||
, class O3 = void
|
||||
, class O4 = void
|
||||
, class O5 = void
|
||||
, class O6 = void
|
||||
>
|
||||
#else
|
||||
template<class T, class ...Options>
|
||||
@@ -461,6 +477,7 @@ template
|
||||
, class O3 = void
|
||||
, class O4 = void
|
||||
, class O5 = void
|
||||
, class O6 = void
|
||||
>
|
||||
#else
|
||||
template<class T, class ...Options>
|
||||
@@ -475,6 +492,7 @@ template
|
||||
, class O3 = void
|
||||
, class O4 = void
|
||||
, class O5 = void
|
||||
, class O6 = void
|
||||
>
|
||||
#else
|
||||
template<class T, class ...Options>
|
||||
|
||||
@@ -248,8 +248,7 @@ class list_impl
|
||||
void push_back(reference value)
|
||||
{
|
||||
node_ptr to_insert = priv_value_traits().to_node_ptr(value);
|
||||
if(safemode_or_autounlink)
|
||||
BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::inited(to_insert));
|
||||
BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(!safemode_or_autounlink || node_algorithms::inited(to_insert));
|
||||
node_algorithms::link_before(this->get_root_node(), to_insert);
|
||||
this->priv_size_traits().increment();
|
||||
}
|
||||
@@ -267,8 +266,7 @@ class list_impl
|
||||
void push_front(reference value)
|
||||
{
|
||||
node_ptr to_insert = priv_value_traits().to_node_ptr(value);
|
||||
if(safemode_or_autounlink)
|
||||
BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::inited(to_insert));
|
||||
BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(!safemode_or_autounlink || node_algorithms::inited(to_insert));
|
||||
node_algorithms::link_before(node_traits::get_next(this->get_root_node()), to_insert);
|
||||
this->priv_size_traits().increment();
|
||||
}
|
||||
@@ -770,6 +768,33 @@ class list_impl
|
||||
rollback.release();
|
||||
}
|
||||
|
||||
//! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw.
|
||||
//! Cloner should yield to nodes equivalent to the original nodes.
|
||||
//!
|
||||
//! <b>Effects</b>: Erases all the elements from *this
|
||||
//! calling Disposer::operator()(pointer), clones all the
|
||||
//! elements from src calling Cloner::operator()(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(BOOST_RV_REF(list_impl) src, Cloner cloner, Disposer disposer)
|
||||
{
|
||||
this->clear_and_dispose(disposer);
|
||||
detail::exception_disposer<list_impl, Disposer>
|
||||
rollback(*this, disposer);
|
||||
iterator b(src.begin()), e(src.end());
|
||||
for(; b != e; ++b){
|
||||
this->push_back(*cloner(*b));
|
||||
}
|
||||
rollback.release();
|
||||
}
|
||||
|
||||
//! <b>Requires</b>: value must be an lvalue and p must be a valid iterator of *this.
|
||||
//!
|
||||
//! <b>Effects</b>: Inserts the value before the position pointed by p.
|
||||
@@ -784,8 +809,7 @@ class list_impl
|
||||
iterator insert(const_iterator p, reference value)
|
||||
{
|
||||
node_ptr to_insert = this->priv_value_traits().to_node_ptr(value);
|
||||
if(safemode_or_autounlink)
|
||||
BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::inited(to_insert));
|
||||
BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(!safemode_or_autounlink || node_algorithms::inited(to_insert));
|
||||
node_algorithms::link_before(p.pointed_node(), to_insert);
|
||||
this->priv_size_traits().increment();
|
||||
return iterator(to_insert, this->priv_value_traits_ptr());
|
||||
@@ -1447,6 +1471,14 @@ class list
|
||||
list& operator=(BOOST_RV_REF(list) x)
|
||||
{ return static_cast<list &>(this->Base::operator=(BOOST_MOVE_BASE(Base, x))); }
|
||||
|
||||
template <class Cloner, class Disposer>
|
||||
void clone_from(const list &src, Cloner cloner, Disposer disposer)
|
||||
{ Base::clone_from(src, cloner, disposer); }
|
||||
|
||||
template <class Cloner, class Disposer>
|
||||
void clone_from(BOOST_RV_REF(list) src, Cloner cloner, Disposer disposer)
|
||||
{ Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer); }
|
||||
|
||||
static list &container_from_end_iterator(iterator end_iterator)
|
||||
{ return static_cast<list &>(Base::container_from_end_iterator(end_iterator)); }
|
||||
|
||||
|
||||
@@ -61,6 +61,15 @@ BOOST_INTRUSIVE_OPTION_TYPE(size_type, SizeType, SizeType, size_type)
|
||||
//!comparison functor for the value type
|
||||
BOOST_INTRUSIVE_OPTION_TYPE(compare, Compare, Compare, compare)
|
||||
|
||||
//!This option setter specifies the a function object
|
||||
//!that specifies the type of the key of an associative
|
||||
//!container and an operator to obtain it from a value type.
|
||||
//!
|
||||
//!This function object must the define a `key_type` and
|
||||
//!a member with signature `const key_type & operator()(const value_type &) const`
|
||||
//!that will return the key from a value_type of an associative container
|
||||
BOOST_INTRUSIVE_OPTION_TYPE(key_of_value, KeyOfValue, KeyOfValue, key_of_value)
|
||||
|
||||
//!This option setter for scapegoat containers specifies if
|
||||
//!the intrusive scapegoat container should use a non-variable
|
||||
//!alpha value that does not need floating-point operations.
|
||||
@@ -199,7 +208,7 @@ BOOST_INTRUSIVE_OPTION_CONSTANT(optimize_multikey, bool, Enabled, optimize_multi
|
||||
//!This allows using masks instead of the default modulo operation to determine
|
||||
//!the bucket number from the hash value, leading to better performance.
|
||||
//!In debug mode, if power of two buckets mode is activated, the bucket length
|
||||
//!will be checked to through assertions to assure the bucket length is power of two.
|
||||
//!will be checked with assertions.
|
||||
BOOST_INTRUSIVE_OPTION_CONSTANT(power_2_buckets, bool, Enabled, power_2_buckets)
|
||||
|
||||
//!This option setter specifies if the container will cache a pointer to the first
|
||||
|
||||
@@ -48,19 +48,16 @@ struct is_default_hook_tag<default_rbtree_hook_applier>
|
||||
{ static const bool value = true; };
|
||||
|
||||
struct rbtree_defaults
|
||||
: bstree_defaults
|
||||
{
|
||||
typedef default_rbtree_hook_applier proto_value_traits;
|
||||
static const bool constant_time_size = true;
|
||||
typedef std::size_t size_type;
|
||||
typedef void compare;
|
||||
typedef void header_holder_type;
|
||||
};
|
||||
|
||||
/// @endcond
|
||||
|
||||
//! The class template rbtree is an intrusive red-black tree container, that
|
||||
//! is used to construct intrusive set and multiset containers. The no-throw
|
||||
//! guarantee holds only, if the value_compare object
|
||||
//! guarantee holds only, if the key_compare object
|
||||
//! doesn't throw.
|
||||
//!
|
||||
//! The template parameter \c T is the type to be managed by the container.
|
||||
@@ -74,17 +71,17 @@ struct rbtree_defaults
|
||||
#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED)
|
||||
template<class T, class ...Options>
|
||||
#else
|
||||
template<class ValueTraits, class VoidOrKeyComp, class SizeType, bool ConstantTimeSize, typename HeaderHolder>
|
||||
template<class ValueTraits, class VoidOrKeyOfValue, class VoidOrKeyComp, class SizeType, bool ConstantTimeSize, typename HeaderHolder>
|
||||
#endif
|
||||
class rbtree_impl
|
||||
/// @cond
|
||||
: public bstree_impl<ValueTraits, VoidOrKeyComp, SizeType, ConstantTimeSize, RbTreeAlgorithms, HeaderHolder>
|
||||
: public bstree_impl<ValueTraits, VoidOrKeyOfValue, VoidOrKeyComp, SizeType, ConstantTimeSize, RbTreeAlgorithms, HeaderHolder>
|
||||
/// @endcond
|
||||
{
|
||||
public:
|
||||
typedef ValueTraits value_traits;
|
||||
/// @cond
|
||||
typedef bstree_impl< ValueTraits, VoidOrKeyComp, SizeType
|
||||
typedef bstree_impl< ValueTraits, VoidOrKeyOfValue, VoidOrKeyComp, SizeType
|
||||
, ConstantTimeSize, RbTreeAlgorithms
|
||||
, HeaderHolder> tree_type;
|
||||
typedef tree_type implementation_defined;
|
||||
@@ -94,6 +91,7 @@ class rbtree_impl
|
||||
typedef typename implementation_defined::const_pointer const_pointer;
|
||||
typedef typename implementation_defined::value_type value_type;
|
||||
typedef typename implementation_defined::key_type key_type;
|
||||
typedef typename implementation_defined::key_of_value key_of_value;
|
||||
typedef typename implementation_defined::reference reference;
|
||||
typedef typename implementation_defined::const_reference const_reference;
|
||||
typedef typename implementation_defined::difference_type difference_type;
|
||||
@@ -123,16 +121,16 @@ class rbtree_impl
|
||||
|
||||
typedef typename implementation_defined::insert_commit_data insert_commit_data;
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::bstree(const value_compare &,const value_traits &)
|
||||
explicit rbtree_impl( const value_compare &cmp = value_compare()
|
||||
//! @copydoc ::boost::intrusive::bstree::bstree(const key_compare &,const value_traits &)
|
||||
explicit rbtree_impl( const key_compare &cmp = key_compare()
|
||||
, const value_traits &v_traits = value_traits())
|
||||
: tree_type(cmp, v_traits)
|
||||
{}
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::bstree(bool,Iterator,Iterator,const value_compare &,const value_traits &)
|
||||
//! @copydoc ::boost::intrusive::bstree::bstree(bool,Iterator,Iterator,const key_compare &,const value_traits &)
|
||||
template<class Iterator>
|
||||
rbtree_impl( bool unique, Iterator b, Iterator e
|
||||
, const value_compare &cmp = value_compare()
|
||||
, const key_compare &cmp = key_compare()
|
||||
, const value_traits &v_traits = value_traits())
|
||||
: tree_type(unique, b, e, cmp, v_traits)
|
||||
{}
|
||||
@@ -213,13 +211,26 @@ class rbtree_impl
|
||||
//! @copydoc ::boost::intrusive::bstree::swap
|
||||
void swap(rbtree_impl& other);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::clone_from(const bstree &src, cloner, Disposer)
|
||||
//! @copydoc ::boost::intrusive::bstree::clone_from(const bstree&,Cloner,Disposer)
|
||||
template <class Cloner, class Disposer>
|
||||
void clone_from(const rbtree_impl &src, Cloner cloner, Disposer disposer);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::clone_from(bstree &src, cloner, Disposer)
|
||||
#else //BOOST_INTRUSIVE_DOXYGEN_INVOKED
|
||||
|
||||
using tree_type::clone_from;
|
||||
|
||||
#endif //#ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::clone_from(bstree&&,Cloner,Disposer)
|
||||
template <class Cloner, class Disposer>
|
||||
void clone_from(rbtree_impl &src, Cloner cloner, Disposer disposer);
|
||||
void clone_from(BOOST_RV_REF(rbtree_impl) src, Cloner cloner, Disposer disposer)
|
||||
{ tree_type::clone_from(BOOST_MOVE_BASE(tree_type, src), cloner, disposer); }
|
||||
|
||||
#ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::clone_from(bstree&&,Cloner,Disposer)
|
||||
template <class Cloner, class Disposer>
|
||||
void clone_from(rbtree_impl &&src, Cloner cloner, Disposer disposer);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::insert_equal(reference)
|
||||
iterator insert_equal(reference value);
|
||||
@@ -237,16 +248,16 @@ class rbtree_impl
|
||||
//! @copydoc ::boost::intrusive::bstree::insert_unique(const_iterator,reference)
|
||||
iterator insert_unique(const_iterator hint, reference value);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::insert_unique_check(const KeyType&,KeyValueCompare,insert_commit_data&)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
//! @copydoc ::boost::intrusive::bstree::insert_unique_check(const KeyType&,KeyTypeKeyCompare,insert_commit_data&)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
std::pair<iterator, bool> insert_unique_check
|
||||
(const KeyType &key, KeyValueCompare key_value_comp, insert_commit_data &commit_data);
|
||||
(const KeyType &key, KeyTypeKeyCompare comp, insert_commit_data &commit_data);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::insert_unique_check(const_iterator,const KeyType&,KeyValueCompare,insert_commit_data&)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
//! @copydoc ::boost::intrusive::bstree::insert_unique_check(const_iterator,const KeyType&,KeyTypeKeyCompare,insert_commit_data&)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
std::pair<iterator, bool> insert_unique_check
|
||||
(const_iterator hint, const KeyType &key
|
||||
,KeyValueCompare key_value_comp, insert_commit_data &commit_data);
|
||||
,KeyTypeKeyCompare comp, insert_commit_data &commit_data);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::insert_unique_commit
|
||||
iterator insert_unique_commit(reference value, const insert_commit_data &commit_data);
|
||||
@@ -270,12 +281,12 @@ class rbtree_impl
|
||||
//! @copydoc ::boost::intrusive::bstree::erase(const_iterator,const_iterator)
|
||||
iterator erase(const_iterator b, const_iterator e);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::erase(const_reference)
|
||||
size_type erase(const_reference value);
|
||||
//! @copydoc ::boost::intrusive::bstree::erase(const key_type &key)
|
||||
size_type erase(const key_type &key);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::erase(const KeyType&,KeyValueCompare)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
size_type erase(const KeyType& key, KeyValueCompare comp);
|
||||
//! @copydoc ::boost::intrusive::bstree::erase(const KeyType&,KeyTypeKeyCompare)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
size_type erase(const KeyType& key, KeyTypeKeyCompare comp);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::erase_and_dispose(const_iterator,Disposer)
|
||||
template<class Disposer>
|
||||
@@ -285,13 +296,13 @@ class rbtree_impl
|
||||
template<class Disposer>
|
||||
iterator erase_and_dispose(const_iterator b, const_iterator e, Disposer disposer);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::erase_and_dispose(const_reference, Disposer)
|
||||
//! @copydoc ::boost::intrusive::bstree::erase_and_dispose(const key_type &, Disposer)
|
||||
template<class Disposer>
|
||||
size_type erase_and_dispose(const_reference value, Disposer disposer);
|
||||
size_type erase_and_dispose(const key_type &key, Disposer disposer);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::erase_and_dispose(const KeyType&,KeyValueCompare,Disposer)
|
||||
template<class KeyType, class KeyValueCompare, class Disposer>
|
||||
size_type erase_and_dispose(const KeyType& key, KeyValueCompare comp, Disposer disposer);
|
||||
//! @copydoc ::boost::intrusive::bstree::erase_and_dispose(const KeyType&,KeyTypeKeyCompare,Disposer)
|
||||
template<class KeyType, class KeyTypeKeyCompare, class Disposer>
|
||||
size_type erase_and_dispose(const KeyType& key, KeyTypeKeyCompare comp, Disposer disposer);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::clear
|
||||
void clear();
|
||||
@@ -300,88 +311,88 @@ class rbtree_impl
|
||||
template<class Disposer>
|
||||
void clear_and_dispose(Disposer disposer);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::count(const_reference)const
|
||||
size_type count(const_reference value) const;
|
||||
//! @copydoc ::boost::intrusive::bstree::count(const key_type &)const
|
||||
size_type count(const key_type &key) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::count(const KeyType&,KeyValueCompare)const
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
size_type count(const KeyType& key, KeyValueCompare comp) const;
|
||||
//! @copydoc ::boost::intrusive::bstree::count(const KeyType&,KeyTypeKeyCompare)const
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
size_type count(const KeyType& key, KeyTypeKeyCompare comp) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::lower_bound(const_reference)
|
||||
iterator lower_bound(const_reference value);
|
||||
//! @copydoc ::boost::intrusive::bstree::lower_bound(const key_type &)
|
||||
iterator lower_bound(const key_type &key);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::lower_bound(const KeyType&,KeyValueCompare)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
iterator lower_bound(const KeyType& key, KeyValueCompare comp);
|
||||
//! @copydoc ::boost::intrusive::bstree::lower_bound(const KeyType&,KeyTypeKeyCompare)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
iterator lower_bound(const KeyType& key, KeyTypeKeyCompare comp);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::lower_bound(const_reference)const
|
||||
const_iterator lower_bound(const_reference value) const;
|
||||
//! @copydoc ::boost::intrusive::bstree::lower_bound(const key_type &)const
|
||||
const_iterator lower_bound(const key_type &key) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::lower_bound(const KeyType&,KeyValueCompare)const
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
const_iterator lower_bound(const KeyType& key, KeyValueCompare comp) const;
|
||||
//! @copydoc ::boost::intrusive::bstree::lower_bound(const KeyType&,KeyTypeKeyCompare)const
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
const_iterator lower_bound(const KeyType& key, KeyTypeKeyCompare comp) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::upper_bound(const_reference)
|
||||
iterator upper_bound(const_reference value);
|
||||
//! @copydoc ::boost::intrusive::bstree::upper_bound(const key_type &)
|
||||
iterator upper_bound(const key_type &key);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::upper_bound(const KeyType&,KeyValueCompare)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
iterator upper_bound(const KeyType& key, KeyValueCompare comp);
|
||||
//! @copydoc ::boost::intrusive::bstree::upper_bound(const KeyType&,KeyTypeKeyCompare)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
iterator upper_bound(const KeyType& key, KeyTypeKeyCompare comp);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::upper_bound(const_reference)const
|
||||
const_iterator upper_bound(const_reference value) const;
|
||||
//! @copydoc ::boost::intrusive::bstree::upper_bound(const key_type &)const
|
||||
const_iterator upper_bound(const key_type &key) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::upper_bound(const KeyType&,KeyValueCompare)const
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
const_iterator upper_bound(const KeyType& key, KeyValueCompare comp) const;
|
||||
//! @copydoc ::boost::intrusive::bstree::upper_bound(const KeyType&,KeyTypeKeyCompare)const
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
const_iterator upper_bound(const KeyType& key, KeyTypeKeyCompare comp) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::find(const_reference)
|
||||
iterator find(const_reference value);
|
||||
//! @copydoc ::boost::intrusive::bstree::find(const key_type &)
|
||||
iterator find(const key_type &key);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::find(const KeyType&,KeyValueCompare)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
iterator find(const KeyType& key, KeyValueCompare comp);
|
||||
//! @copydoc ::boost::intrusive::bstree::find(const KeyType&,KeyTypeKeyCompare)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
iterator find(const KeyType& key, KeyTypeKeyCompare comp);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::find(const_reference)const
|
||||
const_iterator find(const_reference value) const;
|
||||
//! @copydoc ::boost::intrusive::bstree::find(const key_type &)const
|
||||
const_iterator find(const key_type &key) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::find(const KeyType&,KeyValueCompare)const
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
const_iterator find(const KeyType& key, KeyValueCompare comp) const;
|
||||
//! @copydoc ::boost::intrusive::bstree::find(const KeyType&,KeyTypeKeyCompare)const
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
const_iterator find(const KeyType& key, KeyTypeKeyCompare comp) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::equal_range(const_reference)
|
||||
std::pair<iterator,iterator> equal_range(const_reference value);
|
||||
//! @copydoc ::boost::intrusive::bstree::equal_range(const key_type &)
|
||||
std::pair<iterator,iterator> equal_range(const key_type &key);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::equal_range(const KeyType&,KeyValueCompare)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
std::pair<iterator,iterator> equal_range(const KeyType& key, KeyValueCompare comp);
|
||||
//! @copydoc ::boost::intrusive::bstree::equal_range(const KeyType&,KeyTypeKeyCompare)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
std::pair<iterator,iterator> equal_range(const KeyType& key, KeyTypeKeyCompare comp);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::equal_range(const_reference)const
|
||||
//! @copydoc ::boost::intrusive::bstree::equal_range(const key_type &)const
|
||||
std::pair<const_iterator, const_iterator>
|
||||
equal_range(const_reference value) const;
|
||||
equal_range(const key_type &key) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::equal_range(const KeyType&,KeyValueCompare)const
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
//! @copydoc ::boost::intrusive::bstree::equal_range(const KeyType&,KeyTypeKeyCompare)const
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
std::pair<const_iterator, const_iterator>
|
||||
equal_range(const KeyType& key, KeyValueCompare comp) const;
|
||||
equal_range(const KeyType& key, KeyTypeKeyCompare comp) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::bounded_range(const_reference,const_reference,bool,bool)
|
||||
//! @copydoc ::boost::intrusive::bstree::bounded_range(const key_type &,const key_type &,bool,bool)
|
||||
std::pair<iterator,iterator> bounded_range
|
||||
(const_reference lower_value, const_reference upper_value, bool left_closed, bool right_closed);
|
||||
(const key_type &lower, const key_type &upper_key, bool left_closed, bool right_closed);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::bounded_range(const KeyType&,const KeyType&,KeyValueCompare,bool,bool)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
//! @copydoc ::boost::intrusive::bstree::bounded_range(const KeyType&,const KeyType&,KeyTypeKeyCompare,bool,bool)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
std::pair<iterator,iterator> bounded_range
|
||||
(const KeyType& lower_key, const KeyType& upper_key, KeyValueCompare comp, bool left_closed, bool right_closed);
|
||||
(const KeyType& lower_key, const KeyType& upper_key, KeyTypeKeyCompare comp, bool left_closed, bool right_closed);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::bounded_range(const_reference,const_reference,bool,bool)const
|
||||
//! @copydoc ::boost::intrusive::bstree::bounded_range(const key_type &,const key_type &,bool,bool)const
|
||||
std::pair<const_iterator, const_iterator>
|
||||
bounded_range(const_reference lower_value, const_reference upper_value, bool left_closed, bool right_closed) const;
|
||||
bounded_range(const key_type &lower_key, const key_type &upper_key, bool left_closed, bool right_closed) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::bounded_range(const KeyType&,const KeyType&,KeyValueCompare,bool,bool)const
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
//! @copydoc ::boost::intrusive::bstree::bounded_range(const KeyType&,const KeyType&,KeyTypeKeyCompare,bool,bool)const
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
std::pair<const_iterator, const_iterator> bounded_range
|
||||
(const KeyType& lower_key, const KeyType& upper_key, KeyValueCompare comp, bool left_closed, bool right_closed) const;
|
||||
(const KeyType& lower_key, const KeyType& upper_key, KeyTypeKeyCompare comp, bool left_closed, bool right_closed) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::s_iterator_to(reference)
|
||||
static iterator s_iterator_to(reference value);
|
||||
@@ -431,7 +442,7 @@ template<class T, class ...Options>
|
||||
#else
|
||||
template<class T, class O1 = void, class O2 = void
|
||||
, class O3 = void, class O4 = void
|
||||
, class O5 = void>
|
||||
, class O5 = void, class O6 = void>
|
||||
#endif
|
||||
struct make_rbtree
|
||||
{
|
||||
@@ -439,7 +450,7 @@ struct make_rbtree
|
||||
typedef typename pack_options
|
||||
< rbtree_defaults,
|
||||
#if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
|
||||
O1, O2, O3, O4, O5
|
||||
O1, O2, O3, O4, O5, O6
|
||||
#else
|
||||
Options...
|
||||
#endif
|
||||
@@ -450,6 +461,7 @@ struct make_rbtree
|
||||
|
||||
typedef rbtree_impl
|
||||
< value_traits
|
||||
, typename packed_options::key_of_value
|
||||
, typename packed_options::compare
|
||||
, typename packed_options::size_type
|
||||
, packed_options::constant_time_size
|
||||
@@ -463,14 +475,14 @@ struct make_rbtree
|
||||
#ifndef BOOST_INTRUSIVE_DOXYGEN_INVOKED
|
||||
|
||||
#if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
|
||||
template<class T, class O1, class O2, class O3, class O4, class O5>
|
||||
template<class T, class O1, class O2, class O3, class O4, class O5, class O6>
|
||||
#else
|
||||
template<class T, class ...Options>
|
||||
#endif
|
||||
class rbtree
|
||||
: public make_rbtree<T,
|
||||
#if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
|
||||
O1, O2, O3, O4, O5
|
||||
O1, O2, O3, O4, O5, O6
|
||||
#else
|
||||
Options...
|
||||
#endif
|
||||
@@ -479,7 +491,7 @@ class rbtree
|
||||
typedef typename make_rbtree
|
||||
<T,
|
||||
#if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
|
||||
O1, O2, O3, O4, O5
|
||||
O1, O2, O3, O4, O5, O6
|
||||
#else
|
||||
Options...
|
||||
#endif
|
||||
@@ -487,7 +499,7 @@ class rbtree
|
||||
BOOST_MOVABLE_BUT_NOT_COPYABLE(rbtree)
|
||||
|
||||
public:
|
||||
typedef typename Base::value_compare value_compare;
|
||||
typedef typename Base::key_compare key_compare;
|
||||
typedef typename Base::value_traits value_traits;
|
||||
typedef typename Base::iterator iterator;
|
||||
typedef typename Base::const_iterator const_iterator;
|
||||
@@ -497,14 +509,14 @@ class rbtree
|
||||
//Assert if passed value traits are compatible with the type
|
||||
BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value));
|
||||
|
||||
explicit rbtree( const value_compare &cmp = value_compare()
|
||||
explicit rbtree( const key_compare &cmp = key_compare()
|
||||
, const value_traits &v_traits = value_traits())
|
||||
: Base(cmp, v_traits)
|
||||
{}
|
||||
|
||||
template<class Iterator>
|
||||
rbtree( bool unique, Iterator b, Iterator e
|
||||
, const value_compare &cmp = value_compare()
|
||||
, const key_compare &cmp = key_compare()
|
||||
, const value_traits &v_traits = value_traits())
|
||||
: Base(unique, b, e, cmp, v_traits)
|
||||
{}
|
||||
@@ -516,6 +528,14 @@ class rbtree
|
||||
rbtree& operator=(BOOST_RV_REF(rbtree) x)
|
||||
{ return static_cast<rbtree &>(this->Base::operator=(BOOST_MOVE_BASE(Base, x))); }
|
||||
|
||||
template <class Cloner, class Disposer>
|
||||
void clone_from(const rbtree &src, Cloner cloner, Disposer disposer)
|
||||
{ Base::clone_from(src, cloner, disposer); }
|
||||
|
||||
template <class Cloner, class Disposer>
|
||||
void clone_from(BOOST_RV_REF(rbtree) src, Cloner cloner, Disposer disposer)
|
||||
{ Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer); }
|
||||
|
||||
static rbtree &container_from_end_iterator(iterator end_iterator)
|
||||
{ return static_cast<rbtree &>(Base::container_from_end_iterator(end_iterator)); }
|
||||
|
||||
|
||||
+215
-175
@@ -42,15 +42,15 @@ namespace intrusive {
|
||||
#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED)
|
||||
template<class T, class ...Options>
|
||||
#else
|
||||
template<class ValueTraits, class Compare, class SizeType, bool ConstantTimeSize, typename HeaderHolder>
|
||||
template<class ValueTraits, class VoidOrKeyOfValue, class Compare, class SizeType, bool ConstantTimeSize, typename HeaderHolder>
|
||||
#endif
|
||||
class set_impl
|
||||
#ifndef BOOST_INTRUSIVE_DOXYGEN_INVOKED
|
||||
: public bstree_impl<ValueTraits, Compare, SizeType, ConstantTimeSize, RbTreeAlgorithms, HeaderHolder>
|
||||
: public bstree_impl<ValueTraits, VoidOrKeyOfValue, Compare, SizeType, ConstantTimeSize, RbTreeAlgorithms, HeaderHolder>
|
||||
#endif
|
||||
{
|
||||
/// @cond
|
||||
typedef bstree_impl<ValueTraits, Compare, SizeType, ConstantTimeSize, RbTreeAlgorithms, HeaderHolder> tree_type;
|
||||
typedef bstree_impl<ValueTraits, VoidOrKeyOfValue, Compare, SizeType, ConstantTimeSize, RbTreeAlgorithms, HeaderHolder> tree_type;
|
||||
BOOST_MOVABLE_BUT_NOT_COPYABLE(set_impl)
|
||||
|
||||
typedef tree_type implementation_defined;
|
||||
@@ -58,6 +58,8 @@ class set_impl
|
||||
|
||||
public:
|
||||
typedef typename implementation_defined::value_type value_type;
|
||||
typedef typename implementation_defined::key_type key_type;
|
||||
typedef typename implementation_defined::key_of_value key_of_value;
|
||||
typedef typename implementation_defined::value_traits value_traits;
|
||||
typedef typename implementation_defined::pointer pointer;
|
||||
typedef typename implementation_defined::const_pointer const_pointer;
|
||||
@@ -81,16 +83,16 @@ class set_impl
|
||||
static const bool constant_time_size = tree_type::constant_time_size;
|
||||
|
||||
public:
|
||||
//! @copydoc ::boost::intrusive::rbtree::rbtree(const value_compare &,const value_traits &)
|
||||
explicit set_impl( const value_compare &cmp = value_compare()
|
||||
//! @copydoc ::boost::intrusive::rbtree::rbtree(const key_compare &,const value_traits &)
|
||||
explicit set_impl( const key_compare &cmp = key_compare()
|
||||
, const value_traits &v_traits = value_traits())
|
||||
: tree_type(cmp, v_traits)
|
||||
{}
|
||||
|
||||
//! @copydoc ::boost::intrusive::rbtree::rbtree(bool,Iterator,Iterator,const value_compare &,const value_traits &)
|
||||
//! @copydoc ::boost::intrusive::rbtree::rbtree(bool,Iterator,Iterator,const key_compare &,const value_traits &)
|
||||
template<class Iterator>
|
||||
set_impl( Iterator b, Iterator e
|
||||
, const value_compare &cmp = value_compare()
|
||||
, const key_compare &cmp = key_compare()
|
||||
, const value_traits &v_traits = value_traits())
|
||||
: tree_type(true, b, e, cmp, v_traits)
|
||||
{}
|
||||
@@ -171,11 +173,20 @@ class set_impl
|
||||
//! @copydoc ::boost::intrusive::rbtree::swap
|
||||
void swap(set_impl& other);
|
||||
|
||||
//! @copydoc ::boost::intrusive::rbtree::clone_from
|
||||
//! @copydoc ::boost::intrusive::rbtree::clone_from(const rbtree&,Cloner,Disposer)
|
||||
template <class Cloner, class Disposer>
|
||||
void clone_from(const set_impl &src, Cloner cloner, Disposer disposer);
|
||||
|
||||
#endif //#ifdef BOOST_iNTRUSIVE_DOXYGEN_INVOKED
|
||||
#else
|
||||
|
||||
using tree_type::clone_from;
|
||||
|
||||
#endif //#ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
|
||||
|
||||
//! @copydoc ::boost::intrusive::rbtree::clone_from(rbtree&&,Cloner,Disposer)
|
||||
template <class Cloner, class Disposer>
|
||||
void clone_from(BOOST_RV_REF(set_impl) src, Cloner cloner, Disposer disposer)
|
||||
{ tree_type::clone_from(BOOST_MOVE_BASE(tree_type, src), cloner, disposer); }
|
||||
|
||||
//! @copydoc ::boost::intrusive::rbtree::insert_unique(reference)
|
||||
std::pair<iterator, bool> insert(reference value)
|
||||
@@ -185,18 +196,18 @@ class set_impl
|
||||
iterator insert(const_iterator hint, reference value)
|
||||
{ return tree_type::insert_unique(hint, value); }
|
||||
|
||||
//! @copydoc ::boost::intrusive::rbtree::insert_unique_check(const KeyType&,KeyValueCompare,insert_commit_data&)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
//! @copydoc ::boost::intrusive::rbtree::insert_unique_check(const KeyType&,KeyTypeKeyCompare,insert_commit_data&)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
std::pair<iterator, bool> insert_check
|
||||
(const KeyType &key, KeyValueCompare key_value_comp, insert_commit_data &commit_data)
|
||||
{ return tree_type::insert_unique_check(key, key_value_comp, commit_data); }
|
||||
(const KeyType &key, KeyTypeKeyCompare comp, insert_commit_data &commit_data)
|
||||
{ return tree_type::insert_unique_check(key, comp, commit_data); }
|
||||
|
||||
//! @copydoc ::boost::intrusive::rbtree::insert_unique_check(const_iterator,const KeyType&,KeyValueCompare,insert_commit_data&)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
//! @copydoc ::boost::intrusive::rbtree::insert_unique_check(const_iterator,const KeyType&,KeyTypeKeyCompare,insert_commit_data&)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
std::pair<iterator, bool> insert_check
|
||||
(const_iterator hint, const KeyType &key
|
||||
,KeyValueCompare key_value_comp, insert_commit_data &commit_data)
|
||||
{ return tree_type::insert_unique_check(hint, key, key_value_comp, commit_data); }
|
||||
,KeyTypeKeyCompare comp, insert_commit_data &commit_data)
|
||||
{ return tree_type::insert_unique_check(hint, key, comp, commit_data); }
|
||||
|
||||
//! @copydoc ::boost::intrusive::rbtree::insert_unique(Iterator,Iterator)
|
||||
template<class Iterator>
|
||||
@@ -223,12 +234,12 @@ class set_impl
|
||||
//! @copydoc ::boost::intrusive::rbtree::erase(const_iterator,const_iterator)
|
||||
iterator erase(const_iterator b, const_iterator e);
|
||||
|
||||
//! @copydoc ::boost::intrusive::rbtree::erase(const_reference)
|
||||
size_type erase(const_reference value);
|
||||
//! @copydoc ::boost::intrusive::rbtree::erase(const key_type &)
|
||||
size_type erase(const key_type &key);
|
||||
|
||||
//! @copydoc ::boost::intrusive::rbtree::erase(const KeyType&,KeyValueCompare)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
size_type erase(const KeyType& key, KeyValueCompare comp);
|
||||
//! @copydoc ::boost::intrusive::rbtree::erase(const KeyType&,KeyTypeKeyCompare)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
size_type erase(const KeyType& key, KeyTypeKeyCompare comp);
|
||||
|
||||
//! @copydoc ::boost::intrusive::rbtree::erase_and_dispose(const_iterator,Disposer)
|
||||
template<class Disposer>
|
||||
@@ -238,13 +249,13 @@ class set_impl
|
||||
template<class Disposer>
|
||||
iterator erase_and_dispose(const_iterator b, const_iterator e, Disposer disposer);
|
||||
|
||||
//! @copydoc ::boost::intrusive::rbtree::erase_and_dispose(const_reference, Disposer)
|
||||
//! @copydoc ::boost::intrusive::rbtree::erase_and_dispose(const key_type &, Disposer)
|
||||
template<class Disposer>
|
||||
size_type erase_and_dispose(const_reference value, Disposer disposer);
|
||||
size_type erase_and_dispose(const key_type &key, Disposer disposer);
|
||||
|
||||
//! @copydoc ::boost::intrusive::rbtree::erase_and_dispose(const KeyType&,KeyValueCompare,Disposer)
|
||||
template<class KeyType, class KeyValueCompare, class Disposer>
|
||||
size_type erase_and_dispose(const KeyType& key, KeyValueCompare comp, Disposer disposer);
|
||||
//! @copydoc ::boost::intrusive::rbtree::erase_and_dispose(const KeyType&,KeyTypeKeyCompare,Disposer)
|
||||
template<class KeyType, class KeyTypeKeyCompare, class Disposer>
|
||||
size_type erase_and_dispose(const KeyType& key, KeyTypeKeyCompare comp, Disposer disposer);
|
||||
|
||||
//! @copydoc ::boost::intrusive::rbtree::clear
|
||||
void clear();
|
||||
@@ -255,100 +266,100 @@ class set_impl
|
||||
|
||||
#endif // #ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
|
||||
|
||||
//! @copydoc ::boost::intrusive::rbtree::count(const_reference)const
|
||||
size_type count(const_reference value) const
|
||||
{ return static_cast<size_type>(this->tree_type::find(value) != this->tree_type::cend()); }
|
||||
//! @copydoc ::boost::intrusive::rbtree::count(const key_type &)const
|
||||
size_type count(const key_type &key) const
|
||||
{ return static_cast<size_type>(this->tree_type::find(key) != this->tree_type::cend()); }
|
||||
|
||||
//! @copydoc ::boost::intrusive::rbtree::count(const KeyType&,KeyValueCompare)const
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
size_type count(const KeyType& key, KeyValueCompare comp) const
|
||||
//! @copydoc ::boost::intrusive::rbtree::count(const KeyType&,KeyTypeKeyCompare)const
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
size_type count(const KeyType& key, KeyTypeKeyCompare comp) const
|
||||
{ return static_cast<size_type>(this->tree_type::find(key, comp) != this->tree_type::cend()); }
|
||||
|
||||
#ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
|
||||
|
||||
//! @copydoc ::boost::intrusive::rbtree::lower_bound(const_reference)
|
||||
iterator lower_bound(const_reference value);
|
||||
//! @copydoc ::boost::intrusive::rbtree::lower_bound(const key_type &)
|
||||
iterator lower_bound(const key_type &key);
|
||||
|
||||
//! @copydoc ::boost::intrusive::rbtree::lower_bound(const KeyType&,KeyValueCompare)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
iterator lower_bound(const KeyType& key, KeyValueCompare comp);
|
||||
//! @copydoc ::boost::intrusive::rbtree::lower_bound(const KeyType&,KeyTypeKeyCompare)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
iterator lower_bound(const KeyType& key, KeyTypeKeyCompare comp);
|
||||
|
||||
//! @copydoc ::boost::intrusive::rbtree::lower_bound(const_reference)const
|
||||
const_iterator lower_bound(const_reference value) const;
|
||||
//! @copydoc ::boost::intrusive::rbtree::lower_bound(const key_type &)const
|
||||
const_iterator lower_bound(const key_type &key) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::rbtree::lower_bound(const KeyType&,KeyValueCompare)const
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
const_iterator lower_bound(const KeyType& key, KeyValueCompare comp) const;
|
||||
//! @copydoc ::boost::intrusive::rbtree::lower_bound(const KeyType&,KeyTypeKeyCompare)const
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
const_iterator lower_bound(const KeyType& key, KeyTypeKeyCompare comp) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::rbtree::upper_bound(const_reference)
|
||||
iterator upper_bound(const_reference value);
|
||||
//! @copydoc ::boost::intrusive::rbtree::upper_bound(const key_type &)
|
||||
iterator upper_bound(const key_type &key);
|
||||
|
||||
//! @copydoc ::boost::intrusive::rbtree::upper_bound(const KeyType&,KeyValueCompare)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
iterator upper_bound(const KeyType& key, KeyValueCompare comp);
|
||||
//! @copydoc ::boost::intrusive::rbtree::upper_bound(const KeyType&,KeyTypeKeyCompare)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
iterator upper_bound(const KeyType& key, KeyTypeKeyCompare comp);
|
||||
|
||||
//! @copydoc ::boost::intrusive::rbtree::upper_bound(const_reference)const
|
||||
const_iterator upper_bound(const_reference value) const;
|
||||
//! @copydoc ::boost::intrusive::rbtree::upper_bound(const key_type &)const
|
||||
const_iterator upper_bound(const key_type &key) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::rbtree::upper_bound(const KeyType&,KeyValueCompare)const
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
const_iterator upper_bound(const KeyType& key, KeyValueCompare comp) const;
|
||||
//! @copydoc ::boost::intrusive::rbtree::upper_bound(const KeyType&,KeyTypeKeyCompare)const
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
const_iterator upper_bound(const KeyType& key, KeyTypeKeyCompare comp) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::rbtree::find(const_reference)
|
||||
iterator find(const_reference value);
|
||||
//! @copydoc ::boost::intrusive::rbtree::find(const key_type &)
|
||||
iterator find(const key_type &key);
|
||||
|
||||
//! @copydoc ::boost::intrusive::rbtree::find(const KeyType&,KeyValueCompare)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
iterator find(const KeyType& key, KeyValueCompare comp);
|
||||
//! @copydoc ::boost::intrusive::rbtree::find(const KeyType&,KeyTypeKeyCompare)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
iterator find(const KeyType& key, KeyTypeKeyCompare comp);
|
||||
|
||||
//! @copydoc ::boost::intrusive::rbtree::find(const_reference)const
|
||||
const_iterator find(const_reference value) const;
|
||||
//! @copydoc ::boost::intrusive::rbtree::find(const key_type &)const
|
||||
const_iterator find(const key_type &key) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::rbtree::find(const KeyType&,KeyValueCompare)const
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
const_iterator find(const KeyType& key, KeyValueCompare comp) const;
|
||||
//! @copydoc ::boost::intrusive::rbtree::find(const KeyType&,KeyTypeKeyCompare)const
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
const_iterator find(const KeyType& key, KeyTypeKeyCompare comp) const;
|
||||
|
||||
#endif // #ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
|
||||
|
||||
//! @copydoc ::boost::intrusive::rbtree::equal_range(const_reference)
|
||||
std::pair<iterator,iterator> equal_range(const_reference value)
|
||||
{ return this->tree_type::lower_bound_range(value); }
|
||||
//! @copydoc ::boost::intrusive::rbtree::equal_range(const key_type &)
|
||||
std::pair<iterator,iterator> equal_range(const key_type &key)
|
||||
{ return this->tree_type::lower_bound_range(key); }
|
||||
|
||||
//! @copydoc ::boost::intrusive::rbtree::equal_range(const KeyType&,KeyValueCompare)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
std::pair<iterator,iterator> equal_range(const KeyType& key, KeyValueCompare comp)
|
||||
//! @copydoc ::boost::intrusive::rbtree::equal_range(const KeyType&,KeyTypeKeyCompare)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
std::pair<iterator,iterator> equal_range(const KeyType& key, KeyTypeKeyCompare comp)
|
||||
{ return this->tree_type::lower_bound_range(key, comp); }
|
||||
|
||||
//! @copydoc ::boost::intrusive::rbtree::equal_range(const_reference)const
|
||||
//! @copydoc ::boost::intrusive::rbtree::equal_range(const key_type &)const
|
||||
std::pair<const_iterator, const_iterator>
|
||||
equal_range(const_reference value) const
|
||||
{ return this->tree_type::lower_bound_range(value); }
|
||||
equal_range(const key_type &key) const
|
||||
{ return this->tree_type::lower_bound_range(key); }
|
||||
|
||||
//! @copydoc ::boost::intrusive::rbtree::equal_range(const KeyType&,KeyValueCompare)const
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
//! @copydoc ::boost::intrusive::rbtree::equal_range(const KeyType&,KeyTypeKeyCompare)const
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
std::pair<const_iterator, const_iterator>
|
||||
equal_range(const KeyType& key, KeyValueCompare comp) const
|
||||
equal_range(const KeyType& key, KeyTypeKeyCompare comp) const
|
||||
{ return this->tree_type::lower_bound_range(key, comp); }
|
||||
|
||||
#ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
|
||||
|
||||
//! @copydoc ::boost::intrusive::rbtree::bounded_range(const_reference,const_reference,bool,bool)
|
||||
//! @copydoc ::boost::intrusive::rbtree::bounded_range(const key_type &,const key_type &,bool,bool)
|
||||
std::pair<iterator,iterator> bounded_range
|
||||
(const_reference lower_value, const_reference upper_value, bool left_closed, bool right_closed);
|
||||
(const key_type &lower_key, const key_type &upper_key, bool left_closed, bool right_closed);
|
||||
|
||||
//! @copydoc ::boost::intrusive::rbtree::bounded_range(const KeyType&,const KeyType&,KeyValueCompare,bool,bool)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
//! @copydoc ::boost::intrusive::rbtree::bounded_range(const KeyType&,const KeyType&,KeyTypeKeyCompare,bool,bool)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
std::pair<iterator,iterator> bounded_range
|
||||
(const KeyType& lower_key, const KeyType& upper_key, KeyValueCompare comp, bool left_closed, bool right_closed);
|
||||
(const KeyType& lower_key, const KeyType& upper_key, KeyTypeKeyCompare comp, bool left_closed, bool right_closed);
|
||||
|
||||
//! @copydoc ::boost::intrusive::rbtree::bounded_range(const_reference,const_reference,bool,bool)const
|
||||
//! @copydoc ::boost::intrusive::rbtree::bounded_range(const key_type &,const key_type &,bool,bool)const
|
||||
std::pair<const_iterator, const_iterator>
|
||||
bounded_range(const_reference lower_value, const_reference upper_value, bool left_closed, bool right_closed) const;
|
||||
bounded_range(const key_type &lower_key, const key_type &upper_key, bool left_closed, bool right_closed) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::rbtree::bounded_range(const KeyType&,const KeyType&,KeyValueCompare,bool,bool)const
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
//! @copydoc ::boost::intrusive::rbtree::bounded_range(const KeyType&,const KeyType&,KeyTypeKeyCompare,bool,bool)const
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
std::pair<const_iterator, const_iterator> bounded_range
|
||||
(const KeyType& lower_key, const KeyType& upper_key, KeyValueCompare comp, bool left_closed, bool right_closed) const;
|
||||
(const KeyType& lower_key, const KeyType& upper_key, KeyTypeKeyCompare comp, bool left_closed, bool right_closed) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::rbtree::s_iterator_to(reference)
|
||||
static iterator s_iterator_to(reference value);
|
||||
@@ -402,7 +413,7 @@ template<class T, class ...Options>
|
||||
#else
|
||||
template<class T, class O1 = void, class O2 = void
|
||||
, class O3 = void, class O4 = void
|
||||
, class O5 = void>
|
||||
, class O5 = void, class O6 = void>
|
||||
#endif
|
||||
struct make_set
|
||||
{
|
||||
@@ -410,7 +421,7 @@ struct make_set
|
||||
typedef typename pack_options
|
||||
< rbtree_defaults,
|
||||
#if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
|
||||
O1, O2, O3, O4, O5
|
||||
O1, O2, O3, O4, O5, O6
|
||||
#else
|
||||
Options...
|
||||
#endif
|
||||
@@ -421,6 +432,7 @@ struct make_set
|
||||
|
||||
typedef set_impl
|
||||
< value_traits
|
||||
, typename packed_options::key_of_value
|
||||
, typename packed_options::compare
|
||||
, typename packed_options::size_type
|
||||
, packed_options::constant_time_size
|
||||
@@ -432,14 +444,14 @@ struct make_set
|
||||
|
||||
#ifndef BOOST_INTRUSIVE_DOXYGEN_INVOKED
|
||||
#if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
|
||||
template<class T, class O1, class O2, class O3, class O4, class O5>
|
||||
template<class T, class O1, class O2, class O3, class O4, class O5, class O6>
|
||||
#else
|
||||
template<class T, class ...Options>
|
||||
#endif
|
||||
class set
|
||||
: public make_set<T,
|
||||
#if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
|
||||
O1, O2, O3, O4, O5
|
||||
O1, O2, O3, O4, O5, O6
|
||||
#else
|
||||
Options...
|
||||
#endif
|
||||
@@ -448,7 +460,7 @@ class set
|
||||
typedef typename make_set
|
||||
<T,
|
||||
#if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
|
||||
O1, O2, O3, O4, O5
|
||||
O1, O2, O3, O4, O5, O6
|
||||
#else
|
||||
Options...
|
||||
#endif
|
||||
@@ -456,7 +468,7 @@ class set
|
||||
|
||||
BOOST_MOVABLE_BUT_NOT_COPYABLE(set)
|
||||
public:
|
||||
typedef typename Base::value_compare value_compare;
|
||||
typedef typename Base::key_compare key_compare;
|
||||
typedef typename Base::value_traits value_traits;
|
||||
typedef typename Base::iterator iterator;
|
||||
typedef typename Base::const_iterator const_iterator;
|
||||
@@ -464,14 +476,14 @@ class set
|
||||
//Assert if passed value traits are compatible with the type
|
||||
BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value));
|
||||
|
||||
explicit set( const value_compare &cmp = value_compare()
|
||||
explicit set( const key_compare &cmp = key_compare()
|
||||
, const value_traits &v_traits = value_traits())
|
||||
: Base(cmp, v_traits)
|
||||
{}
|
||||
|
||||
template<class Iterator>
|
||||
set( Iterator b, Iterator e
|
||||
, const value_compare &cmp = value_compare()
|
||||
, const key_compare &cmp = key_compare()
|
||||
, const value_traits &v_traits = value_traits())
|
||||
: Base(b, e, cmp, v_traits)
|
||||
{}
|
||||
@@ -483,6 +495,14 @@ class set
|
||||
set& operator=(BOOST_RV_REF(set) x)
|
||||
{ return static_cast<set &>(this->Base::operator=(BOOST_MOVE_BASE(Base, x))); }
|
||||
|
||||
template <class Cloner, class Disposer>
|
||||
void clone_from(const set &src, Cloner cloner, Disposer disposer)
|
||||
{ Base::clone_from(src, cloner, disposer); }
|
||||
|
||||
template <class Cloner, class Disposer>
|
||||
void clone_from(BOOST_RV_REF(set) src, Cloner cloner, Disposer disposer)
|
||||
{ Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer); }
|
||||
|
||||
static set &container_from_end_iterator(iterator end_iterator)
|
||||
{ return static_cast<set &>(Base::container_from_end_iterator(end_iterator)); }
|
||||
|
||||
@@ -512,15 +532,15 @@ class set
|
||||
#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED)
|
||||
template<class T, class ...Options>
|
||||
#else
|
||||
template<class ValueTraits, class Compare, class SizeType, bool ConstantTimeSize, typename HeaderHolder>
|
||||
template<class ValueTraits, class VoidOrKeyOfValue, class Compare, class SizeType, bool ConstantTimeSize, typename HeaderHolder>
|
||||
#endif
|
||||
class multiset_impl
|
||||
#ifndef BOOST_INTRUSIVE_DOXYGEN_INVOKED
|
||||
: public bstree_impl<ValueTraits, Compare, SizeType, ConstantTimeSize, RbTreeAlgorithms, HeaderHolder>
|
||||
: public bstree_impl<ValueTraits, VoidOrKeyOfValue, Compare, SizeType, ConstantTimeSize, RbTreeAlgorithms, HeaderHolder>
|
||||
#endif
|
||||
{
|
||||
/// @cond
|
||||
typedef bstree_impl<ValueTraits, Compare, SizeType, ConstantTimeSize, RbTreeAlgorithms, HeaderHolder> tree_type;
|
||||
typedef bstree_impl<ValueTraits, VoidOrKeyOfValue, Compare, SizeType, ConstantTimeSize, RbTreeAlgorithms, HeaderHolder> tree_type;
|
||||
|
||||
BOOST_MOVABLE_BUT_NOT_COPYABLE(multiset_impl)
|
||||
typedef tree_type implementation_defined;
|
||||
@@ -528,6 +548,8 @@ class multiset_impl
|
||||
|
||||
public:
|
||||
typedef typename implementation_defined::value_type value_type;
|
||||
typedef typename implementation_defined::key_type key_type;
|
||||
typedef typename implementation_defined::key_of_value key_of_value;
|
||||
typedef typename implementation_defined::value_traits value_traits;
|
||||
typedef typename implementation_defined::pointer pointer;
|
||||
typedef typename implementation_defined::const_pointer const_pointer;
|
||||
@@ -551,16 +573,16 @@ class multiset_impl
|
||||
static const bool constant_time_size = tree_type::constant_time_size;
|
||||
|
||||
public:
|
||||
//! @copydoc ::boost::intrusive::rbtree::rbtree(const value_compare &,const value_traits &)
|
||||
explicit multiset_impl( const value_compare &cmp = value_compare()
|
||||
//! @copydoc ::boost::intrusive::rbtree::rbtree(const key_compare &,const value_traits &)
|
||||
explicit multiset_impl( const key_compare &cmp = key_compare()
|
||||
, const value_traits &v_traits = value_traits())
|
||||
: tree_type(cmp, v_traits)
|
||||
{}
|
||||
|
||||
//! @copydoc ::boost::intrusive::rbtree::rbtree(bool,Iterator,Iterator,const value_compare &,const value_traits &)
|
||||
//! @copydoc ::boost::intrusive::rbtree::rbtree(bool,Iterator,Iterator,const key_compare &,const value_traits &)
|
||||
template<class Iterator>
|
||||
multiset_impl( Iterator b, Iterator e
|
||||
, const value_compare &cmp = value_compare()
|
||||
, const key_compare &cmp = key_compare()
|
||||
, const value_traits &v_traits = value_traits())
|
||||
: tree_type(false, b, e, cmp, v_traits)
|
||||
{}
|
||||
@@ -641,11 +663,20 @@ class multiset_impl
|
||||
//! @copydoc ::boost::intrusive::rbtree::swap
|
||||
void swap(multiset_impl& other);
|
||||
|
||||
//! @copydoc ::boost::intrusive::rbtree::clone_from
|
||||
//! @copydoc ::boost::intrusive::rbtree::clone_from(const rbtree&,Cloner,Disposer)
|
||||
template <class Cloner, class Disposer>
|
||||
void clone_from(const multiset_impl &src, Cloner cloner, Disposer disposer);
|
||||
|
||||
#endif //#ifdef BOOST_iNTRUSIVE_DOXYGEN_INVOKED
|
||||
#else
|
||||
|
||||
using tree_type::clone_from;
|
||||
|
||||
#endif //#ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
|
||||
|
||||
//! @copydoc ::boost::intrusive::rbtree::clone_from(rbtree&&,Cloner,Disposer)
|
||||
template <class Cloner, class Disposer>
|
||||
void clone_from(BOOST_RV_REF(multiset_impl) src, Cloner cloner, Disposer disposer)
|
||||
{ tree_type::clone_from(BOOST_MOVE_BASE(tree_type, src), cloner, disposer); }
|
||||
|
||||
//! @copydoc ::boost::intrusive::rbtree::insert_equal(reference)
|
||||
iterator insert(reference value)
|
||||
@@ -676,12 +707,12 @@ class multiset_impl
|
||||
//! @copydoc ::boost::intrusive::rbtree::erase(const_iterator,const_iterator)
|
||||
iterator erase(const_iterator b, const_iterator e);
|
||||
|
||||
//! @copydoc ::boost::intrusive::rbtree::erase(const_reference)
|
||||
size_type erase(const_reference value);
|
||||
//! @copydoc ::boost::intrusive::rbtree::erase(const key_type &)
|
||||
size_type erase(const key_type &key);
|
||||
|
||||
//! @copydoc ::boost::intrusive::rbtree::erase(const KeyType&,KeyValueCompare)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
size_type erase(const KeyType& key, KeyValueCompare comp);
|
||||
//! @copydoc ::boost::intrusive::rbtree::erase(const KeyType&,KeyTypeKeyCompare)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
size_type erase(const KeyType& key, KeyTypeKeyCompare comp);
|
||||
|
||||
//! @copydoc ::boost::intrusive::rbtree::erase_and_dispose(const_iterator,Disposer)
|
||||
template<class Disposer>
|
||||
@@ -691,13 +722,13 @@ class multiset_impl
|
||||
template<class Disposer>
|
||||
iterator erase_and_dispose(const_iterator b, const_iterator e, Disposer disposer);
|
||||
|
||||
//! @copydoc ::boost::intrusive::rbtree::erase_and_dispose(const_reference, Disposer)
|
||||
//! @copydoc ::boost::intrusive::rbtree::erase_and_dispose(const key_type &, Disposer)
|
||||
template<class Disposer>
|
||||
size_type erase_and_dispose(const_reference value, Disposer disposer);
|
||||
size_type erase_and_dispose(const key_type &key, Disposer disposer);
|
||||
|
||||
//! @copydoc ::boost::intrusive::rbtree::erase_and_dispose(const KeyType&,KeyValueCompare,Disposer)
|
||||
template<class KeyType, class KeyValueCompare, class Disposer>
|
||||
size_type erase_and_dispose(const KeyType& key, KeyValueCompare comp, Disposer disposer);
|
||||
//! @copydoc ::boost::intrusive::rbtree::erase_and_dispose(const KeyType&,KeyTypeKeyCompare,Disposer)
|
||||
template<class KeyType, class KeyTypeKeyCompare, class Disposer>
|
||||
size_type erase_and_dispose(const KeyType& key, KeyTypeKeyCompare comp, Disposer disposer);
|
||||
|
||||
//! @copydoc ::boost::intrusive::rbtree::clear
|
||||
void clear();
|
||||
@@ -706,88 +737,88 @@ class multiset_impl
|
||||
template<class Disposer>
|
||||
void clear_and_dispose(Disposer disposer);
|
||||
|
||||
//! @copydoc ::boost::intrusive::rbtree::count(const_reference)const
|
||||
size_type count(const_reference value) const;
|
||||
//! @copydoc ::boost::intrusive::rbtree::count(const key_type &)const
|
||||
size_type count(const key_type &key) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::rbtree::count(const KeyType&,KeyValueCompare)const
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
size_type count(const KeyType& key, KeyValueCompare comp) const;
|
||||
//! @copydoc ::boost::intrusive::rbtree::count(const KeyType&,KeyTypeKeyCompare)const
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
size_type count(const KeyType& key, KeyTypeKeyCompare comp) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::rbtree::lower_bound(const_reference)
|
||||
iterator lower_bound(const_reference value);
|
||||
//! @copydoc ::boost::intrusive::rbtree::lower_bound(const key_type &)
|
||||
iterator lower_bound(const key_type &key);
|
||||
|
||||
//! @copydoc ::boost::intrusive::rbtree::lower_bound(const KeyType&,KeyValueCompare)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
iterator lower_bound(const KeyType& key, KeyValueCompare comp);
|
||||
//! @copydoc ::boost::intrusive::rbtree::lower_bound(const KeyType&,KeyTypeKeyCompare)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
iterator lower_bound(const KeyType& key, KeyTypeKeyCompare comp);
|
||||
|
||||
//! @copydoc ::boost::intrusive::rbtree::lower_bound(const_reference)const
|
||||
const_iterator lower_bound(const_reference value) const;
|
||||
//! @copydoc ::boost::intrusive::rbtree::lower_bound(const key_type &)const
|
||||
const_iterator lower_bound(const key_type &key) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::rbtree::lower_bound(const KeyType&,KeyValueCompare)const
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
const_iterator lower_bound(const KeyType& key, KeyValueCompare comp) const;
|
||||
//! @copydoc ::boost::intrusive::rbtree::lower_bound(const KeyType&,KeyTypeKeyCompare)const
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
const_iterator lower_bound(const KeyType& key, KeyTypeKeyCompare comp) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::rbtree::upper_bound(const_reference)
|
||||
iterator upper_bound(const_reference value);
|
||||
//! @copydoc ::boost::intrusive::rbtree::upper_bound(const key_type &)
|
||||
iterator upper_bound(const key_type &key);
|
||||
|
||||
//! @copydoc ::boost::intrusive::rbtree::upper_bound(const KeyType&,KeyValueCompare)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
iterator upper_bound(const KeyType& key, KeyValueCompare comp);
|
||||
//! @copydoc ::boost::intrusive::rbtree::upper_bound(const KeyType&,KeyTypeKeyCompare)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
iterator upper_bound(const KeyType& key, KeyTypeKeyCompare comp);
|
||||
|
||||
//! @copydoc ::boost::intrusive::rbtree::upper_bound(const_reference)const
|
||||
const_iterator upper_bound(const_reference value) const;
|
||||
//! @copydoc ::boost::intrusive::rbtree::upper_bound(const key_type &)const
|
||||
const_iterator upper_bound(const key_type &key) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::rbtree::upper_bound(const KeyType&,KeyValueCompare)const
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
const_iterator upper_bound(const KeyType& key, KeyValueCompare comp) const;
|
||||
//! @copydoc ::boost::intrusive::rbtree::upper_bound(const KeyType&,KeyTypeKeyCompare)const
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
const_iterator upper_bound(const KeyType& key, KeyTypeKeyCompare comp) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::rbtree::find(const_reference)
|
||||
iterator find(const_reference value);
|
||||
//! @copydoc ::boost::intrusive::rbtree::find(const key_type &)
|
||||
iterator find(const key_type &key);
|
||||
|
||||
//! @copydoc ::boost::intrusive::rbtree::find(const KeyType&,KeyValueCompare)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
iterator find(const KeyType& key, KeyValueCompare comp);
|
||||
//! @copydoc ::boost::intrusive::rbtree::find(const KeyType&,KeyTypeKeyCompare)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
iterator find(const KeyType& key, KeyTypeKeyCompare comp);
|
||||
|
||||
//! @copydoc ::boost::intrusive::rbtree::find(const_reference)const
|
||||
const_iterator find(const_reference value) const;
|
||||
//! @copydoc ::boost::intrusive::rbtree::find(const key_type &)const
|
||||
const_iterator find(const key_type &key) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::rbtree::find(const KeyType&,KeyValueCompare)const
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
const_iterator find(const KeyType& key, KeyValueCompare comp) const;
|
||||
//! @copydoc ::boost::intrusive::rbtree::find(const KeyType&,KeyTypeKeyCompare)const
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
const_iterator find(const KeyType& key, KeyTypeKeyCompare comp) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::rbtree::equal_range(const_reference)
|
||||
std::pair<iterator,iterator> equal_range(const_reference value);
|
||||
//! @copydoc ::boost::intrusive::rbtree::equal_range(const key_type &)
|
||||
std::pair<iterator,iterator> equal_range(const key_type &key);
|
||||
|
||||
//! @copydoc ::boost::intrusive::rbtree::equal_range(const KeyType&,KeyValueCompare)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
std::pair<iterator,iterator> equal_range(const KeyType& key, KeyValueCompare comp);
|
||||
//! @copydoc ::boost::intrusive::rbtree::equal_range(const KeyType&,KeyTypeKeyCompare)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
std::pair<iterator,iterator> equal_range(const KeyType& key, KeyTypeKeyCompare comp);
|
||||
|
||||
//! @copydoc ::boost::intrusive::rbtree::equal_range(const_reference)const
|
||||
//! @copydoc ::boost::intrusive::rbtree::equal_range(const key_type &)const
|
||||
std::pair<const_iterator, const_iterator>
|
||||
equal_range(const_reference value) const;
|
||||
equal_range(const key_type &key) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::rbtree::equal_range(const KeyType&,KeyValueCompare)const
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
//! @copydoc ::boost::intrusive::rbtree::equal_range(const KeyType&,KeyTypeKeyCompare)const
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
std::pair<const_iterator, const_iterator>
|
||||
equal_range(const KeyType& key, KeyValueCompare comp) const;
|
||||
equal_range(const KeyType& key, KeyTypeKeyCompare comp) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::rbtree::bounded_range(const_reference,const_reference,bool,bool)
|
||||
//! @copydoc ::boost::intrusive::rbtree::bounded_range(const key_type &,const key_type &,bool,bool)
|
||||
std::pair<iterator,iterator> bounded_range
|
||||
(const_reference lower_value, const_reference upper_value, bool left_closed, bool right_closed);
|
||||
(const key_type &lower_key, const key_type &upper_key, bool left_closed, bool right_closed);
|
||||
|
||||
//! @copydoc ::boost::intrusive::rbtree::bounded_range(const KeyType&,const KeyType&,KeyValueCompare,bool,bool)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
//! @copydoc ::boost::intrusive::rbtree::bounded_range(const KeyType&,const KeyType&,KeyTypeKeyCompare,bool,bool)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
std::pair<iterator,iterator> bounded_range
|
||||
(const KeyType& lower_key, const KeyType& upper_key, KeyValueCompare comp, bool left_closed, bool right_closed);
|
||||
(const KeyType& lower_key, const KeyType& upper_key, KeyTypeKeyCompare comp, bool left_closed, bool right_closed);
|
||||
|
||||
//! @copydoc ::boost::intrusive::rbtree::bounded_range(const_reference,const_reference,bool,bool)const
|
||||
//! @copydoc ::boost::intrusive::rbtree::bounded_range(const key_type &,const key_type &,bool,bool)const
|
||||
std::pair<const_iterator, const_iterator>
|
||||
bounded_range(const_reference lower_value, const_reference upper_value, bool left_closed, bool right_closed) const;
|
||||
bounded_range(const key_type &lower_key, const key_type &upper_key, bool left_closed, bool right_closed) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::rbtree::bounded_range(const KeyType&,const KeyType&,KeyValueCompare,bool,bool)const
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
//! @copydoc ::boost::intrusive::rbtree::bounded_range(const KeyType&,const KeyType&,KeyTypeKeyCompare,bool,bool)const
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
std::pair<const_iterator, const_iterator> bounded_range
|
||||
(const KeyType& lower_key, const KeyType& upper_key, KeyValueCompare comp, bool left_closed, bool right_closed) const;
|
||||
(const KeyType& lower_key, const KeyType& upper_key, KeyTypeKeyCompare comp, bool left_closed, bool right_closed) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::rbtree::s_iterator_to(reference)
|
||||
static iterator s_iterator_to(reference value);
|
||||
@@ -841,7 +872,7 @@ template<class T, class ...Options>
|
||||
#else
|
||||
template<class T, class O1 = void, class O2 = void
|
||||
, class O3 = void, class O4 = void
|
||||
, class O5 = void>
|
||||
, class O5 = void, class O6 = void>
|
||||
#endif
|
||||
struct make_multiset
|
||||
{
|
||||
@@ -849,7 +880,7 @@ struct make_multiset
|
||||
typedef typename pack_options
|
||||
< rbtree_defaults,
|
||||
#if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
|
||||
O1, O2, O3, O4, O5
|
||||
O1, O2, O3, O4, O5, O6
|
||||
#else
|
||||
Options...
|
||||
#endif
|
||||
@@ -860,6 +891,7 @@ struct make_multiset
|
||||
|
||||
typedef multiset_impl
|
||||
< value_traits
|
||||
, typename packed_options::key_of_value
|
||||
, typename packed_options::compare
|
||||
, typename packed_options::size_type
|
||||
, packed_options::constant_time_size
|
||||
@@ -872,14 +904,14 @@ struct make_multiset
|
||||
#ifndef BOOST_INTRUSIVE_DOXYGEN_INVOKED
|
||||
|
||||
#if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
|
||||
template<class T, class O1, class O2, class O3, class O4, class O5>
|
||||
template<class T, class O1, class O2, class O3, class O4, class O5, class O6>
|
||||
#else
|
||||
template<class T, class ...Options>
|
||||
#endif
|
||||
class multiset
|
||||
: public make_multiset<T,
|
||||
#if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
|
||||
O1, O2, O3, O4, O5
|
||||
O1, O2, O3, O4, O5, O6
|
||||
#else
|
||||
Options...
|
||||
#endif
|
||||
@@ -887,7 +919,7 @@ class multiset
|
||||
{
|
||||
typedef typename make_multiset<T,
|
||||
#if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
|
||||
O1, O2, O3, O4, O5
|
||||
O1, O2, O3, O4, O5, O6
|
||||
#else
|
||||
Options...
|
||||
#endif
|
||||
@@ -896,7 +928,7 @@ class multiset
|
||||
BOOST_MOVABLE_BUT_NOT_COPYABLE(multiset)
|
||||
|
||||
public:
|
||||
typedef typename Base::value_compare value_compare;
|
||||
typedef typename Base::key_compare key_compare;
|
||||
typedef typename Base::value_traits value_traits;
|
||||
typedef typename Base::iterator iterator;
|
||||
typedef typename Base::const_iterator const_iterator;
|
||||
@@ -904,14 +936,14 @@ class multiset
|
||||
//Assert if passed value traits are compatible with the type
|
||||
BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value));
|
||||
|
||||
multiset( const value_compare &cmp = value_compare()
|
||||
multiset( const key_compare &cmp = key_compare()
|
||||
, const value_traits &v_traits = value_traits())
|
||||
: Base(cmp, v_traits)
|
||||
{}
|
||||
|
||||
template<class Iterator>
|
||||
multiset( Iterator b, Iterator e
|
||||
, const value_compare &cmp = value_compare()
|
||||
, const key_compare &cmp = key_compare()
|
||||
, const value_traits &v_traits = value_traits())
|
||||
: Base(b, e, cmp, v_traits)
|
||||
{}
|
||||
@@ -923,6 +955,14 @@ class multiset
|
||||
multiset& operator=(BOOST_RV_REF(multiset) x)
|
||||
{ return static_cast<multiset &>(this->Base::operator=(BOOST_MOVE_BASE(Base, x))); }
|
||||
|
||||
template <class Cloner, class Disposer>
|
||||
void clone_from(const multiset &src, Cloner cloner, Disposer disposer)
|
||||
{ Base::clone_from(src, cloner, disposer); }
|
||||
|
||||
template <class Cloner, class Disposer>
|
||||
void clone_from(BOOST_RV_REF(multiset) src, Cloner cloner, Disposer disposer)
|
||||
{ Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer); }
|
||||
|
||||
static multiset &container_from_end_iterator(iterator end_iterator)
|
||||
{ return static_cast<multiset &>(Base::container_from_end_iterator(end_iterator)); }
|
||||
|
||||
|
||||
+215
-175
@@ -40,15 +40,15 @@ namespace intrusive {
|
||||
#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED)
|
||||
template<class T, class ...Options>
|
||||
#else
|
||||
template<class ValueTraits, class Compare, class SizeType, bool FloatingPoint, typename HeaderHolder>
|
||||
template<class ValueTraits, class VoidOrKeyOfValue, class Compare, class SizeType, bool FloatingPoint, typename HeaderHolder>
|
||||
#endif
|
||||
class sg_set_impl
|
||||
#ifndef BOOST_INTRUSIVE_DOXYGEN_INVOKED
|
||||
: public sgtree_impl<ValueTraits, Compare, SizeType, FloatingPoint, HeaderHolder>
|
||||
: public sgtree_impl<ValueTraits, VoidOrKeyOfValue, Compare, SizeType, FloatingPoint, HeaderHolder>
|
||||
#endif
|
||||
{
|
||||
/// @cond
|
||||
typedef sgtree_impl<ValueTraits, Compare, SizeType, FloatingPoint, HeaderHolder> tree_type;
|
||||
typedef sgtree_impl<ValueTraits, VoidOrKeyOfValue, Compare, SizeType, FloatingPoint, HeaderHolder> tree_type;
|
||||
BOOST_MOVABLE_BUT_NOT_COPYABLE(sg_set_impl)
|
||||
|
||||
typedef tree_type implementation_defined;
|
||||
@@ -56,6 +56,8 @@ class sg_set_impl
|
||||
|
||||
public:
|
||||
typedef typename implementation_defined::value_type value_type;
|
||||
typedef typename implementation_defined::key_type key_type;
|
||||
typedef typename implementation_defined::key_of_value key_of_value;
|
||||
typedef typename implementation_defined::value_traits value_traits;
|
||||
typedef typename implementation_defined::pointer pointer;
|
||||
typedef typename implementation_defined::const_pointer const_pointer;
|
||||
@@ -79,16 +81,16 @@ class sg_set_impl
|
||||
static const bool constant_time_size = tree_type::constant_time_size;
|
||||
|
||||
public:
|
||||
//! @copydoc ::boost::intrusive::sgtree::sgtree(const value_compare &,const value_traits &)
|
||||
explicit sg_set_impl( const value_compare &cmp = value_compare()
|
||||
//! @copydoc ::boost::intrusive::sgtree::sgtree(const key_compare &,const value_traits &)
|
||||
explicit sg_set_impl( const key_compare &cmp = key_compare()
|
||||
, const value_traits &v_traits = value_traits())
|
||||
: tree_type(cmp, v_traits)
|
||||
{}
|
||||
|
||||
//! @copydoc ::boost::intrusive::sgtree::sgtree(bool,Iterator,Iterator,const value_compare &,const value_traits &)
|
||||
//! @copydoc ::boost::intrusive::sgtree::sgtree(bool,Iterator,Iterator,const key_compare &,const value_traits &)
|
||||
template<class Iterator>
|
||||
sg_set_impl( Iterator b, Iterator e
|
||||
, const value_compare &cmp = value_compare()
|
||||
, const key_compare &cmp = key_compare()
|
||||
, const value_traits &v_traits = value_traits())
|
||||
: tree_type(true, b, e, cmp, v_traits)
|
||||
{}
|
||||
@@ -169,11 +171,20 @@ class sg_set_impl
|
||||
//! @copydoc ::boost::intrusive::sgtree::swap
|
||||
void swap(sg_set_impl& other);
|
||||
|
||||
//! @copydoc ::boost::intrusive::sgtree::clone_from
|
||||
//! @copydoc ::boost::intrusive::sgtree::clone_from(const sgtree&,Cloner,Disposer)
|
||||
template <class Cloner, class Disposer>
|
||||
void clone_from(const sg_set_impl &src, Cloner cloner, Disposer disposer);
|
||||
|
||||
#endif //#ifdef BOOST_iNTRUSIVE_DOXYGEN_INVOKED
|
||||
#else
|
||||
|
||||
using tree_type::clone_from;
|
||||
|
||||
#endif //#ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
|
||||
|
||||
//! @copydoc ::boost::intrusive::sgtree::clone_from(sgtree&&,Cloner,Disposer)
|
||||
template <class Cloner, class Disposer>
|
||||
void clone_from(BOOST_RV_REF(sg_set_impl) src, Cloner cloner, Disposer disposer)
|
||||
{ tree_type::clone_from(BOOST_MOVE_BASE(tree_type, src), cloner, disposer); }
|
||||
|
||||
//! @copydoc ::boost::intrusive::sgtree::insert_unique(reference)
|
||||
std::pair<iterator, bool> insert(reference value)
|
||||
@@ -183,18 +194,18 @@ class sg_set_impl
|
||||
iterator insert(const_iterator hint, reference value)
|
||||
{ return tree_type::insert_unique(hint, value); }
|
||||
|
||||
//! @copydoc ::boost::intrusive::sgtree::insert_unique_check(const KeyType&,KeyValueCompare,insert_commit_data&)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
//! @copydoc ::boost::intrusive::sgtree::insert_unique_check(const KeyType&,KeyTypeKeyCompare,insert_commit_data&)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
std::pair<iterator, bool> insert_check
|
||||
(const KeyType &key, KeyValueCompare key_value_comp, insert_commit_data &commit_data)
|
||||
{ return tree_type::insert_unique_check(key, key_value_comp, commit_data); }
|
||||
(const KeyType &key, KeyTypeKeyCompare comp, insert_commit_data &commit_data)
|
||||
{ return tree_type::insert_unique_check(key, comp, commit_data); }
|
||||
|
||||
//! @copydoc ::boost::intrusive::sgtree::insert_unique_check(const_iterator,const KeyType&,KeyValueCompare,insert_commit_data&)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
//! @copydoc ::boost::intrusive::sgtree::insert_unique_check(const_iterator,const KeyType&,KeyTypeKeyCompare,insert_commit_data&)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
std::pair<iterator, bool> insert_check
|
||||
(const_iterator hint, const KeyType &key
|
||||
,KeyValueCompare key_value_comp, insert_commit_data &commit_data)
|
||||
{ return tree_type::insert_unique_check(hint, key, key_value_comp, commit_data); }
|
||||
,KeyTypeKeyCompare comp, insert_commit_data &commit_data)
|
||||
{ return tree_type::insert_unique_check(hint, key, comp, commit_data); }
|
||||
|
||||
//! @copydoc ::boost::intrusive::sgtree::insert_unique(Iterator,Iterator)
|
||||
template<class Iterator>
|
||||
@@ -221,12 +232,12 @@ class sg_set_impl
|
||||
//! @copydoc ::boost::intrusive::sgtree::erase(const_iterator,const_iterator)
|
||||
iterator erase(const_iterator b, const_iterator e);
|
||||
|
||||
//! @copydoc ::boost::intrusive::sgtree::erase(const_reference)
|
||||
size_type erase(const_reference value);
|
||||
//! @copydoc ::boost::intrusive::sgtree::erase(const key_type &)
|
||||
size_type erase(const key_type &key);
|
||||
|
||||
//! @copydoc ::boost::intrusive::sgtree::erase(const KeyType&,KeyValueCompare)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
size_type erase(const KeyType& key, KeyValueCompare comp);
|
||||
//! @copydoc ::boost::intrusive::sgtree::erase(const KeyType&,KeyTypeKeyCompare)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
size_type erase(const KeyType& key, KeyTypeKeyCompare comp);
|
||||
|
||||
//! @copydoc ::boost::intrusive::sgtree::erase_and_dispose(const_iterator,Disposer)
|
||||
template<class Disposer>
|
||||
@@ -236,13 +247,13 @@ class sg_set_impl
|
||||
template<class Disposer>
|
||||
iterator erase_and_dispose(const_iterator b, const_iterator e, Disposer disposer);
|
||||
|
||||
//! @copydoc ::boost::intrusive::sgtree::erase_and_dispose(const_reference, Disposer)
|
||||
//! @copydoc ::boost::intrusive::sgtree::erase_and_dispose(const key_type &, Disposer)
|
||||
template<class Disposer>
|
||||
size_type erase_and_dispose(const_reference value, Disposer disposer);
|
||||
size_type erase_and_dispose(const key_type &key, Disposer disposer);
|
||||
|
||||
//! @copydoc ::boost::intrusive::sgtree::erase_and_dispose(const KeyType&,KeyValueCompare,Disposer)
|
||||
template<class KeyType, class KeyValueCompare, class Disposer>
|
||||
size_type erase_and_dispose(const KeyType& key, KeyValueCompare comp, Disposer disposer);
|
||||
//! @copydoc ::boost::intrusive::sgtree::erase_and_dispose(const KeyType&,KeyTypeKeyCompare,Disposer)
|
||||
template<class KeyType, class KeyTypeKeyCompare, class Disposer>
|
||||
size_type erase_and_dispose(const KeyType& key, KeyTypeKeyCompare comp, Disposer disposer);
|
||||
|
||||
//! @copydoc ::boost::intrusive::sgtree::clear
|
||||
void clear();
|
||||
@@ -253,100 +264,100 @@ class sg_set_impl
|
||||
|
||||
#endif // #ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
|
||||
|
||||
//! @copydoc ::boost::intrusive::sgtree::count(const_reference)const
|
||||
size_type count(const_reference value) const
|
||||
{ return static_cast<size_type>(this->tree_type::find(value) != this->tree_type::cend()); }
|
||||
//! @copydoc ::boost::intrusive::sgtree::count(const key_type &)const
|
||||
size_type count(const key_type &key) const
|
||||
{ return static_cast<size_type>(this->tree_type::find(key) != this->tree_type::cend()); }
|
||||
|
||||
//! @copydoc ::boost::intrusive::sgtree::count(const KeyType&,KeyValueCompare)const
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
size_type count(const KeyType& key, KeyValueCompare comp) const
|
||||
//! @copydoc ::boost::intrusive::sgtree::count(const KeyType&,KeyTypeKeyCompare)const
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
size_type count(const KeyType& key, KeyTypeKeyCompare comp) const
|
||||
{ return static_cast<size_type>(this->tree_type::find(key, comp) != this->tree_type::cend()); }
|
||||
|
||||
#ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
|
||||
|
||||
//! @copydoc ::boost::intrusive::sgtree::lower_bound(const_reference)
|
||||
iterator lower_bound(const_reference value);
|
||||
//! @copydoc ::boost::intrusive::sgtree::lower_bound(const key_type &)
|
||||
iterator lower_bound(const key_type &key);
|
||||
|
||||
//! @copydoc ::boost::intrusive::sgtree::lower_bound(const KeyType&,KeyValueCompare)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
iterator lower_bound(const KeyType& key, KeyValueCompare comp);
|
||||
//! @copydoc ::boost::intrusive::sgtree::lower_bound(const KeyType&,KeyTypeKeyCompare)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
iterator lower_bound(const KeyType& key, KeyTypeKeyCompare comp);
|
||||
|
||||
//! @copydoc ::boost::intrusive::sgtree::lower_bound(const_reference)const
|
||||
const_iterator lower_bound(const_reference value) const;
|
||||
//! @copydoc ::boost::intrusive::sgtree::lower_bound(const key_type &)const
|
||||
const_iterator lower_bound(const key_type &key) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::sgtree::lower_bound(const KeyType&,KeyValueCompare)const
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
const_iterator lower_bound(const KeyType& key, KeyValueCompare comp) const;
|
||||
//! @copydoc ::boost::intrusive::sgtree::lower_bound(const KeyType&,KeyTypeKeyCompare)const
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
const_iterator lower_bound(const KeyType& key, KeyTypeKeyCompare comp) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::sgtree::upper_bound(const_reference)
|
||||
iterator upper_bound(const_reference value);
|
||||
//! @copydoc ::boost::intrusive::sgtree::upper_bound(const key_type &)
|
||||
iterator upper_bound(const key_type &key);
|
||||
|
||||
//! @copydoc ::boost::intrusive::sgtree::upper_bound(const KeyType&,KeyValueCompare)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
iterator upper_bound(const KeyType& key, KeyValueCompare comp);
|
||||
//! @copydoc ::boost::intrusive::sgtree::upper_bound(const KeyType&,KeyTypeKeyCompare)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
iterator upper_bound(const KeyType& key, KeyTypeKeyCompare comp);
|
||||
|
||||
//! @copydoc ::boost::intrusive::sgtree::upper_bound(const_reference)const
|
||||
const_iterator upper_bound(const_reference value) const;
|
||||
//! @copydoc ::boost::intrusive::sgtree::upper_bound(const key_type &)const
|
||||
const_iterator upper_bound(const key_type &key) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::sgtree::upper_bound(const KeyType&,KeyValueCompare)const
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
const_iterator upper_bound(const KeyType& key, KeyValueCompare comp) const;
|
||||
//! @copydoc ::boost::intrusive::sgtree::upper_bound(const KeyType&,KeyTypeKeyCompare)const
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
const_iterator upper_bound(const KeyType& key, KeyTypeKeyCompare comp) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::sgtree::find(const_reference)
|
||||
iterator find(const_reference value);
|
||||
//! @copydoc ::boost::intrusive::sgtree::find(const key_type &)
|
||||
iterator find(const key_type &key);
|
||||
|
||||
//! @copydoc ::boost::intrusive::sgtree::find(const KeyType&,KeyValueCompare)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
iterator find(const KeyType& key, KeyValueCompare comp);
|
||||
//! @copydoc ::boost::intrusive::sgtree::find(const KeyType&,KeyTypeKeyCompare)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
iterator find(const KeyType& key, KeyTypeKeyCompare comp);
|
||||
|
||||
//! @copydoc ::boost::intrusive::sgtree::find(const_reference)const
|
||||
const_iterator find(const_reference value) const;
|
||||
//! @copydoc ::boost::intrusive::sgtree::find(const key_type &)const
|
||||
const_iterator find(const key_type &key) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::sgtree::find(const KeyType&,KeyValueCompare)const
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
const_iterator find(const KeyType& key, KeyValueCompare comp) const;
|
||||
//! @copydoc ::boost::intrusive::sgtree::find(const KeyType&,KeyTypeKeyCompare)const
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
const_iterator find(const KeyType& key, KeyTypeKeyCompare comp) const;
|
||||
|
||||
#endif // #ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
|
||||
|
||||
//! @copydoc ::boost::intrusive::rbtree::equal_range(const_reference)
|
||||
std::pair<iterator,iterator> equal_range(const_reference value)
|
||||
{ return this->tree_type::lower_bound_range(value); }
|
||||
//! @copydoc ::boost::intrusive::rbtree::equal_range(const key_type &)
|
||||
std::pair<iterator,iterator> equal_range(const key_type &key)
|
||||
{ return this->tree_type::lower_bound_range(key); }
|
||||
|
||||
//! @copydoc ::boost::intrusive::rbtree::equal_range(const KeyType&,KeyValueCompare)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
std::pair<iterator,iterator> equal_range(const KeyType& key, KeyValueCompare comp)
|
||||
//! @copydoc ::boost::intrusive::rbtree::equal_range(const KeyType&,KeyTypeKeyCompare)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
std::pair<iterator,iterator> equal_range(const KeyType& key, KeyTypeKeyCompare comp)
|
||||
{ return this->tree_type::lower_bound_range(key, comp); }
|
||||
|
||||
//! @copydoc ::boost::intrusive::rbtree::equal_range(const_reference)const
|
||||
//! @copydoc ::boost::intrusive::rbtree::equal_range(const key_type &)const
|
||||
std::pair<const_iterator, const_iterator>
|
||||
equal_range(const_reference value) const
|
||||
{ return this->tree_type::lower_bound_range(value); }
|
||||
equal_range(const key_type &key) const
|
||||
{ return this->tree_type::lower_bound_range(key); }
|
||||
|
||||
//! @copydoc ::boost::intrusive::rbtree::equal_range(const KeyType&,KeyValueCompare)const
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
//! @copydoc ::boost::intrusive::rbtree::equal_range(const KeyType&,KeyTypeKeyCompare)const
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
std::pair<const_iterator, const_iterator>
|
||||
equal_range(const KeyType& key, KeyValueCompare comp) const
|
||||
equal_range(const KeyType& key, KeyTypeKeyCompare comp) const
|
||||
{ return this->tree_type::lower_bound_range(key, comp); }
|
||||
|
||||
#ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
|
||||
|
||||
//! @copydoc ::boost::intrusive::sgtree::bounded_range(const_reference,const_reference,bool,bool)
|
||||
//! @copydoc ::boost::intrusive::sgtree::bounded_range(const key_type &,const key_type &,bool,bool)
|
||||
std::pair<iterator,iterator> bounded_range
|
||||
(const_reference lower_value, const_reference upper_value, bool left_closed, bool right_closed);
|
||||
(const key_type &lower_key, const key_type &upper_key, bool left_closed, bool right_closed);
|
||||
|
||||
//! @copydoc ::boost::intrusive::sgtree::bounded_range(const KeyType&,const KeyType&,KeyValueCompare,bool,bool)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
//! @copydoc ::boost::intrusive::sgtree::bounded_range(const KeyType&,const KeyType&,KeyTypeKeyCompare,bool,bool)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
std::pair<iterator,iterator> bounded_range
|
||||
(const KeyType& lower_key, const KeyType& upper_key, KeyValueCompare comp, bool left_closed, bool right_closed);
|
||||
(const KeyType& lower_key, const KeyType& upper_key, KeyTypeKeyCompare comp, bool left_closed, bool right_closed);
|
||||
|
||||
//! @copydoc ::boost::intrusive::sgtree::bounded_range(const_reference,const_reference,bool,bool)const
|
||||
//! @copydoc ::boost::intrusive::sgtree::bounded_range(const key_type &,const key_type &,bool,bool)const
|
||||
std::pair<const_iterator, const_iterator>
|
||||
bounded_range(const_reference lower_value, const_reference upper_value, bool left_closed, bool right_closed) const;
|
||||
bounded_range(const key_type &lower_key, const key_type &upper_key, bool left_closed, bool right_closed) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::sgtree::bounded_range(const KeyType&,const KeyType&,KeyValueCompare,bool,bool)const
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
//! @copydoc ::boost::intrusive::sgtree::bounded_range(const KeyType&,const KeyType&,KeyTypeKeyCompare,bool,bool)const
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
std::pair<const_iterator, const_iterator> bounded_range
|
||||
(const KeyType& lower_key, const KeyType& upper_key, KeyValueCompare comp, bool left_closed, bool right_closed) const;
|
||||
(const KeyType& lower_key, const KeyType& upper_key, KeyTypeKeyCompare comp, bool left_closed, bool right_closed) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::sgtree::s_iterator_to(reference)
|
||||
static iterator s_iterator_to(reference value);
|
||||
@@ -413,7 +424,7 @@ template<class T, class ...Options>
|
||||
#else
|
||||
template<class T, class O1 = void, class O2 = void
|
||||
, class O3 = void, class O4 = void
|
||||
, class O5 = void>
|
||||
, class O5 = void, class O6 = void>
|
||||
#endif
|
||||
struct make_sg_set
|
||||
{
|
||||
@@ -421,7 +432,7 @@ struct make_sg_set
|
||||
typedef typename pack_options
|
||||
< sgtree_defaults,
|
||||
#if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
|
||||
O1, O2, O3, O4, O5
|
||||
O1, O2, O3, O4, O5, O6
|
||||
#else
|
||||
Options...
|
||||
#endif
|
||||
@@ -432,6 +443,7 @@ struct make_sg_set
|
||||
|
||||
typedef sg_set_impl
|
||||
< value_traits
|
||||
, typename packed_options::key_of_value
|
||||
, typename packed_options::compare
|
||||
, typename packed_options::size_type
|
||||
, packed_options::floating_point
|
||||
@@ -443,14 +455,14 @@ struct make_sg_set
|
||||
|
||||
#ifndef BOOST_INTRUSIVE_DOXYGEN_INVOKED
|
||||
#if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
|
||||
template<class T, class O1, class O2, class O3, class O4, class O5>
|
||||
template<class T, class O1, class O2, class O3, class O4, class O5, class O6>
|
||||
#else
|
||||
template<class T, class ...Options>
|
||||
#endif
|
||||
class sg_set
|
||||
: public make_sg_set<T,
|
||||
#if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
|
||||
O1, O2, O3, O4, O5
|
||||
O1, O2, O3, O4, O5, O6
|
||||
#else
|
||||
Options...
|
||||
#endif
|
||||
@@ -459,7 +471,7 @@ class sg_set
|
||||
typedef typename make_sg_set
|
||||
<T,
|
||||
#if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
|
||||
O1, O2, O3, O4, O5
|
||||
O1, O2, O3, O4, O5, O6
|
||||
#else
|
||||
Options...
|
||||
#endif
|
||||
@@ -467,7 +479,7 @@ class sg_set
|
||||
|
||||
BOOST_MOVABLE_BUT_NOT_COPYABLE(sg_set)
|
||||
public:
|
||||
typedef typename Base::value_compare value_compare;
|
||||
typedef typename Base::key_compare key_compare;
|
||||
typedef typename Base::value_traits value_traits;
|
||||
typedef typename Base::iterator iterator;
|
||||
typedef typename Base::const_iterator const_iterator;
|
||||
@@ -475,14 +487,14 @@ class sg_set
|
||||
//Assert if passed value traits are compatible with the type
|
||||
BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value));
|
||||
|
||||
explicit sg_set( const value_compare &cmp = value_compare()
|
||||
explicit sg_set( const key_compare &cmp = key_compare()
|
||||
, const value_traits &v_traits = value_traits())
|
||||
: Base(cmp, v_traits)
|
||||
{}
|
||||
|
||||
template<class Iterator>
|
||||
sg_set( Iterator b, Iterator e
|
||||
, const value_compare &cmp = value_compare()
|
||||
, const key_compare &cmp = key_compare()
|
||||
, const value_traits &v_traits = value_traits())
|
||||
: Base(b, e, cmp, v_traits)
|
||||
{}
|
||||
@@ -494,6 +506,14 @@ class sg_set
|
||||
sg_set& operator=(BOOST_RV_REF(sg_set) x)
|
||||
{ return static_cast<sg_set &>(this->Base::operator=(BOOST_MOVE_BASE(Base, x))); }
|
||||
|
||||
template <class Cloner, class Disposer>
|
||||
void clone_from(const sg_set &src, Cloner cloner, Disposer disposer)
|
||||
{ Base::clone_from(src, cloner, disposer); }
|
||||
|
||||
template <class Cloner, class Disposer>
|
||||
void clone_from(BOOST_RV_REF(sg_set) src, Cloner cloner, Disposer disposer)
|
||||
{ Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer); }
|
||||
|
||||
static sg_set &container_from_end_iterator(iterator end_iterator)
|
||||
{ return static_cast<sg_set &>(Base::container_from_end_iterator(end_iterator)); }
|
||||
|
||||
@@ -523,15 +543,15 @@ class sg_set
|
||||
#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED)
|
||||
template<class T, class ...Options>
|
||||
#else
|
||||
template<class ValueTraits, class Compare, class SizeType, bool FloatingPoint, typename HeaderHolder>
|
||||
template<class ValueTraits, class VoidOrKeyOfValue, class Compare, class SizeType, bool FloatingPoint, typename HeaderHolder>
|
||||
#endif
|
||||
class sg_multiset_impl
|
||||
#ifndef BOOST_INTRUSIVE_DOXYGEN_INVOKED
|
||||
: public sgtree_impl<ValueTraits, Compare, SizeType, FloatingPoint, HeaderHolder>
|
||||
: public sgtree_impl<ValueTraits, VoidOrKeyOfValue, Compare, SizeType, FloatingPoint, HeaderHolder>
|
||||
#endif
|
||||
{
|
||||
/// @cond
|
||||
typedef sgtree_impl<ValueTraits, Compare, SizeType, FloatingPoint, HeaderHolder> tree_type;
|
||||
typedef sgtree_impl<ValueTraits, VoidOrKeyOfValue, Compare, SizeType, FloatingPoint, HeaderHolder> tree_type;
|
||||
|
||||
BOOST_MOVABLE_BUT_NOT_COPYABLE(sg_multiset_impl)
|
||||
typedef tree_type implementation_defined;
|
||||
@@ -539,6 +559,8 @@ class sg_multiset_impl
|
||||
|
||||
public:
|
||||
typedef typename implementation_defined::value_type value_type;
|
||||
typedef typename implementation_defined::key_type key_type;
|
||||
typedef typename implementation_defined::key_of_value key_of_value;
|
||||
typedef typename implementation_defined::value_traits value_traits;
|
||||
typedef typename implementation_defined::pointer pointer;
|
||||
typedef typename implementation_defined::const_pointer const_pointer;
|
||||
@@ -562,16 +584,16 @@ class sg_multiset_impl
|
||||
static const bool constant_time_size = tree_type::constant_time_size;
|
||||
|
||||
public:
|
||||
//! @copydoc ::boost::intrusive::sgtree::sgtree(const value_compare &,const value_traits &)
|
||||
explicit sg_multiset_impl( const value_compare &cmp = value_compare()
|
||||
//! @copydoc ::boost::intrusive::sgtree::sgtree(const key_compare &,const value_traits &)
|
||||
explicit sg_multiset_impl( const key_compare &cmp = key_compare()
|
||||
, const value_traits &v_traits = value_traits())
|
||||
: tree_type(cmp, v_traits)
|
||||
{}
|
||||
|
||||
//! @copydoc ::boost::intrusive::sgtree::sgtree(bool,Iterator,Iterator,const value_compare &,const value_traits &)
|
||||
//! @copydoc ::boost::intrusive::sgtree::sgtree(bool,Iterator,Iterator,const key_compare &,const value_traits &)
|
||||
template<class Iterator>
|
||||
sg_multiset_impl( Iterator b, Iterator e
|
||||
, const value_compare &cmp = value_compare()
|
||||
, const key_compare &cmp = key_compare()
|
||||
, const value_traits &v_traits = value_traits())
|
||||
: tree_type(false, b, e, cmp, v_traits)
|
||||
{}
|
||||
@@ -652,11 +674,20 @@ class sg_multiset_impl
|
||||
//! @copydoc ::boost::intrusive::sgtree::swap
|
||||
void swap(sg_multiset_impl& other);
|
||||
|
||||
//! @copydoc ::boost::intrusive::sgtree::clone_from
|
||||
//! @copydoc ::boost::intrusive::sgtree::clone_from(const sgtree&,Cloner,Disposer)
|
||||
template <class Cloner, class Disposer>
|
||||
void clone_from(const sg_multiset_impl &src, Cloner cloner, Disposer disposer);
|
||||
|
||||
#endif //#ifdef BOOST_iNTRUSIVE_DOXYGEN_INVOKED
|
||||
#else
|
||||
|
||||
using tree_type::clone_from;
|
||||
|
||||
#endif //#ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
|
||||
|
||||
//! @copydoc ::boost::intrusive::sgtree::clone_from(sgtree&&,Cloner,Disposer)
|
||||
template <class Cloner, class Disposer>
|
||||
void clone_from(BOOST_RV_REF(sg_multiset_impl) src, Cloner cloner, Disposer disposer)
|
||||
{ tree_type::clone_from(BOOST_MOVE_BASE(tree_type, src), cloner, disposer); }
|
||||
|
||||
//! @copydoc ::boost::intrusive::sgtree::insert_equal(reference)
|
||||
iterator insert(reference value)
|
||||
@@ -687,12 +718,12 @@ class sg_multiset_impl
|
||||
//! @copydoc ::boost::intrusive::sgtree::erase(const_iterator,const_iterator)
|
||||
iterator erase(const_iterator b, const_iterator e);
|
||||
|
||||
//! @copydoc ::boost::intrusive::sgtree::erase(const_reference)
|
||||
size_type erase(const_reference value);
|
||||
//! @copydoc ::boost::intrusive::sgtree::erase(const key_type &)
|
||||
size_type erase(const key_type &key);
|
||||
|
||||
//! @copydoc ::boost::intrusive::sgtree::erase(const KeyType&,KeyValueCompare)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
size_type erase(const KeyType& key, KeyValueCompare comp);
|
||||
//! @copydoc ::boost::intrusive::sgtree::erase(const KeyType&,KeyTypeKeyCompare)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
size_type erase(const KeyType& key, KeyTypeKeyCompare comp);
|
||||
|
||||
//! @copydoc ::boost::intrusive::sgtree::erase_and_dispose(const_iterator,Disposer)
|
||||
template<class Disposer>
|
||||
@@ -702,13 +733,13 @@ class sg_multiset_impl
|
||||
template<class Disposer>
|
||||
iterator erase_and_dispose(const_iterator b, const_iterator e, Disposer disposer);
|
||||
|
||||
//! @copydoc ::boost::intrusive::sgtree::erase_and_dispose(const_reference, Disposer)
|
||||
//! @copydoc ::boost::intrusive::sgtree::erase_and_dispose(const key_type &, Disposer)
|
||||
template<class Disposer>
|
||||
size_type erase_and_dispose(const_reference value, Disposer disposer);
|
||||
size_type erase_and_dispose(const key_type &key, Disposer disposer);
|
||||
|
||||
//! @copydoc ::boost::intrusive::sgtree::erase_and_dispose(const KeyType&,KeyValueCompare,Disposer)
|
||||
template<class KeyType, class KeyValueCompare, class Disposer>
|
||||
size_type erase_and_dispose(const KeyType& key, KeyValueCompare comp, Disposer disposer);
|
||||
//! @copydoc ::boost::intrusive::sgtree::erase_and_dispose(const KeyType&,KeyTypeKeyCompare,Disposer)
|
||||
template<class KeyType, class KeyTypeKeyCompare, class Disposer>
|
||||
size_type erase_and_dispose(const KeyType& key, KeyTypeKeyCompare comp, Disposer disposer);
|
||||
|
||||
//! @copydoc ::boost::intrusive::sgtree::clear
|
||||
void clear();
|
||||
@@ -717,88 +748,88 @@ class sg_multiset_impl
|
||||
template<class Disposer>
|
||||
void clear_and_dispose(Disposer disposer);
|
||||
|
||||
//! @copydoc ::boost::intrusive::sgtree::count(const_reference)const
|
||||
size_type count(const_reference value) const;
|
||||
//! @copydoc ::boost::intrusive::sgtree::count(const key_type &)const
|
||||
size_type count(const key_type &key) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::sgtree::count(const KeyType&,KeyValueCompare)const
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
size_type count(const KeyType& key, KeyValueCompare comp) const;
|
||||
//! @copydoc ::boost::intrusive::sgtree::count(const KeyType&,KeyTypeKeyCompare)const
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
size_type count(const KeyType& key, KeyTypeKeyCompare comp) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::sgtree::lower_bound(const_reference)
|
||||
iterator lower_bound(const_reference value);
|
||||
//! @copydoc ::boost::intrusive::sgtree::lower_bound(const key_type &)
|
||||
iterator lower_bound(const key_type &key);
|
||||
|
||||
//! @copydoc ::boost::intrusive::sgtree::lower_bound(const KeyType&,KeyValueCompare)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
iterator lower_bound(const KeyType& key, KeyValueCompare comp);
|
||||
//! @copydoc ::boost::intrusive::sgtree::lower_bound(const KeyType&,KeyTypeKeyCompare)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
iterator lower_bound(const KeyType& key, KeyTypeKeyCompare comp);
|
||||
|
||||
//! @copydoc ::boost::intrusive::sgtree::lower_bound(const_reference)const
|
||||
const_iterator lower_bound(const_reference value) const;
|
||||
//! @copydoc ::boost::intrusive::sgtree::lower_bound(const key_type &)const
|
||||
const_iterator lower_bound(const key_type &key) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::sgtree::lower_bound(const KeyType&,KeyValueCompare)const
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
const_iterator lower_bound(const KeyType& key, KeyValueCompare comp) const;
|
||||
//! @copydoc ::boost::intrusive::sgtree::lower_bound(const KeyType&,KeyTypeKeyCompare)const
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
const_iterator lower_bound(const KeyType& key, KeyTypeKeyCompare comp) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::sgtree::upper_bound(const_reference)
|
||||
iterator upper_bound(const_reference value);
|
||||
//! @copydoc ::boost::intrusive::sgtree::upper_bound(const key_type &)
|
||||
iterator upper_bound(const key_type &key);
|
||||
|
||||
//! @copydoc ::boost::intrusive::sgtree::upper_bound(const KeyType&,KeyValueCompare)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
iterator upper_bound(const KeyType& key, KeyValueCompare comp);
|
||||
//! @copydoc ::boost::intrusive::sgtree::upper_bound(const KeyType&,KeyTypeKeyCompare)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
iterator upper_bound(const KeyType& key, KeyTypeKeyCompare comp);
|
||||
|
||||
//! @copydoc ::boost::intrusive::sgtree::upper_bound(const_reference)const
|
||||
const_iterator upper_bound(const_reference value) const;
|
||||
//! @copydoc ::boost::intrusive::sgtree::upper_bound(const key_type &)const
|
||||
const_iterator upper_bound(const key_type &key) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::sgtree::upper_bound(const KeyType&,KeyValueCompare)const
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
const_iterator upper_bound(const KeyType& key, KeyValueCompare comp) const;
|
||||
//! @copydoc ::boost::intrusive::sgtree::upper_bound(const KeyType&,KeyTypeKeyCompare)const
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
const_iterator upper_bound(const KeyType& key, KeyTypeKeyCompare comp) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::sgtree::find(const_reference)
|
||||
iterator find(const_reference value);
|
||||
//! @copydoc ::boost::intrusive::sgtree::find(const key_type &)
|
||||
iterator find(const key_type &key);
|
||||
|
||||
//! @copydoc ::boost::intrusive::sgtree::find(const KeyType&,KeyValueCompare)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
iterator find(const KeyType& key, KeyValueCompare comp);
|
||||
//! @copydoc ::boost::intrusive::sgtree::find(const KeyType&,KeyTypeKeyCompare)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
iterator find(const KeyType& key, KeyTypeKeyCompare comp);
|
||||
|
||||
//! @copydoc ::boost::intrusive::sgtree::find(const_reference)const
|
||||
const_iterator find(const_reference value) const;
|
||||
//! @copydoc ::boost::intrusive::sgtree::find(const key_type &)const
|
||||
const_iterator find(const key_type &key) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::sgtree::find(const KeyType&,KeyValueCompare)const
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
const_iterator find(const KeyType& key, KeyValueCompare comp) const;
|
||||
//! @copydoc ::boost::intrusive::sgtree::find(const KeyType&,KeyTypeKeyCompare)const
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
const_iterator find(const KeyType& key, KeyTypeKeyCompare comp) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::sgtree::equal_range(const_reference)
|
||||
std::pair<iterator,iterator> equal_range(const_reference value);
|
||||
//! @copydoc ::boost::intrusive::sgtree::equal_range(const key_type &)
|
||||
std::pair<iterator,iterator> equal_range(const key_type &key);
|
||||
|
||||
//! @copydoc ::boost::intrusive::sgtree::equal_range(const KeyType&,KeyValueCompare)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
std::pair<iterator,iterator> equal_range(const KeyType& key, KeyValueCompare comp);
|
||||
//! @copydoc ::boost::intrusive::sgtree::equal_range(const KeyType&,KeyTypeKeyCompare)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
std::pair<iterator,iterator> equal_range(const KeyType& key, KeyTypeKeyCompare comp);
|
||||
|
||||
//! @copydoc ::boost::intrusive::sgtree::equal_range(const_reference)const
|
||||
//! @copydoc ::boost::intrusive::sgtree::equal_range(const key_type &)const
|
||||
std::pair<const_iterator, const_iterator>
|
||||
equal_range(const_reference value) const;
|
||||
equal_range(const key_type &key) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::sgtree::equal_range(const KeyType&,KeyValueCompare)const
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
//! @copydoc ::boost::intrusive::sgtree::equal_range(const KeyType&,KeyTypeKeyCompare)const
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
std::pair<const_iterator, const_iterator>
|
||||
equal_range(const KeyType& key, KeyValueCompare comp) const;
|
||||
equal_range(const KeyType& key, KeyTypeKeyCompare comp) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::sgtree::bounded_range(const_reference,const_reference,bool,bool)
|
||||
//! @copydoc ::boost::intrusive::sgtree::bounded_range(const key_type &,const key_type &,bool,bool)
|
||||
std::pair<iterator,iterator> bounded_range
|
||||
(const_reference lower_value, const_reference upper_value, bool left_closed, bool right_closed);
|
||||
(const key_type &lower_key, const key_type &upper_key, bool left_closed, bool right_closed);
|
||||
|
||||
//! @copydoc ::boost::intrusive::sgtree::bounded_range(const KeyType&,const KeyType&,KeyValueCompare,bool,bool)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
//! @copydoc ::boost::intrusive::sgtree::bounded_range(const KeyType&,const KeyType&,KeyTypeKeyCompare,bool,bool)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
std::pair<iterator,iterator> bounded_range
|
||||
(const KeyType& lower_key, const KeyType& upper_key, KeyValueCompare comp, bool left_closed, bool right_closed);
|
||||
(const KeyType& lower_key, const KeyType& upper_key, KeyTypeKeyCompare comp, bool left_closed, bool right_closed);
|
||||
|
||||
//! @copydoc ::boost::intrusive::sgtree::bounded_range(const_reference,const_reference,bool,bool)const
|
||||
//! @copydoc ::boost::intrusive::sgtree::bounded_range(const key_type &,const key_type &,bool,bool)const
|
||||
std::pair<const_iterator, const_iterator>
|
||||
bounded_range(const_reference lower_value, const_reference upper_value, bool left_closed, bool right_closed) const;
|
||||
bounded_range(const key_type &lower_key, const key_type &upper_key, bool left_closed, bool right_closed) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::sgtree::bounded_range(const KeyType&,const KeyType&,KeyValueCompare,bool,bool)const
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
//! @copydoc ::boost::intrusive::sgtree::bounded_range(const KeyType&,const KeyType&,KeyTypeKeyCompare,bool,bool)const
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
std::pair<const_iterator, const_iterator> bounded_range
|
||||
(const KeyType& lower_key, const KeyType& upper_key, KeyValueCompare comp, bool left_closed, bool right_closed) const;
|
||||
(const KeyType& lower_key, const KeyType& upper_key, KeyTypeKeyCompare comp, bool left_closed, bool right_closed) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::sgtree::s_iterator_to(reference)
|
||||
static iterator s_iterator_to(reference value);
|
||||
@@ -865,7 +896,7 @@ template<class T, class ...Options>
|
||||
#else
|
||||
template<class T, class O1 = void, class O2 = void
|
||||
, class O3 = void, class O4 = void
|
||||
, class O5 = void>
|
||||
, class O5 = void, class O6 = void>
|
||||
#endif
|
||||
struct make_sg_multiset
|
||||
{
|
||||
@@ -873,7 +904,7 @@ struct make_sg_multiset
|
||||
typedef typename pack_options
|
||||
< sgtree_defaults,
|
||||
#if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
|
||||
O1, O2, O3, O4, O5
|
||||
O1, O2, O3, O4, O5, O6
|
||||
#else
|
||||
Options...
|
||||
#endif
|
||||
@@ -884,6 +915,7 @@ struct make_sg_multiset
|
||||
|
||||
typedef sg_multiset_impl
|
||||
< value_traits
|
||||
, typename packed_options::key_of_value
|
||||
, typename packed_options::compare
|
||||
, typename packed_options::size_type
|
||||
, packed_options::floating_point
|
||||
@@ -896,14 +928,14 @@ struct make_sg_multiset
|
||||
#ifndef BOOST_INTRUSIVE_DOXYGEN_INVOKED
|
||||
|
||||
#if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
|
||||
template<class T, class O1, class O2, class O3, class O4, class O5>
|
||||
template<class T, class O1, class O2, class O3, class O4, class O5, class O6>
|
||||
#else
|
||||
template<class T, class ...Options>
|
||||
#endif
|
||||
class sg_multiset
|
||||
: public make_sg_multiset<T,
|
||||
#if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
|
||||
O1, O2, O3, O4, O5
|
||||
O1, O2, O3, O4, O5, O6
|
||||
#else
|
||||
Options...
|
||||
#endif
|
||||
@@ -911,7 +943,7 @@ class sg_multiset
|
||||
{
|
||||
typedef typename make_sg_multiset<T,
|
||||
#if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
|
||||
O1, O2, O3, O4, O5
|
||||
O1, O2, O3, O4, O5, O6
|
||||
#else
|
||||
Options...
|
||||
#endif
|
||||
@@ -920,7 +952,7 @@ class sg_multiset
|
||||
BOOST_MOVABLE_BUT_NOT_COPYABLE(sg_multiset)
|
||||
|
||||
public:
|
||||
typedef typename Base::value_compare value_compare;
|
||||
typedef typename Base::key_compare key_compare;
|
||||
typedef typename Base::value_traits value_traits;
|
||||
typedef typename Base::iterator iterator;
|
||||
typedef typename Base::const_iterator const_iterator;
|
||||
@@ -928,14 +960,14 @@ class sg_multiset
|
||||
//Assert if passed value traits are compatible with the type
|
||||
BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value));
|
||||
|
||||
sg_multiset( const value_compare &cmp = value_compare()
|
||||
sg_multiset( const key_compare &cmp = key_compare()
|
||||
, const value_traits &v_traits = value_traits())
|
||||
: Base(cmp, v_traits)
|
||||
{}
|
||||
|
||||
template<class Iterator>
|
||||
sg_multiset( Iterator b, Iterator e
|
||||
, const value_compare &cmp = value_compare()
|
||||
, const key_compare &cmp = key_compare()
|
||||
, const value_traits &v_traits = value_traits())
|
||||
: Base(b, e, cmp, v_traits)
|
||||
{}
|
||||
@@ -947,6 +979,14 @@ class sg_multiset
|
||||
sg_multiset& operator=(BOOST_RV_REF(sg_multiset) x)
|
||||
{ return static_cast<sg_multiset &>(this->Base::operator=(BOOST_MOVE_BASE(Base, x))); }
|
||||
|
||||
template <class Cloner, class Disposer>
|
||||
void clone_from(const sg_multiset &src, Cloner cloner, Disposer disposer)
|
||||
{ Base::clone_from(src, cloner, disposer); }
|
||||
|
||||
template <class Cloner, class Disposer>
|
||||
void clone_from(BOOST_RV_REF(sg_multiset) src, Cloner cloner, Disposer disposer)
|
||||
{ Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer); }
|
||||
|
||||
static sg_multiset &container_from_end_iterator(iterator end_iterator)
|
||||
{ return static_cast<sg_multiset &>(Base::container_from_end_iterator(end_iterator)); }
|
||||
|
||||
|
||||
+124
-115
@@ -195,13 +195,9 @@ struct alpha_holder<false, SizeType>
|
||||
} //namespace detail{
|
||||
|
||||
struct sgtree_defaults
|
||||
: bstree_defaults
|
||||
{
|
||||
typedef default_bstree_hook_applier proto_value_traits;
|
||||
static const bool constant_time_size = true;
|
||||
typedef std::size_t size_type;
|
||||
typedef void compare;
|
||||
static const bool floating_point = true;
|
||||
typedef void header_holder_type;
|
||||
};
|
||||
|
||||
/// @endcond
|
||||
@@ -222,18 +218,18 @@ struct sgtree_defaults
|
||||
#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED)
|
||||
template<class T, class ...Options>
|
||||
#else
|
||||
template<class ValueTraits, class VoidOrKeyComp, class SizeType, bool FloatingPoint, typename HeaderHolder>
|
||||
template<class ValueTraits, class VoidOrKeyOfValue, class VoidOrKeyComp, class SizeType, bool FloatingPoint, typename HeaderHolder>
|
||||
#endif
|
||||
class sgtree_impl
|
||||
/// @cond
|
||||
: public bstree_impl<ValueTraits, VoidOrKeyComp, SizeType, true, SgTreeAlgorithms, HeaderHolder>
|
||||
: public bstree_impl<ValueTraits, VoidOrKeyOfValue, VoidOrKeyComp, SizeType, true, SgTreeAlgorithms, HeaderHolder>
|
||||
, public detail::alpha_holder<FloatingPoint, SizeType>
|
||||
/// @endcond
|
||||
{
|
||||
public:
|
||||
typedef ValueTraits value_traits;
|
||||
/// @cond
|
||||
typedef bstree_impl< ValueTraits, VoidOrKeyComp, SizeType
|
||||
typedef bstree_impl< ValueTraits, VoidOrKeyOfValue, VoidOrKeyComp, SizeType
|
||||
, true, SgTreeAlgorithms, HeaderHolder> tree_type;
|
||||
typedef tree_type implementation_defined;
|
||||
|
||||
@@ -243,6 +239,7 @@ class sgtree_impl
|
||||
typedef typename implementation_defined::const_pointer const_pointer;
|
||||
typedef typename implementation_defined::value_type value_type;
|
||||
typedef typename implementation_defined::key_type key_type;
|
||||
typedef typename implementation_defined::key_of_value key_of_value;
|
||||
typedef typename implementation_defined::reference reference;
|
||||
typedef typename implementation_defined::const_reference const_reference;
|
||||
typedef typename implementation_defined::difference_type difference_type;
|
||||
@@ -284,16 +281,16 @@ class sgtree_impl
|
||||
|
||||
typedef BOOST_INTRUSIVE_IMPDEF(typename node_algorithms::insert_commit_data) insert_commit_data;
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::bstree(const value_compare &,const value_traits &)
|
||||
explicit sgtree_impl( const value_compare &cmp = value_compare()
|
||||
//! @copydoc ::boost::intrusive::bstree::bstree(const key_compare &,const value_traits &)
|
||||
explicit sgtree_impl( const key_compare &cmp = key_compare()
|
||||
, const value_traits &v_traits = value_traits())
|
||||
: tree_type(cmp, v_traits)
|
||||
{}
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::bstree(bool,Iterator,Iterator,const value_compare &,const value_traits &)
|
||||
//! @copydoc ::boost::intrusive::bstree::bstree(bool,Iterator,Iterator,const key_compare &,const value_traits &)
|
||||
template<class Iterator>
|
||||
sgtree_impl( bool unique, Iterator b, Iterator e
|
||||
, const value_compare &cmp = value_compare()
|
||||
, const key_compare &cmp = key_compare()
|
||||
, const value_traits &v_traits = value_traits())
|
||||
: tree_type(cmp, v_traits)
|
||||
{
|
||||
@@ -408,26 +405,33 @@ class sgtree_impl
|
||||
::boost::adl_move_swap(this->get_alpha_traits(), other.get_alpha_traits());
|
||||
}
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::clone_from
|
||||
//! @copydoc ::boost::intrusive::bstree::clone_from(const bstree&,Cloner,Disposer)
|
||||
//! Additional notes: it also copies the alpha factor from the source container.
|
||||
template <class Cloner, class Disposer>
|
||||
void clone_from(const sgtree_impl &src, Cloner cloner, Disposer disposer)
|
||||
{
|
||||
this->tree_type::clone_from(src, cloner, disposer);
|
||||
tree_type::clone_from(src, cloner, disposer);
|
||||
this->get_alpha_traits() = src.get_alpha_traits();
|
||||
}
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::clone_from(bstree&&,Cloner,Disposer)
|
||||
//! Additional notes: it also copies the alpha factor from the source container.
|
||||
template <class Cloner, class Disposer>
|
||||
void clone_from(BOOST_RV_REF(sgtree_impl) src, Cloner cloner, Disposer disposer)
|
||||
{
|
||||
tree_type::clone_from(BOOST_MOVE_BASE(tree_type, src), cloner, disposer);
|
||||
this->get_alpha_traits() = ::boost::move(src.get_alpha_traits());
|
||||
}
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::insert_equal(reference)
|
||||
iterator insert_equal(reference value)
|
||||
{
|
||||
detail::key_nodeptr_comp<value_compare, value_traits>
|
||||
key_node_comp(this->value_comp(), &this->get_value_traits());
|
||||
node_ptr to_insert(this->get_value_traits().to_node_ptr(value));
|
||||
if(safemode_or_autounlink)
|
||||
BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert));
|
||||
std::size_t max_tree_size = (std::size_t)this->max_tree_size_;
|
||||
node_ptr p = node_algorithms::insert_equal_upper_bound
|
||||
(this->tree_type::header_ptr(), to_insert, key_node_comp
|
||||
(this->tree_type::header_ptr(), to_insert, this->key_node_comp(this->key_comp())
|
||||
, (size_type)this->size(), this->get_h_alpha_func(), max_tree_size);
|
||||
this->tree_type::sz_traits().increment();
|
||||
this->max_tree_size_ = (size_type)max_tree_size;
|
||||
@@ -437,14 +441,12 @@ class sgtree_impl
|
||||
//! @copydoc ::boost::intrusive::bstree::insert_equal(const_iterator,reference)
|
||||
iterator insert_equal(const_iterator hint, reference value)
|
||||
{
|
||||
detail::key_nodeptr_comp<value_compare, value_traits>
|
||||
key_node_comp(this->value_comp(), &this->get_value_traits());
|
||||
node_ptr to_insert(this->get_value_traits().to_node_ptr(value));
|
||||
if(safemode_or_autounlink)
|
||||
BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert));
|
||||
std::size_t max_tree_size = (std::size_t)this->max_tree_size_;
|
||||
node_ptr p = node_algorithms::insert_equal
|
||||
(this->tree_type::header_ptr(), hint.pointed_node(), to_insert, key_node_comp
|
||||
( this->tree_type::header_ptr(), hint.pointed_node(), to_insert, this->key_node_comp(this->key_comp())
|
||||
, (std::size_t)this->size(), this->get_h_alpha_func(), max_tree_size);
|
||||
this->tree_type::sz_traits().increment();
|
||||
this->max_tree_size_ = (size_type)max_tree_size;
|
||||
@@ -464,46 +466,44 @@ class sgtree_impl
|
||||
std::pair<iterator, bool> insert_unique(reference value)
|
||||
{
|
||||
insert_commit_data commit_data;
|
||||
std::pair<iterator, bool> ret = insert_unique_check(value, this->value_comp(), commit_data);
|
||||
std::pair<iterator, bool> ret = this->insert_unique_check
|
||||
(key_of_value()(value), this->key_comp(), commit_data);
|
||||
if(!ret.second)
|
||||
return ret;
|
||||
return std::pair<iterator, bool> (insert_unique_commit(value, commit_data), true);
|
||||
return std::pair<iterator, bool> (this->insert_unique_commit(value, commit_data), true);
|
||||
}
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::insert_unique(const_iterator,reference)
|
||||
iterator insert_unique(const_iterator hint, reference value)
|
||||
{
|
||||
insert_commit_data commit_data;
|
||||
std::pair<iterator, bool> ret = insert_unique_check(hint, value, this->value_comp(), commit_data);
|
||||
std::pair<iterator, bool> ret = this->insert_unique_check
|
||||
(hint, key_of_value()(value), this->key_comp(), commit_data);
|
||||
if(!ret.second)
|
||||
return ret.first;
|
||||
return insert_unique_commit(value, commit_data);
|
||||
return this->insert_unique_commit(value, commit_data);
|
||||
}
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::insert_unique_check(const KeyType&,KeyValueCompare,insert_commit_data&)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
//! @copydoc ::boost::intrusive::bstree::insert_unique_check(const KeyType&,KeyTypeKeyCompare,insert_commit_data&)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
std::pair<iterator, bool> insert_unique_check
|
||||
(const KeyType &key, KeyValueCompare key_value_comp, insert_commit_data &commit_data)
|
||||
(const KeyType &key, KeyTypeKeyCompare comp, insert_commit_data &commit_data)
|
||||
{
|
||||
detail::key_nodeptr_comp<KeyValueCompare, value_traits>
|
||||
comp(key_value_comp, &this->get_value_traits());
|
||||
std::pair<node_ptr, bool> ret =
|
||||
(node_algorithms::insert_unique_check
|
||||
(this->tree_type::header_ptr(), key, comp, commit_data));
|
||||
node_algorithms::insert_unique_check
|
||||
(this->tree_type::header_ptr(), key, this->key_node_comp(comp), commit_data);
|
||||
return std::pair<iterator, bool>(iterator(ret.first, this->priv_value_traits_ptr()), ret.second);
|
||||
}
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::insert_unique_check(const_iterator,const KeyType&,KeyValueCompare,insert_commit_data&)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
//! @copydoc ::boost::intrusive::bstree::insert_unique_check(const_iterator,const KeyType&,KeyTypeKeyCompare,insert_commit_data&)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
std::pair<iterator, bool> insert_unique_check
|
||||
(const_iterator hint, const KeyType &key
|
||||
,KeyValueCompare key_value_comp, insert_commit_data &commit_data)
|
||||
,KeyTypeKeyCompare comp, insert_commit_data &commit_data)
|
||||
{
|
||||
detail::key_nodeptr_comp<KeyValueCompare, value_traits>
|
||||
comp(key_value_comp, &this->get_value_traits());
|
||||
std::pair<node_ptr, bool> ret =
|
||||
(node_algorithms::insert_unique_check
|
||||
(this->tree_type::header_ptr(), hint.pointed_node(), key, comp, commit_data));
|
||||
node_algorithms::insert_unique_check
|
||||
(this->tree_type::header_ptr(), hint.pointed_node(), key, this->key_node_comp(comp), commit_data);
|
||||
return std::pair<iterator, bool>(iterator(ret.first, this->priv_value_traits_ptr()), ret.second);
|
||||
}
|
||||
|
||||
@@ -604,15 +604,15 @@ class sgtree_impl
|
||||
iterator erase(const_iterator b, const_iterator e)
|
||||
{ size_type n; return private_erase(b, e, n); }
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::erase(const_reference)
|
||||
size_type erase(const_reference value)
|
||||
{ return this->erase(value, this->value_comp()); }
|
||||
//! @copydoc ::boost::intrusive::bstree::erase(const key_type &)
|
||||
size_type erase(const key_type &key)
|
||||
{ return this->erase(key, this->key_comp()); }
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::erase(const KeyType&,KeyValueCompare)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
//! @copydoc ::boost::intrusive::bstree::erase(const KeyType&,KeyTypeKeyCompare)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
BOOST_INTRUSIVE_DOC1ST(size_type
|
||||
, typename detail::disable_if_convertible<KeyValueCompare BOOST_INTRUSIVE_I const_iterator BOOST_INTRUSIVE_I size_type>::type)
|
||||
erase(const KeyType& key, KeyValueCompare comp)
|
||||
, typename detail::disable_if_convertible<KeyTypeKeyCompare BOOST_INTRUSIVE_I const_iterator BOOST_INTRUSIVE_I size_type>::type)
|
||||
erase(const KeyType& key, KeyTypeKeyCompare comp)
|
||||
{
|
||||
std::pair<iterator,iterator> p = this->equal_range(key, comp);
|
||||
size_type n;
|
||||
@@ -641,21 +641,21 @@ class sgtree_impl
|
||||
iterator erase_and_dispose(const_iterator b, const_iterator e, Disposer disposer)
|
||||
{ size_type n; return private_erase(b, e, n, disposer); }
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::erase_and_dispose(const_reference, Disposer)
|
||||
//! @copydoc ::boost::intrusive::bstree::erase_and_dispose(const key_type &, Disposer)
|
||||
template<class Disposer>
|
||||
size_type erase_and_dispose(const_reference value, Disposer disposer)
|
||||
size_type erase_and_dispose(const key_type &key, Disposer disposer)
|
||||
{
|
||||
std::pair<iterator,iterator> p = this->equal_range(value);
|
||||
std::pair<iterator,iterator> p = this->equal_range(key);
|
||||
size_type n;
|
||||
private_erase(p.first, p.second, n, disposer);
|
||||
return n;
|
||||
}
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::erase_and_dispose(const KeyType&,KeyValueCompare,Disposer)
|
||||
template<class KeyType, class KeyValueCompare, class Disposer>
|
||||
//! @copydoc ::boost::intrusive::bstree::erase_and_dispose(const KeyType&,KeyTypeKeyCompare,Disposer)
|
||||
template<class KeyType, class KeyTypeKeyCompare, class Disposer>
|
||||
BOOST_INTRUSIVE_DOC1ST(size_type
|
||||
, typename detail::disable_if_convertible<KeyValueCompare BOOST_INTRUSIVE_I const_iterator BOOST_INTRUSIVE_I size_type>::type)
|
||||
erase_and_dispose(const KeyType& key, KeyValueCompare comp, Disposer disposer)
|
||||
, typename detail::disable_if_convertible<KeyTypeKeyCompare BOOST_INTRUSIVE_I const_iterator BOOST_INTRUSIVE_I size_type>::type)
|
||||
erase_and_dispose(const KeyType& key, KeyTypeKeyCompare comp, Disposer disposer)
|
||||
{
|
||||
std::pair<iterator,iterator> p = this->equal_range(key, comp);
|
||||
size_type n;
|
||||
@@ -679,88 +679,88 @@ class sgtree_impl
|
||||
}
|
||||
|
||||
#ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
|
||||
//! @copydoc ::boost::intrusive::bstree::count(const_reference)const
|
||||
size_type count(const_reference value) const;
|
||||
//! @copydoc ::boost::intrusive::bstree::count(const key_type &)const
|
||||
size_type count(const key_type &key) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::count(const KeyType&,KeyValueCompare)const
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
size_type count(const KeyType& key, KeyValueCompare comp) const;
|
||||
//! @copydoc ::boost::intrusive::bstree::count(const KeyType&,KeyTypeKeyCompare)const
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
size_type count(const KeyType& key, KeyTypeKeyCompare comp) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::lower_bound(const_reference)
|
||||
iterator lower_bound(const_reference value);
|
||||
//! @copydoc ::boost::intrusive::bstree::lower_bound(const key_type &)
|
||||
iterator lower_bound(const key_type &key);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::lower_bound(const KeyType&,KeyValueCompare)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
iterator lower_bound(const KeyType& key, KeyValueCompare comp);
|
||||
//! @copydoc ::boost::intrusive::bstree::lower_bound(const KeyType&,KeyTypeKeyCompare)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
iterator lower_bound(const KeyType& key, KeyTypeKeyCompare comp);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::lower_bound(const_reference)const
|
||||
const_iterator lower_bound(const_reference value) const;
|
||||
//! @copydoc ::boost::intrusive::bstree::lower_bound(const key_type &)const
|
||||
const_iterator lower_bound(const key_type &key) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::lower_bound(const KeyType&,KeyValueCompare)const
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
const_iterator lower_bound(const KeyType& key, KeyValueCompare comp) const;
|
||||
//! @copydoc ::boost::intrusive::bstree::lower_bound(const KeyType&,KeyTypeKeyCompare)const
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
const_iterator lower_bound(const KeyType& key, KeyTypeKeyCompare comp) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::upper_bound(const_reference)
|
||||
iterator upper_bound(const_reference value);
|
||||
//! @copydoc ::boost::intrusive::bstree::upper_bound(const key_type &)
|
||||
iterator upper_bound(const key_type &key);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::upper_bound(const KeyType&,KeyValueCompare)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
iterator upper_bound(const KeyType& key, KeyValueCompare comp);
|
||||
//! @copydoc ::boost::intrusive::bstree::upper_bound(const KeyType&,KeyTypeKeyCompare)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
iterator upper_bound(const KeyType& key, KeyTypeKeyCompare comp);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::upper_bound(const_reference)const
|
||||
const_iterator upper_bound(const_reference value) const;
|
||||
//! @copydoc ::boost::intrusive::bstree::upper_bound(const key_type &)const
|
||||
const_iterator upper_bound(const key_type &key) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::upper_bound(const KeyType&,KeyValueCompare)const
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
const_iterator upper_bound(const KeyType& key, KeyValueCompare comp) const;
|
||||
//! @copydoc ::boost::intrusive::bstree::upper_bound(const KeyType&,KeyTypeKeyCompare)const
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
const_iterator upper_bound(const KeyType& key, KeyTypeKeyCompare comp) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::find(const_reference)
|
||||
iterator find(const_reference value);
|
||||
//! @copydoc ::boost::intrusive::bstree::find(const key_type &)
|
||||
iterator find(const key_type &key);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::find(const KeyType&,KeyValueCompare)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
iterator find(const KeyType& key, KeyValueCompare comp);
|
||||
//! @copydoc ::boost::intrusive::bstree::find(const KeyType&,KeyTypeKeyCompare)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
iterator find(const KeyType& key, KeyTypeKeyCompare comp);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::find(const_reference)const
|
||||
const_iterator find(const_reference value) const;
|
||||
//! @copydoc ::boost::intrusive::bstree::find(const key_type &)const
|
||||
const_iterator find(const key_type &key) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::find(const KeyType&,KeyValueCompare)const
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
const_iterator find(const KeyType& key, KeyValueCompare comp) const;
|
||||
//! @copydoc ::boost::intrusive::bstree::find(const KeyType&,KeyTypeKeyCompare)const
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
const_iterator find(const KeyType& key, KeyTypeKeyCompare comp) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::equal_range(const_reference)
|
||||
std::pair<iterator,iterator> equal_range(const_reference value);
|
||||
//! @copydoc ::boost::intrusive::bstree::equal_range(const key_type &)
|
||||
std::pair<iterator,iterator> equal_range(const key_type &key);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::equal_range(const KeyType&,KeyValueCompare)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
std::pair<iterator,iterator> equal_range(const KeyType& key, KeyValueCompare comp);
|
||||
//! @copydoc ::boost::intrusive::bstree::equal_range(const KeyType&,KeyTypeKeyCompare)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
std::pair<iterator,iterator> equal_range(const KeyType& key, KeyTypeKeyCompare comp);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::equal_range(const_reference)const
|
||||
//! @copydoc ::boost::intrusive::bstree::equal_range(const key_type &)const
|
||||
std::pair<const_iterator, const_iterator>
|
||||
equal_range(const_reference value) const;
|
||||
equal_range(const key_type &key) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::equal_range(const KeyType&,KeyValueCompare)const
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
//! @copydoc ::boost::intrusive::bstree::equal_range(const KeyType&,KeyTypeKeyCompare)const
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
std::pair<const_iterator, const_iterator>
|
||||
equal_range(const KeyType& key, KeyValueCompare comp) const;
|
||||
equal_range(const KeyType& key, KeyTypeKeyCompare comp) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::bounded_range(const_reference,const_reference,bool,bool)
|
||||
//! @copydoc ::boost::intrusive::bstree::bounded_range(const key_type &,const key_type &,bool,bool)
|
||||
std::pair<iterator,iterator> bounded_range
|
||||
(const_reference lower_value, const_reference upper_value, bool left_closed, bool right_closed);
|
||||
(const key_type &lower_key, const key_type &upper_key, bool left_closed, bool right_closed);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::bounded_range(const KeyType&,const KeyType&,KeyValueCompare,bool,bool)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
//! @copydoc ::boost::intrusive::bstree::bounded_range(const KeyType&,const KeyType&,KeyTypeKeyCompare,bool,bool)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
std::pair<iterator,iterator> bounded_range
|
||||
(const KeyType& lower_key, const KeyType& upper_key, KeyValueCompare comp, bool left_closed, bool right_closed);
|
||||
(const KeyType& lower_key, const KeyType& upper_key, KeyTypeKeyCompare comp, bool left_closed, bool right_closed);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::bounded_range(const_reference,const_reference,bool,bool)const
|
||||
//! @copydoc ::boost::intrusive::bstree::bounded_range(const key_type &,const key_type &,bool,bool)const
|
||||
std::pair<const_iterator, const_iterator>
|
||||
bounded_range(const_reference lower_value, const_reference upper_value, bool left_closed, bool right_closed) const;
|
||||
bounded_range(const key_type &lower_key, const key_type &upper_key, bool left_closed, bool right_closed) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::bounded_range(const KeyType&,const KeyType&,KeyValueCompare,bool,bool)const
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
//! @copydoc ::boost::intrusive::bstree::bounded_range(const KeyType&,const KeyType&,KeyTypeKeyCompare,bool,bool)const
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
std::pair<const_iterator, const_iterator> bounded_range
|
||||
(const KeyType& lower_key, const KeyType& upper_key, KeyValueCompare comp, bool left_closed, bool right_closed) const;
|
||||
(const KeyType& lower_key, const KeyType& upper_key, KeyTypeKeyCompare comp, bool left_closed, bool right_closed) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::s_iterator_to(reference)
|
||||
static iterator s_iterator_to(reference value);
|
||||
@@ -868,7 +868,7 @@ template<class T, class ...Options>
|
||||
#else
|
||||
template<class T, class O1 = void, class O2 = void
|
||||
, class O3 = void, class O4 = void
|
||||
, class O5 = void>
|
||||
, class O5 = void, class O6 = void>
|
||||
#endif
|
||||
struct make_sgtree
|
||||
{
|
||||
@@ -876,7 +876,7 @@ struct make_sgtree
|
||||
typedef typename pack_options
|
||||
< sgtree_defaults,
|
||||
#if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
|
||||
O1, O2, O3, O4, O5
|
||||
O1, O2, O3, O4, O5, O6
|
||||
#else
|
||||
Options...
|
||||
#endif
|
||||
@@ -887,6 +887,7 @@ struct make_sgtree
|
||||
|
||||
typedef sgtree_impl
|
||||
< value_traits
|
||||
, typename packed_options::key_of_value
|
||||
, typename packed_options::compare
|
||||
, typename packed_options::size_type
|
||||
, packed_options::floating_point
|
||||
@@ -900,14 +901,14 @@ struct make_sgtree
|
||||
#ifndef BOOST_INTRUSIVE_DOXYGEN_INVOKED
|
||||
|
||||
#if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
|
||||
template<class T, class O1, class O2, class O3, class O4, class O5>
|
||||
template<class T, class O1, class O2, class O3, class O4, class O5, class O6>
|
||||
#else
|
||||
template<class T, class ...Options>
|
||||
#endif
|
||||
class sgtree
|
||||
: public make_sgtree<T,
|
||||
#if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
|
||||
O1, O2, O3, O4, O5
|
||||
O1, O2, O3, O4, O5, O6
|
||||
#else
|
||||
Options...
|
||||
#endif
|
||||
@@ -916,7 +917,7 @@ class sgtree
|
||||
typedef typename make_sgtree
|
||||
<T,
|
||||
#if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
|
||||
O1, O2, O3, O4, O5
|
||||
O1, O2, O3, O4, O5, O6
|
||||
#else
|
||||
Options...
|
||||
#endif
|
||||
@@ -924,7 +925,7 @@ class sgtree
|
||||
BOOST_MOVABLE_BUT_NOT_COPYABLE(sgtree)
|
||||
|
||||
public:
|
||||
typedef typename Base::value_compare value_compare;
|
||||
typedef typename Base::key_compare key_compare;
|
||||
typedef typename Base::value_traits value_traits;
|
||||
typedef typename Base::iterator iterator;
|
||||
typedef typename Base::const_iterator const_iterator;
|
||||
@@ -934,14 +935,14 @@ class sgtree
|
||||
//Assert if passed value traits are compatible with the type
|
||||
BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value));
|
||||
|
||||
explicit sgtree( const value_compare &cmp = value_compare()
|
||||
explicit sgtree( const key_compare &cmp = key_compare()
|
||||
, const value_traits &v_traits = value_traits())
|
||||
: Base(cmp, v_traits)
|
||||
{}
|
||||
|
||||
template<class Iterator>
|
||||
sgtree( bool unique, Iterator b, Iterator e
|
||||
, const value_compare &cmp = value_compare()
|
||||
, const key_compare &cmp = key_compare()
|
||||
, const value_traits &v_traits = value_traits())
|
||||
: Base(unique, b, e, cmp, v_traits)
|
||||
{}
|
||||
@@ -953,6 +954,14 @@ class sgtree
|
||||
sgtree& operator=(BOOST_RV_REF(sgtree) x)
|
||||
{ return static_cast<sgtree &>(this->Base::operator=(BOOST_MOVE_BASE(Base, x))); }
|
||||
|
||||
template <class Cloner, class Disposer>
|
||||
void clone_from(const sgtree &src, Cloner cloner, Disposer disposer)
|
||||
{ Base::clone_from(src, cloner, disposer); }
|
||||
|
||||
template <class Cloner, class Disposer>
|
||||
void clone_from(BOOST_RV_REF(sgtree) src, Cloner cloner, Disposer disposer)
|
||||
{ Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer); }
|
||||
|
||||
static sgtree &container_from_end_iterator(iterator end_iterator)
|
||||
{ return static_cast<sgtree &>(Base::container_from_end_iterator(end_iterator)); }
|
||||
|
||||
|
||||
@@ -416,8 +416,7 @@ class slist_impl
|
||||
void push_front(reference value)
|
||||
{
|
||||
node_ptr to_insert = priv_value_traits().to_node_ptr(value);
|
||||
if(safemode_or_autounlink)
|
||||
BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::inited(to_insert));
|
||||
BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(!safemode_or_autounlink || node_algorithms::inited(to_insert));
|
||||
if(cache_last){
|
||||
if(this->empty()){
|
||||
this->set_last_node(to_insert);
|
||||
@@ -442,8 +441,7 @@ class slist_impl
|
||||
{
|
||||
BOOST_STATIC_ASSERT((cache_last));
|
||||
node_ptr n = priv_value_traits().to_node_ptr(value);
|
||||
if(safemode_or_autounlink)
|
||||
BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::inited(n));
|
||||
BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(!safemode_or_autounlink || node_algorithms::inited(n));
|
||||
node_algorithms::link_after(this->get_last_node(), n);
|
||||
if(cache_last){
|
||||
this->set_last_node(n);
|
||||
@@ -768,6 +766,34 @@ class slist_impl
|
||||
rollback.release();
|
||||
}
|
||||
|
||||
//! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw.
|
||||
//! Cloner should yield to nodes equivalent to the original nodes.
|
||||
//!
|
||||
//! <b>Effects</b>: Erases all the elements from *this
|
||||
//! calling Disposer::operator()(pointer), clones all the
|
||||
//! elements from src calling Cloner::operator()(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.
|
||||
template <class Cloner, class Disposer>
|
||||
void clone_from(BOOST_RV_REF(slist_impl) src, Cloner cloner, Disposer disposer)
|
||||
{
|
||||
this->clear_and_dispose(disposer);
|
||||
detail::exception_disposer<slist_impl, Disposer>
|
||||
rollback(*this, disposer);
|
||||
iterator prev(this->cbefore_begin());
|
||||
iterator b(src.begin()), e(src.end());
|
||||
for(; b != e; ++b){
|
||||
prev = this->insert_after(prev, *cloner(*b));
|
||||
}
|
||||
rollback.release();
|
||||
}
|
||||
|
||||
//! <b>Requires</b>: value must be an lvalue and prev_p must point to an element
|
||||
//! contained by the list or to end().
|
||||
//!
|
||||
@@ -784,8 +810,7 @@ class slist_impl
|
||||
iterator insert_after(const_iterator prev_p, reference value)
|
||||
{
|
||||
node_ptr n = priv_value_traits().to_node_ptr(value);
|
||||
if(safemode_or_autounlink)
|
||||
BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::inited(n));
|
||||
BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(!safemode_or_autounlink || node_algorithms::inited(n));
|
||||
node_ptr prev_n(prev_p.pointed_node());
|
||||
node_algorithms::link_after(prev_n, n);
|
||||
if(cache_last && (this->get_last_node() == prev_n)){
|
||||
@@ -815,8 +840,7 @@ class slist_impl
|
||||
node_ptr prev_n(prev_p.pointed_node());
|
||||
for (; f != l; ++f, ++count){
|
||||
const node_ptr n = priv_value_traits().to_node_ptr(*f);
|
||||
if(safemode_or_autounlink)
|
||||
BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::inited(n));
|
||||
BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(!safemode_or_autounlink || node_algorithms::inited(n));
|
||||
node_algorithms::link_after(prev_n, n);
|
||||
prev_n = n;
|
||||
}
|
||||
@@ -1028,6 +1052,15 @@ class slist_impl
|
||||
|
||||
/// @cond
|
||||
|
||||
static iterator s_insert_after(const_iterator const prev_p, reference value)
|
||||
{
|
||||
BOOST_STATIC_ASSERT(((!cache_last)&&(!constant_time_size)&&(!stateful_value_traits)));
|
||||
node_ptr const n = value_traits::to_node_ptr(value);
|
||||
BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(!safemode_or_autounlink || node_algorithms::inited(n));
|
||||
node_algorithms::link_after(prev_p.pointed_node(), n);
|
||||
return iterator (n, const_value_traits_ptr());
|
||||
}
|
||||
|
||||
template<class Disposer>
|
||||
static iterator s_erase_after_and_dispose(const_iterator prev, Disposer disposer)
|
||||
{
|
||||
@@ -1044,6 +1077,23 @@ class slist_impl
|
||||
return it.unconst();
|
||||
}
|
||||
|
||||
template<class Disposer>
|
||||
static iterator s_erase_after_and_dispose(const_iterator before_f, const_iterator l, Disposer disposer)
|
||||
{
|
||||
BOOST_STATIC_ASSERT(((!cache_last)&&(!constant_time_size)&&(!stateful_value_traits)));
|
||||
node_ptr bfp(before_f.pointed_node()), lp(l.pointed_node());
|
||||
node_ptr fp(node_traits::get_next(bfp));
|
||||
node_algorithms::unlink_after(bfp, lp);
|
||||
while(fp != lp){
|
||||
node_ptr to_erase(fp);
|
||||
fp = node_traits::get_next(fp);
|
||||
if(safemode_or_autounlink)
|
||||
node_algorithms::init(to_erase);
|
||||
disposer(value_traits::to_value_ptr(to_erase));
|
||||
}
|
||||
return l.unconst();
|
||||
}
|
||||
|
||||
static iterator s_erase_after(const_iterator prev)
|
||||
{ return s_erase_after_and_dispose(prev, detail::null_disposer()); }
|
||||
|
||||
@@ -2163,6 +2213,14 @@ class slist
|
||||
slist& operator=(BOOST_RV_REF(slist) x)
|
||||
{ return static_cast<slist &>(this->Base::operator=(BOOST_MOVE_BASE(Base, x))); }
|
||||
|
||||
template <class Cloner, class Disposer>
|
||||
void clone_from(const slist &src, Cloner cloner, Disposer disposer)
|
||||
{ Base::clone_from(src, cloner, disposer); }
|
||||
|
||||
template <class Cloner, class Disposer>
|
||||
void clone_from(BOOST_RV_REF(slist) src, Cloner cloner, Disposer disposer)
|
||||
{ Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer); }
|
||||
|
||||
static slist &container_from_end_iterator(iterator end_iterator)
|
||||
{ return static_cast<slist &>(Base::container_from_end_iterator(end_iterator)); }
|
||||
|
||||
|
||||
@@ -40,15 +40,15 @@ namespace intrusive {
|
||||
#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED)
|
||||
template<class T, class ...Options>
|
||||
#else
|
||||
template<class ValueTraits, class Compare, class SizeType, bool ConstantTimeSize, typename HeaderHolder>
|
||||
template<class ValueTraits, class VoidOrKeyOfValue, class Compare, class SizeType, bool ConstantTimeSize, typename HeaderHolder>
|
||||
#endif
|
||||
class splay_set_impl
|
||||
#ifndef BOOST_INTRUSIVE_DOXYGEN_INVOKED
|
||||
: public splaytree_impl<ValueTraits, Compare, SizeType, ConstantTimeSize, HeaderHolder>
|
||||
: public splaytree_impl<ValueTraits, VoidOrKeyOfValue, Compare, SizeType, ConstantTimeSize, HeaderHolder>
|
||||
#endif
|
||||
{
|
||||
/// @cond
|
||||
typedef splaytree_impl<ValueTraits, Compare, SizeType, ConstantTimeSize, HeaderHolder> tree_type;
|
||||
typedef splaytree_impl<ValueTraits, VoidOrKeyOfValue, Compare, SizeType, ConstantTimeSize, HeaderHolder> tree_type;
|
||||
BOOST_MOVABLE_BUT_NOT_COPYABLE(splay_set_impl)
|
||||
|
||||
typedef tree_type implementation_defined;
|
||||
@@ -56,6 +56,8 @@ class splay_set_impl
|
||||
|
||||
public:
|
||||
typedef typename implementation_defined::value_type value_type;
|
||||
typedef typename implementation_defined::key_type key_type;
|
||||
typedef typename implementation_defined::key_of_value key_of_value;
|
||||
typedef typename implementation_defined::value_traits value_traits;
|
||||
typedef typename implementation_defined::pointer pointer;
|
||||
typedef typename implementation_defined::const_pointer const_pointer;
|
||||
@@ -79,16 +81,16 @@ class splay_set_impl
|
||||
static const bool constant_time_size = tree_type::constant_time_size;
|
||||
|
||||
public:
|
||||
//! @copydoc ::boost::intrusive::splaytree::splaytree(const value_compare &,const value_traits &)
|
||||
explicit splay_set_impl( const value_compare &cmp = value_compare()
|
||||
//! @copydoc ::boost::intrusive::splaytree::splaytree(const key_compare &,const value_traits &)
|
||||
explicit splay_set_impl( const key_compare &cmp = key_compare()
|
||||
, const value_traits &v_traits = value_traits())
|
||||
: tree_type(cmp, v_traits)
|
||||
{}
|
||||
|
||||
//! @copydoc ::boost::intrusive::splaytree::splaytree(bool,Iterator,Iterator,const value_compare &,const value_traits &)
|
||||
//! @copydoc ::boost::intrusive::splaytree::splaytree(bool,Iterator,Iterator,const key_compare &,const value_traits &)
|
||||
template<class Iterator>
|
||||
splay_set_impl( Iterator b, Iterator e
|
||||
, const value_compare &cmp = value_compare()
|
||||
, const key_compare &cmp = key_compare()
|
||||
, const value_traits &v_traits = value_traits())
|
||||
: tree_type(true, b, e, cmp, v_traits)
|
||||
{}
|
||||
@@ -169,11 +171,20 @@ class splay_set_impl
|
||||
//! @copydoc ::boost::intrusive::splaytree::swap
|
||||
void swap(splay_set_impl& other);
|
||||
|
||||
//! @copydoc ::boost::intrusive::splaytree::clone_from
|
||||
//! @copydoc ::boost::intrusive::splaytree::clone_from(const splaytree&,Cloner,Disposer)
|
||||
template <class Cloner, class Disposer>
|
||||
void clone_from(const splay_set_impl &src, Cloner cloner, Disposer disposer);
|
||||
|
||||
#endif //#ifdef BOOST_iNTRUSIVE_DOXYGEN_INVOKED
|
||||
#else
|
||||
|
||||
using tree_type::clone_from;
|
||||
|
||||
#endif //#ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
|
||||
|
||||
//! @copydoc ::boost::intrusive::splaytree::clone_from(splaytree&&,Cloner,Disposer)
|
||||
template <class Cloner, class Disposer>
|
||||
void clone_from(BOOST_RV_REF(splay_set_impl) src, Cloner cloner, Disposer disposer)
|
||||
{ tree_type::clone_from(BOOST_MOVE_BASE(tree_type, src), cloner, disposer); }
|
||||
|
||||
//! @copydoc ::boost::intrusive::splaytree::insert_unique(reference)
|
||||
std::pair<iterator, bool> insert(reference value)
|
||||
@@ -183,18 +194,18 @@ class splay_set_impl
|
||||
iterator insert(const_iterator hint, reference value)
|
||||
{ return tree_type::insert_unique(hint, value); }
|
||||
|
||||
//! @copydoc ::boost::intrusive::splaytree::insert_unique_check(const KeyType&,KeyValueCompare,insert_commit_data&)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
//! @copydoc ::boost::intrusive::splaytree::insert_unique_check(const KeyType&,KeyTypeKeyCompare,insert_commit_data&)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
std::pair<iterator, bool> insert_check
|
||||
(const KeyType &key, KeyValueCompare key_value_comp, insert_commit_data &commit_data)
|
||||
{ return tree_type::insert_unique_check(key, key_value_comp, commit_data); }
|
||||
(const KeyType &key, KeyTypeKeyCompare comp, insert_commit_data &commit_data)
|
||||
{ return tree_type::insert_unique_check(key, comp, commit_data); }
|
||||
|
||||
//! @copydoc ::boost::intrusive::splaytree::insert_unique_check(const_iterator,const KeyType&,KeyValueCompare,insert_commit_data&)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
//! @copydoc ::boost::intrusive::splaytree::insert_unique_check(const_iterator,const KeyType&,KeyTypeKeyCompare,insert_commit_data&)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
std::pair<iterator, bool> insert_check
|
||||
(const_iterator hint, const KeyType &key
|
||||
,KeyValueCompare key_value_comp, insert_commit_data &commit_data)
|
||||
{ return tree_type::insert_unique_check(hint, key, key_value_comp, commit_data); }
|
||||
,KeyTypeKeyCompare comp, insert_commit_data &commit_data)
|
||||
{ return tree_type::insert_unique_check(hint, key, comp, commit_data); }
|
||||
|
||||
//! @copydoc ::boost::intrusive::splaytree::insert_unique(Iterator,Iterator)
|
||||
template<class Iterator>
|
||||
@@ -221,12 +232,12 @@ class splay_set_impl
|
||||
//! @copydoc ::boost::intrusive::splaytree::erase(const_iterator,const_iterator)
|
||||
iterator erase(const_iterator b, const_iterator e);
|
||||
|
||||
//! @copydoc ::boost::intrusive::splaytree::erase(const_reference)
|
||||
size_type erase(const_reference value);
|
||||
//! @copydoc ::boost::intrusive::splaytree::erase(const key_type &)
|
||||
size_type erase(const key_type &key);
|
||||
|
||||
//! @copydoc ::boost::intrusive::splaytree::erase(const KeyType&,KeyValueCompare)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
size_type erase(const KeyType& key, KeyValueCompare comp);
|
||||
//! @copydoc ::boost::intrusive::splaytree::erase(const KeyType&,KeyTypeKeyCompare)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
size_type erase(const KeyType& key, KeyTypeKeyCompare comp);
|
||||
|
||||
//! @copydoc ::boost::intrusive::splaytree::erase_and_dispose(const_iterator,Disposer)
|
||||
template<class Disposer>
|
||||
@@ -236,13 +247,13 @@ class splay_set_impl
|
||||
template<class Disposer>
|
||||
iterator erase_and_dispose(const_iterator b, const_iterator e, Disposer disposer);
|
||||
|
||||
//! @copydoc ::boost::intrusive::splaytree::erase_and_dispose(const_reference, Disposer)
|
||||
//! @copydoc ::boost::intrusive::splaytree::erase_and_dispose(const key_type &, Disposer)
|
||||
template<class Disposer>
|
||||
size_type erase_and_dispose(const_reference value, Disposer disposer);
|
||||
size_type erase_and_dispose(const key_type &key, Disposer disposer);
|
||||
|
||||
//! @copydoc ::boost::intrusive::splaytree::erase_and_dispose(const KeyType&,KeyValueCompare,Disposer)
|
||||
template<class KeyType, class KeyValueCompare, class Disposer>
|
||||
size_type erase_and_dispose(const KeyType& key, KeyValueCompare comp, Disposer disposer);
|
||||
//! @copydoc ::boost::intrusive::splaytree::erase_and_dispose(const KeyType&,KeyTypeKeyCompare,Disposer)
|
||||
template<class KeyType, class KeyTypeKeyCompare, class Disposer>
|
||||
size_type erase_and_dispose(const KeyType& key, KeyTypeKeyCompare comp, Disposer disposer);
|
||||
|
||||
//! @copydoc ::boost::intrusive::splaytree::clear
|
||||
void clear();
|
||||
@@ -253,107 +264,107 @@ class splay_set_impl
|
||||
|
||||
#endif // #ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
|
||||
|
||||
//! @copydoc ::boost::intrusive::splaytree::count(const_reference)const
|
||||
size_type count(const_reference value) const
|
||||
{ return static_cast<size_type>(this->tree_type::find(value) != this->tree_type::cend()); }
|
||||
//! @copydoc ::boost::intrusive::splaytree::count(const key_type &)const
|
||||
size_type count(const key_type &key) const
|
||||
{ return static_cast<size_type>(this->tree_type::find(key) != this->tree_type::cend()); }
|
||||
|
||||
//! @copydoc ::boost::intrusive::splaytree::count(const KeyType&,KeyValueCompare)const
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
size_type count(const KeyType& key, KeyValueCompare comp) const
|
||||
//! @copydoc ::boost::intrusive::splaytree::count(const KeyType&,KeyTypeKeyCompare)const
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
size_type count(const KeyType& key, KeyTypeKeyCompare comp) const
|
||||
{ return static_cast<size_type>(this->tree_type::find(key, comp) != this->tree_type::cend()); }
|
||||
|
||||
#ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
|
||||
|
||||
//! @copydoc ::boost::intrusive::splaytree::count(const_reference)const
|
||||
size_type count(const_reference value) const;
|
||||
//! @copydoc ::boost::intrusive::splaytree::count(const key_type &)const
|
||||
size_type count(const key_type &key) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::splaytree::count(const KeyType&,KeyValueCompare)const
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
size_type count(const KeyType& key, KeyValueCompare comp) const;
|
||||
//! @copydoc ::boost::intrusive::splaytree::count(const KeyType&,KeyTypeKeyCompare)const
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
size_type count(const KeyType& key, KeyTypeKeyCompare comp) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::splaytree::lower_bound(const_reference)
|
||||
iterator lower_bound(const_reference value);
|
||||
//! @copydoc ::boost::intrusive::splaytree::lower_bound(const key_type &)
|
||||
iterator lower_bound(const key_type &key);
|
||||
|
||||
//! @copydoc ::boost::intrusive::splaytree::lower_bound(const KeyType&,KeyValueCompare)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
iterator lower_bound(const KeyType& key, KeyValueCompare comp);
|
||||
//! @copydoc ::boost::intrusive::splaytree::lower_bound(const KeyType&,KeyTypeKeyCompare)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
iterator lower_bound(const KeyType& key, KeyTypeKeyCompare comp);
|
||||
|
||||
//! @copydoc ::boost::intrusive::splaytree::lower_bound(const_reference)const
|
||||
const_iterator lower_bound(const_reference value) const;
|
||||
//! @copydoc ::boost::intrusive::splaytree::lower_bound(const key_type &)const
|
||||
const_iterator lower_bound(const key_type &key) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::splaytree::lower_bound(const KeyType&,KeyValueCompare)const
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
const_iterator lower_bound(const KeyType& key, KeyValueCompare comp) const;
|
||||
//! @copydoc ::boost::intrusive::splaytree::lower_bound(const KeyType&,KeyTypeKeyCompare)const
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
const_iterator lower_bound(const KeyType& key, KeyTypeKeyCompare comp) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::splaytree::upper_bound(const_reference)
|
||||
iterator upper_bound(const_reference value);
|
||||
//! @copydoc ::boost::intrusive::splaytree::upper_bound(const key_type &)
|
||||
iterator upper_bound(const key_type &key);
|
||||
|
||||
//! @copydoc ::boost::intrusive::splaytree::upper_bound(const KeyType&,KeyValueCompare)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
iterator upper_bound(const KeyType& key, KeyValueCompare comp);
|
||||
//! @copydoc ::boost::intrusive::splaytree::upper_bound(const KeyType&,KeyTypeKeyCompare)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
iterator upper_bound(const KeyType& key, KeyTypeKeyCompare comp);
|
||||
|
||||
//! @copydoc ::boost::intrusive::splaytree::upper_bound(const_reference)const
|
||||
const_iterator upper_bound(const_reference value) const;
|
||||
//! @copydoc ::boost::intrusive::splaytree::upper_bound(const key_type &)const
|
||||
const_iterator upper_bound(const key_type &key) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::splaytree::upper_bound(const KeyType&,KeyValueCompare)const
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
const_iterator upper_bound(const KeyType& key, KeyValueCompare comp) const;
|
||||
//! @copydoc ::boost::intrusive::splaytree::upper_bound(const KeyType&,KeyTypeKeyCompare)const
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
const_iterator upper_bound(const KeyType& key, KeyTypeKeyCompare comp) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::splaytree::find(const_reference)
|
||||
iterator find(const_reference value);
|
||||
//! @copydoc ::boost::intrusive::splaytree::find(const key_type &)
|
||||
iterator find(const key_type &key);
|
||||
|
||||
//! @copydoc ::boost::intrusive::splaytree::find(const KeyType&,KeyValueCompare)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
iterator find(const KeyType& key, KeyValueCompare comp);
|
||||
//! @copydoc ::boost::intrusive::splaytree::find(const KeyType&,KeyTypeKeyCompare)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
iterator find(const KeyType& key, KeyTypeKeyCompare comp);
|
||||
|
||||
//! @copydoc ::boost::intrusive::splaytree::find(const_reference)const
|
||||
const_iterator find(const_reference value) const;
|
||||
//! @copydoc ::boost::intrusive::splaytree::find(const key_type &)const
|
||||
const_iterator find(const key_type &key) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::splaytree::find(const KeyType&,KeyValueCompare)const
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
const_iterator find(const KeyType& key, KeyValueCompare comp) const;
|
||||
//! @copydoc ::boost::intrusive::splaytree::find(const KeyType&,KeyTypeKeyCompare)const
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
const_iterator find(const KeyType& key, KeyTypeKeyCompare comp) const;
|
||||
|
||||
#endif // #ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
|
||||
|
||||
//! @copydoc ::boost::intrusive::rbtree::equal_range(const_reference)
|
||||
std::pair<iterator,iterator> equal_range(const_reference value)
|
||||
{ return this->tree_type::lower_bound_range(value); }
|
||||
//! @copydoc ::boost::intrusive::rbtree::equal_range(const key_type &)
|
||||
std::pair<iterator,iterator> equal_range(const key_type &key)
|
||||
{ return this->tree_type::lower_bound_range(key); }
|
||||
|
||||
//! @copydoc ::boost::intrusive::rbtree::equal_range(const KeyType&,KeyValueCompare)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
std::pair<iterator,iterator> equal_range(const KeyType& key, KeyValueCompare comp)
|
||||
//! @copydoc ::boost::intrusive::rbtree::equal_range(const KeyType&,KeyTypeKeyCompare)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
std::pair<iterator,iterator> equal_range(const KeyType& key, KeyTypeKeyCompare comp)
|
||||
{ return this->tree_type::lower_bound_range(key, comp); }
|
||||
|
||||
//! @copydoc ::boost::intrusive::rbtree::equal_range(const_reference)const
|
||||
//! @copydoc ::boost::intrusive::rbtree::equal_range(const key_type &)const
|
||||
std::pair<const_iterator, const_iterator>
|
||||
equal_range(const_reference value) const
|
||||
{ return this->tree_type::lower_bound_range(value); }
|
||||
equal_range(const key_type &key) const
|
||||
{ return this->tree_type::lower_bound_range(key); }
|
||||
|
||||
//! @copydoc ::boost::intrusive::rbtree::equal_range(const KeyType&,KeyValueCompare)const
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
//! @copydoc ::boost::intrusive::rbtree::equal_range(const KeyType&,KeyTypeKeyCompare)const
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
std::pair<const_iterator, const_iterator>
|
||||
equal_range(const KeyType& key, KeyValueCompare comp) const
|
||||
equal_range(const KeyType& key, KeyTypeKeyCompare comp) const
|
||||
{ return this->tree_type::lower_bound_range(key, comp); }
|
||||
|
||||
#ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
|
||||
|
||||
//! @copydoc ::boost::intrusive::splaytree::bounded_range(const_reference,const_reference,bool,bool)
|
||||
//! @copydoc ::boost::intrusive::splaytree::bounded_range(const key_type&,const key_type&,bool,bool)
|
||||
std::pair<iterator,iterator> bounded_range
|
||||
(const_reference lower_value, const_reference upper_value, bool left_closed, bool right_closed);
|
||||
(const key_type &lower_key, const key_type &upper_key, bool left_closed, bool right_closed);
|
||||
|
||||
//! @copydoc ::boost::intrusive::splaytree::bounded_range(const KeyType&,const KeyType&,KeyValueCompare,bool,bool)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
//! @copydoc ::boost::intrusive::splaytree::bounded_range(const KeyType&,const KeyType&,KeyTypeKeyCompare,bool,bool)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
std::pair<iterator,iterator> bounded_range
|
||||
(const KeyType& lower_key, const KeyType& upper_key, KeyValueCompare comp, bool left_closed, bool right_closed);
|
||||
(const KeyType& lower_key, const KeyType& upper_key, KeyTypeKeyCompare comp, bool left_closed, bool right_closed);
|
||||
|
||||
//! @copydoc ::boost::intrusive::splaytree::bounded_range(const_reference,const_reference,bool,bool)const
|
||||
//! @copydoc ::boost::intrusive::splaytree::bounded_range(const key_type&,const key_type&,bool,bool)const
|
||||
std::pair<const_iterator, const_iterator> bounded_range
|
||||
(const_reference lower_value, const_reference upper_value, bool left_closed, bool right_closed) const;
|
||||
(const key_type &lower_key, const key_type &upper_key, bool left_closed, bool right_closed) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::splaytree::bounded_range(const KeyType&,const KeyType&,KeyValueCompare,bool,bool)const
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
//! @copydoc ::boost::intrusive::splaytree::bounded_range(const KeyType&,const KeyType&,KeyTypeKeyCompare,bool,bool)const
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
std::pair<const_iterator, const_iterator> bounded_range
|
||||
(const KeyType& lower_key, const KeyType& upper_key, KeyValueCompare comp, bool left_closed, bool right_closed) const;
|
||||
(const KeyType& lower_key, const KeyType& upper_key, KeyTypeKeyCompare comp, bool left_closed, bool right_closed) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::splaytree::s_iterator_to(reference)
|
||||
static iterator s_iterator_to(reference value);
|
||||
@@ -382,12 +393,12 @@ class splay_set_impl
|
||||
//! @copydoc ::boost::intrusive::splaytree::splay_up(iterator)
|
||||
void splay_up(iterator i);
|
||||
|
||||
//! @copydoc ::boost::intrusive::splaytree::splay_down(const KeyType&,KeyValueCompare)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
iterator splay_down(const KeyType &key, KeyValueCompare comp);
|
||||
//! @copydoc ::boost::intrusive::splaytree::splay_down(const KeyType&,KeyTypeKeyCompare)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
iterator splay_down(const KeyType &key, KeyTypeKeyCompare comp);
|
||||
|
||||
//! @copydoc ::boost::intrusive::splaytree::splay_down(const_reference)
|
||||
iterator splay_down(const_reference value);
|
||||
//! @copydoc ::boost::intrusive::splaytree::splay_down(const key_type &key)
|
||||
iterator splay_down(const key_type &key);
|
||||
|
||||
//! @copydoc ::boost::intrusive::splaytree::rebalance
|
||||
void rebalance();
|
||||
@@ -423,7 +434,7 @@ template<class T, class ...Options>
|
||||
#else
|
||||
template<class T, class O1 = void, class O2 = void
|
||||
, class O3 = void, class O4 = void
|
||||
, class O5 = void>
|
||||
, class O5 = void, class O6 = void>
|
||||
#endif
|
||||
struct make_splay_set
|
||||
{
|
||||
@@ -431,7 +442,7 @@ struct make_splay_set
|
||||
typedef typename pack_options
|
||||
< splaytree_defaults,
|
||||
#if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
|
||||
O1, O2, O3, O4, O5
|
||||
O1, O2, O3, O4, O5, O6
|
||||
#else
|
||||
Options...
|
||||
#endif
|
||||
@@ -442,6 +453,7 @@ struct make_splay_set
|
||||
|
||||
typedef splay_set_impl
|
||||
< value_traits
|
||||
, typename packed_options::key_of_value
|
||||
, typename packed_options::compare
|
||||
, typename packed_options::size_type
|
||||
, packed_options::constant_time_size
|
||||
@@ -453,14 +465,14 @@ struct make_splay_set
|
||||
|
||||
#ifndef BOOST_INTRUSIVE_DOXYGEN_INVOKED
|
||||
#if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
|
||||
template<class T, class O1, class O2, class O3, class O4, class O5>
|
||||
template<class T, class O1, class O2, class O3, class O4, class O5, class O6>
|
||||
#else
|
||||
template<class T, class ...Options>
|
||||
#endif
|
||||
class splay_set
|
||||
: public make_splay_set<T,
|
||||
#if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
|
||||
O1, O2, O3, O4, O5
|
||||
O1, O2, O3, O4, O5, O6
|
||||
#else
|
||||
Options...
|
||||
#endif
|
||||
@@ -469,7 +481,7 @@ class splay_set
|
||||
typedef typename make_splay_set
|
||||
<T,
|
||||
#if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
|
||||
O1, O2, O3, O4, O5
|
||||
O1, O2, O3, O4, O5, O6
|
||||
#else
|
||||
Options...
|
||||
#endif
|
||||
@@ -477,7 +489,7 @@ class splay_set
|
||||
|
||||
BOOST_MOVABLE_BUT_NOT_COPYABLE(splay_set)
|
||||
public:
|
||||
typedef typename Base::value_compare value_compare;
|
||||
typedef typename Base::key_compare key_compare;
|
||||
typedef typename Base::value_traits value_traits;
|
||||
typedef typename Base::iterator iterator;
|
||||
typedef typename Base::const_iterator const_iterator;
|
||||
@@ -485,14 +497,14 @@ class splay_set
|
||||
//Assert if passed value traits are compatible with the type
|
||||
BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value));
|
||||
|
||||
explicit splay_set( const value_compare &cmp = value_compare()
|
||||
explicit splay_set( const key_compare &cmp = key_compare()
|
||||
, const value_traits &v_traits = value_traits())
|
||||
: Base(cmp, v_traits)
|
||||
{}
|
||||
|
||||
template<class Iterator>
|
||||
splay_set( Iterator b, Iterator e
|
||||
, const value_compare &cmp = value_compare()
|
||||
, const key_compare &cmp = key_compare()
|
||||
, const value_traits &v_traits = value_traits())
|
||||
: Base(b, e, cmp, v_traits)
|
||||
{}
|
||||
@@ -504,6 +516,14 @@ class splay_set
|
||||
splay_set& operator=(BOOST_RV_REF(splay_set) x)
|
||||
{ return static_cast<splay_set &>(this->Base::operator=(::boost::move(static_cast<Base&>(x)))); }
|
||||
|
||||
template <class Cloner, class Disposer>
|
||||
void clone_from(const splay_set &src, Cloner cloner, Disposer disposer)
|
||||
{ Base::clone_from(src, cloner, disposer); }
|
||||
|
||||
template <class Cloner, class Disposer>
|
||||
void clone_from(BOOST_RV_REF(splay_set) src, Cloner cloner, Disposer disposer)
|
||||
{ Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer); }
|
||||
|
||||
static splay_set &container_from_end_iterator(iterator end_iterator)
|
||||
{ return static_cast<splay_set &>(Base::container_from_end_iterator(end_iterator)); }
|
||||
|
||||
@@ -533,15 +553,15 @@ class splay_set
|
||||
#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED)
|
||||
template<class T, class ...Options>
|
||||
#else
|
||||
template<class ValueTraits, class Compare, class SizeType, bool ConstantTimeSize, typename HeaderHolder>
|
||||
template<class ValueTraits, class VoidOrKeyOfValue, class Compare, class SizeType, bool ConstantTimeSize, typename HeaderHolder>
|
||||
#endif
|
||||
class splay_multiset_impl
|
||||
#ifndef BOOST_INTRUSIVE_DOXYGEN_INVOKED
|
||||
: public splaytree_impl<ValueTraits, Compare, SizeType, ConstantTimeSize, HeaderHolder>
|
||||
: public splaytree_impl<ValueTraits, VoidOrKeyOfValue, Compare, SizeType, ConstantTimeSize, HeaderHolder>
|
||||
#endif
|
||||
{
|
||||
/// @cond
|
||||
typedef splaytree_impl<ValueTraits, Compare, SizeType, ConstantTimeSize, HeaderHolder> tree_type;
|
||||
typedef splaytree_impl<ValueTraits, VoidOrKeyOfValue, Compare, SizeType, ConstantTimeSize, HeaderHolder> tree_type;
|
||||
|
||||
BOOST_MOVABLE_BUT_NOT_COPYABLE(splay_multiset_impl)
|
||||
typedef tree_type implementation_defined;
|
||||
@@ -549,6 +569,8 @@ class splay_multiset_impl
|
||||
|
||||
public:
|
||||
typedef typename implementation_defined::value_type value_type;
|
||||
typedef typename implementation_defined::key_type key_type;
|
||||
typedef typename implementation_defined::key_of_value key_of_value;
|
||||
typedef typename implementation_defined::value_traits value_traits;
|
||||
typedef typename implementation_defined::pointer pointer;
|
||||
typedef typename implementation_defined::const_pointer const_pointer;
|
||||
@@ -572,16 +594,16 @@ class splay_multiset_impl
|
||||
static const bool constant_time_size = tree_type::constant_time_size;
|
||||
|
||||
public:
|
||||
//! @copydoc ::boost::intrusive::splaytree::splaytree(const value_compare &,const value_traits &)
|
||||
explicit splay_multiset_impl( const value_compare &cmp = value_compare()
|
||||
//! @copydoc ::boost::intrusive::splaytree::splaytree(const key_compare &,const value_traits &)
|
||||
explicit splay_multiset_impl( const key_compare &cmp = key_compare()
|
||||
, const value_traits &v_traits = value_traits())
|
||||
: tree_type(cmp, v_traits)
|
||||
{}
|
||||
|
||||
//! @copydoc ::boost::intrusive::splaytree::splaytree(bool,Iterator,Iterator,const value_compare &,const value_traits &)
|
||||
//! @copydoc ::boost::intrusive::splaytree::splaytree(bool,Iterator,Iterator,const key_compare &,const value_traits &)
|
||||
template<class Iterator>
|
||||
splay_multiset_impl( Iterator b, Iterator e
|
||||
, const value_compare &cmp = value_compare()
|
||||
, const key_compare &cmp = key_compare()
|
||||
, const value_traits &v_traits = value_traits())
|
||||
: tree_type(false, b, e, cmp, v_traits)
|
||||
{}
|
||||
@@ -662,11 +684,20 @@ class splay_multiset_impl
|
||||
//! @copydoc ::boost::intrusive::splaytree::swap
|
||||
void swap(splay_multiset_impl& other);
|
||||
|
||||
//! @copydoc ::boost::intrusive::splaytree::clone_from
|
||||
//! @copydoc ::boost::intrusive::splaytree::clone_from(const splaytree&,Cloner,Disposer)
|
||||
template <class Cloner, class Disposer>
|
||||
void clone_from(const splay_multiset_impl &src, Cloner cloner, Disposer disposer);
|
||||
|
||||
#endif //#ifdef BOOST_iNTRUSIVE_DOXYGEN_INVOKED
|
||||
#else
|
||||
|
||||
using tree_type::clone_from;
|
||||
|
||||
#endif //#ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
|
||||
|
||||
//! @copydoc ::boost::intrusive::splaytree::clone_from(splaytree&&,Cloner,Disposer)
|
||||
template <class Cloner, class Disposer>
|
||||
void clone_from(BOOST_RV_REF(splay_multiset_impl) src, Cloner cloner, Disposer disposer)
|
||||
{ tree_type::clone_from(BOOST_MOVE_BASE(tree_type, src), cloner, disposer); }
|
||||
|
||||
//! @copydoc ::boost::intrusive::splaytree::insert_equal(reference)
|
||||
iterator insert(reference value)
|
||||
@@ -697,12 +728,12 @@ class splay_multiset_impl
|
||||
//! @copydoc ::boost::intrusive::splaytree::erase(const_iterator,const_iterator)
|
||||
iterator erase(const_iterator b, const_iterator e);
|
||||
|
||||
//! @copydoc ::boost::intrusive::splaytree::erase(const_reference)
|
||||
size_type erase(const_reference value);
|
||||
//! @copydoc ::boost::intrusive::splaytree::erase(const key_type&)
|
||||
size_type erase(const key_type &key);
|
||||
|
||||
//! @copydoc ::boost::intrusive::splaytree::erase(const KeyType&,KeyValueCompare)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
size_type erase(const KeyType& key, KeyValueCompare comp);
|
||||
//! @copydoc ::boost::intrusive::splaytree::erase(const KeyType&,KeyTypeKeyCompare)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
size_type erase(const KeyType& key, KeyTypeKeyCompare comp);
|
||||
|
||||
//! @copydoc ::boost::intrusive::splaytree::erase_and_dispose(const_iterator,Disposer)
|
||||
template<class Disposer>
|
||||
@@ -712,13 +743,13 @@ class splay_multiset_impl
|
||||
template<class Disposer>
|
||||
iterator erase_and_dispose(const_iterator b, const_iterator e, Disposer disposer);
|
||||
|
||||
//! @copydoc ::boost::intrusive::splaytree::erase_and_dispose(const_reference, Disposer)
|
||||
//! @copydoc ::boost::intrusive::splaytree::erase_and_dispose(const key_type&, Disposer)
|
||||
template<class Disposer>
|
||||
size_type erase_and_dispose(const_reference value, Disposer disposer);
|
||||
size_type erase_and_dispose(const key_type &key, Disposer disposer);
|
||||
|
||||
//! @copydoc ::boost::intrusive::splaytree::erase_and_dispose(const KeyType&,KeyValueCompare,Disposer)
|
||||
template<class KeyType, class KeyValueCompare, class Disposer>
|
||||
size_type erase_and_dispose(const KeyType& key, KeyValueCompare comp, Disposer disposer);
|
||||
//! @copydoc ::boost::intrusive::splaytree::erase_and_dispose(const KeyType&,KeyTypeKeyCompare,Disposer)
|
||||
template<class KeyType, class KeyTypeKeyCompare, class Disposer>
|
||||
size_type erase_and_dispose(const KeyType& key, KeyTypeKeyCompare comp, Disposer disposer);
|
||||
|
||||
//! @copydoc ::boost::intrusive::splaytree::clear
|
||||
void clear();
|
||||
@@ -727,88 +758,88 @@ class splay_multiset_impl
|
||||
template<class Disposer>
|
||||
void clear_and_dispose(Disposer disposer);
|
||||
|
||||
//! @copydoc ::boost::intrusive::splaytree::count(const_reference)
|
||||
size_type count(const_reference value);
|
||||
//! @copydoc ::boost::intrusive::splaytree::count(const key_type&)
|
||||
size_type count(const key_type&);
|
||||
|
||||
//! @copydoc ::boost::intrusive::splaytree::count(const KeyType&,KeyValueCompare)const
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
size_type count(const KeyType& key, KeyValueCompare comp);
|
||||
//! @copydoc ::boost::intrusive::splaytree::count(const KeyType&,KeyTypeKeyCompare)const
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
size_type count(const KeyType& key, KeyTypeKeyCompare comp);
|
||||
|
||||
//! @copydoc ::boost::intrusive::splaytree::lower_bound(const_reference)
|
||||
iterator lower_bound(const_reference value);
|
||||
//! @copydoc ::boost::intrusive::splaytree::lower_bound(const key_type&)
|
||||
iterator lower_bound(const key_type &key);
|
||||
|
||||
//! @copydoc ::boost::intrusive::splaytree::lower_bound(const KeyType&,KeyValueCompare)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
iterator lower_bound(const KeyType& key, KeyValueCompare comp);
|
||||
//! @copydoc ::boost::intrusive::splaytree::lower_bound(const KeyType&,KeyTypeKeyCompare)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
iterator lower_bound(const KeyType& key, KeyTypeKeyCompare comp);
|
||||
|
||||
//! @copydoc ::boost::intrusive::splaytree::lower_bound(const_reference)const
|
||||
const_iterator lower_bound(const_reference value) const;
|
||||
//! @copydoc ::boost::intrusive::splaytree::lower_bound(const key_type&)const
|
||||
const_iterator lower_bound(const key_type &key) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::splaytree::lower_bound(const KeyType&,KeyValueCompare)const
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
const_iterator lower_bound(const KeyType& key, KeyValueCompare comp) const;
|
||||
//! @copydoc ::boost::intrusive::splaytree::lower_bound(const KeyType&,KeyTypeKeyCompare)const
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
const_iterator lower_bound(const KeyType& key, KeyTypeKeyCompare comp) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::splaytree::upper_bound(const_reference)
|
||||
iterator upper_bound(const_reference value);
|
||||
//! @copydoc ::boost::intrusive::splaytree::upper_bound(const key_type&)
|
||||
iterator upper_bound(const key_type &key);
|
||||
|
||||
//! @copydoc ::boost::intrusive::splaytree::upper_bound(const KeyType&,KeyValueCompare)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
iterator upper_bound(const KeyType& key, KeyValueCompare comp);
|
||||
//! @copydoc ::boost::intrusive::splaytree::upper_bound(const KeyType&,KeyTypeKeyCompare)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
iterator upper_bound(const KeyType& key, KeyTypeKeyCompare comp);
|
||||
|
||||
//! @copydoc ::boost::intrusive::splaytree::upper_bound(const_reference)const
|
||||
const_iterator upper_bound(const_reference value) const;
|
||||
//! @copydoc ::boost::intrusive::splaytree::upper_bound(const key_type&)const
|
||||
const_iterator upper_bound(const key_type &key) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::splaytree::upper_bound(const KeyType&,KeyValueCompare)const
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
const_iterator upper_bound(const KeyType& key, KeyValueCompare comp) const;
|
||||
//! @copydoc ::boost::intrusive::splaytree::upper_bound(const KeyType&,KeyTypeKeyCompare)const
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
const_iterator upper_bound(const KeyType& key, KeyTypeKeyCompare comp) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::splaytree::find(const_reference)
|
||||
iterator find(const_reference value);
|
||||
//! @copydoc ::boost::intrusive::splaytree::find(const key_type&)
|
||||
iterator find(const key_type &key);
|
||||
|
||||
//! @copydoc ::boost::intrusive::splaytree::find(const KeyType&,KeyValueCompare)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
iterator find(const KeyType& key, KeyValueCompare comp);
|
||||
//! @copydoc ::boost::intrusive::splaytree::find(const KeyType&,KeyTypeKeyCompare)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
iterator find(const KeyType& key, KeyTypeKeyCompare comp);
|
||||
|
||||
//! @copydoc ::boost::intrusive::splaytree::find(const_reference)const
|
||||
const_iterator find(const_reference value) const;
|
||||
//! @copydoc ::boost::intrusive::splaytree::find(const key_type&)const
|
||||
const_iterator find(const key_type &key) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::splaytree::find(const KeyType&,KeyValueCompare)const
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
const_iterator find(const KeyType& key, KeyValueCompare comp) const;
|
||||
//! @copydoc ::boost::intrusive::splaytree::find(const KeyType&,KeyTypeKeyCompare)const
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
const_iterator find(const KeyType& key, KeyTypeKeyCompare comp) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::splaytree::equal_range(const_reference)
|
||||
std::pair<iterator,iterator> equal_range(const_reference value);
|
||||
//! @copydoc ::boost::intrusive::splaytree::equal_range(const key_type&)
|
||||
std::pair<iterator,iterator> equal_range(const key_type &key);
|
||||
|
||||
//! @copydoc ::boost::intrusive::splaytree::equal_range(const KeyType&,KeyValueCompare)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
std::pair<iterator,iterator> equal_range(const KeyType& key, KeyValueCompare comp);
|
||||
//! @copydoc ::boost::intrusive::splaytree::equal_range(const KeyType&,KeyTypeKeyCompare)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
std::pair<iterator,iterator> equal_range(const KeyType& key, KeyTypeKeyCompare comp);
|
||||
|
||||
//! @copydoc ::boost::intrusive::splaytree::equal_range(const_reference)const
|
||||
//! @copydoc ::boost::intrusive::splaytree::equal_range(const key_type&)const
|
||||
std::pair<const_iterator, const_iterator>
|
||||
equal_range(const_reference value) const;
|
||||
equal_range(const key_type &key) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::splaytree::equal_range(const KeyType&,KeyValueCompare)const
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
//! @copydoc ::boost::intrusive::splaytree::equal_range(const KeyType&,KeyTypeKeyCompare)const
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
std::pair<const_iterator, const_iterator>
|
||||
equal_range(const KeyType& key, KeyValueCompare comp) const;
|
||||
equal_range(const KeyType& key, KeyTypeKeyCompare comp) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::splaytree::bounded_range(const_reference,const_reference,bool,bool)
|
||||
//! @copydoc ::boost::intrusive::splaytree::bounded_range(const key_type&, const key_type&,bool,bool)
|
||||
std::pair<iterator,iterator> bounded_range
|
||||
(const_reference lower_value, const_reference upper_value, bool left_closed, bool right_closed);
|
||||
|
||||
//! @copydoc ::boost::intrusive::splaytree::bounded_range(const KeyType&,const KeyType&,KeyValueCompare,bool,bool)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
//! @copydoc ::boost::intrusive::splaytree::bounded_range(const KeyType&,const KeyType&,KeyTypeKeyCompare,bool,bool)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
std::pair<iterator,iterator> bounded_range
|
||||
(const KeyType& lower_key, const KeyType& upper_key, KeyValueCompare comp, bool left_closed, bool right_closed);
|
||||
(const KeyType& lower_key, const KeyType& upper_key, KeyTypeKeyCompare comp, bool left_closed, bool right_closed);
|
||||
|
||||
//! @copydoc ::boost::intrusive::splaytree::bounded_range(const_reference,const_reference,bool,bool)const
|
||||
//! @copydoc ::boost::intrusive::splaytree::bounded_range(const key_type&, const key_type&,bool,bool)const
|
||||
std::pair<const_iterator, const_iterator> bounded_range
|
||||
(const_reference lower_value, const_reference upper_value, bool left_closed, bool right_closed) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::splaytree::bounded_range(const KeyType&,const KeyType&,KeyValueCompare,bool,bool)const
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
//! @copydoc ::boost::intrusive::splaytree::bounded_range(const KeyType&,const KeyType&,KeyTypeKeyCompare,bool,bool)const
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
std::pair<const_iterator, const_iterator> bounded_range
|
||||
(const KeyType& lower_key, const KeyType& upper_key, KeyValueCompare comp, bool left_closed, bool right_closed) const;
|
||||
(const KeyType& lower_key, const KeyType& upper_key, KeyTypeKeyCompare comp, bool left_closed, bool right_closed) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::splaytree::s_iterator_to(reference)
|
||||
static iterator s_iterator_to(reference value);
|
||||
@@ -837,12 +868,12 @@ class splay_multiset_impl
|
||||
//! @copydoc ::boost::intrusive::splaytree::splay_up(iterator)
|
||||
void splay_up(iterator i);
|
||||
|
||||
//! @copydoc ::boost::intrusive::splaytree::splay_down(const KeyType&,KeyValueCompare)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
iterator splay_down(const KeyType &key, KeyValueCompare comp);
|
||||
//! @copydoc ::boost::intrusive::splaytree::splay_down(const KeyType&,KeyTypeKeyCompare)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
iterator splay_down(const KeyType &key, KeyTypeKeyCompare comp);
|
||||
|
||||
//! @copydoc ::boost::intrusive::splaytree::splay_down(const_reference)
|
||||
iterator splay_down(const_reference value);
|
||||
//! @copydoc ::boost::intrusive::splaytree::splay_down(const key_type &key)
|
||||
iterator splay_down(const key_type &key);
|
||||
|
||||
//! @copydoc ::boost::intrusive::splaytree::rebalance
|
||||
void rebalance();
|
||||
@@ -878,7 +909,7 @@ template<class T, class ...Options>
|
||||
#else
|
||||
template<class T, class O1 = void, class O2 = void
|
||||
, class O3 = void, class O4 = void
|
||||
, class O5 = void>
|
||||
, class O5 = void, class O6 = void>
|
||||
#endif
|
||||
struct make_splay_multiset
|
||||
{
|
||||
@@ -886,7 +917,7 @@ struct make_splay_multiset
|
||||
typedef typename pack_options
|
||||
< splaytree_defaults,
|
||||
#if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
|
||||
O1, O2, O3, O4, O5
|
||||
O1, O2, O3, O4, O5, O6
|
||||
#else
|
||||
Options...
|
||||
#endif
|
||||
@@ -897,6 +928,7 @@ struct make_splay_multiset
|
||||
|
||||
typedef splay_multiset_impl
|
||||
< value_traits
|
||||
, typename packed_options::key_of_value
|
||||
, typename packed_options::compare
|
||||
, typename packed_options::size_type
|
||||
, packed_options::constant_time_size
|
||||
@@ -909,14 +941,14 @@ struct make_splay_multiset
|
||||
#ifndef BOOST_INTRUSIVE_DOXYGEN_INVOKED
|
||||
|
||||
#if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
|
||||
template<class T, class O1, class O2, class O3, class O4, class O5>
|
||||
template<class T, class O1, class O2, class O3, class O4, class O5, class O6>
|
||||
#else
|
||||
template<class T, class ...Options>
|
||||
#endif
|
||||
class splay_multiset
|
||||
: public make_splay_multiset<T,
|
||||
#if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
|
||||
O1, O2, O3, O4, O5
|
||||
O1, O2, O3, O4, O5, O6
|
||||
#else
|
||||
Options...
|
||||
#endif
|
||||
@@ -924,7 +956,7 @@ class splay_multiset
|
||||
{
|
||||
typedef typename make_splay_multiset<T,
|
||||
#if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
|
||||
O1, O2, O3, O4, O5
|
||||
O1, O2, O3, O4, O5, O6
|
||||
#else
|
||||
Options...
|
||||
#endif
|
||||
@@ -933,7 +965,7 @@ class splay_multiset
|
||||
BOOST_MOVABLE_BUT_NOT_COPYABLE(splay_multiset)
|
||||
|
||||
public:
|
||||
typedef typename Base::value_compare value_compare;
|
||||
typedef typename Base::key_compare key_compare;
|
||||
typedef typename Base::value_traits value_traits;
|
||||
typedef typename Base::iterator iterator;
|
||||
typedef typename Base::const_iterator const_iterator;
|
||||
@@ -941,14 +973,14 @@ class splay_multiset
|
||||
//Assert if passed value traits are compatible with the type
|
||||
BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value));
|
||||
|
||||
explicit splay_multiset( const value_compare &cmp = value_compare()
|
||||
explicit splay_multiset( const key_compare &cmp = key_compare()
|
||||
, const value_traits &v_traits = value_traits())
|
||||
: Base(cmp, v_traits)
|
||||
{}
|
||||
|
||||
template<class Iterator>
|
||||
splay_multiset( Iterator b, Iterator e
|
||||
, const value_compare &cmp = value_compare()
|
||||
, const key_compare &cmp = key_compare()
|
||||
, const value_traits &v_traits = value_traits())
|
||||
: Base(b, e, cmp, v_traits)
|
||||
{}
|
||||
@@ -960,6 +992,14 @@ class splay_multiset
|
||||
splay_multiset& operator=(BOOST_RV_REF(splay_multiset) x)
|
||||
{ return static_cast<splay_multiset &>(this->Base::operator=(::boost::move(static_cast<Base&>(x)))); }
|
||||
|
||||
template <class Cloner, class Disposer>
|
||||
void clone_from(const splay_multiset &src, Cloner cloner, Disposer disposer)
|
||||
{ Base::clone_from(src, cloner, disposer); }
|
||||
|
||||
template <class Cloner, class Disposer>
|
||||
void clone_from(BOOST_RV_REF(splay_multiset) src, Cloner cloner, Disposer disposer)
|
||||
{ Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer); }
|
||||
|
||||
static splay_multiset &container_from_end_iterator(iterator end_iterator)
|
||||
{ return static_cast<splay_multiset &>(Base::container_from_end_iterator(end_iterator)); }
|
||||
|
||||
|
||||
@@ -40,19 +40,14 @@ namespace intrusive {
|
||||
/// @cond
|
||||
|
||||
struct splaytree_defaults
|
||||
{
|
||||
typedef default_bstree_hook_applier proto_value_traits;
|
||||
static const bool constant_time_size = true;
|
||||
typedef std::size_t size_type;
|
||||
typedef void compare;
|
||||
typedef void header_holder_type;
|
||||
};
|
||||
: bstree_defaults
|
||||
{};
|
||||
|
||||
/// @endcond
|
||||
|
||||
//! The class template splaytree is an intrusive splay tree container that
|
||||
//! is used to construct intrusive splay_set and splay_multiset containers. The no-throw
|
||||
//! guarantee holds only, if the value_compare object
|
||||
//! guarantee holds only, if the key_compare object
|
||||
//! doesn't throw.
|
||||
//!
|
||||
//! The template parameter \c T is the type to be managed by the container.
|
||||
@@ -66,17 +61,17 @@ struct splaytree_defaults
|
||||
#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED)
|
||||
template<class T, class ...Options>
|
||||
#else
|
||||
template<class ValueTraits, class VoidOrKeyComp, class SizeType, bool ConstantTimeSize, typename HeaderHolder>
|
||||
template<class ValueTraits, class VoidOrKeyOfValue, class VoidOrKeyComp, class SizeType, bool ConstantTimeSize, typename HeaderHolder>
|
||||
#endif
|
||||
class splaytree_impl
|
||||
/// @cond
|
||||
: public bstree_impl<ValueTraits, VoidOrKeyComp, SizeType, ConstantTimeSize, SplayTreeAlgorithms, HeaderHolder>
|
||||
: public bstree_impl<ValueTraits, VoidOrKeyOfValue, VoidOrKeyComp, SizeType, ConstantTimeSize, SplayTreeAlgorithms, HeaderHolder>
|
||||
/// @endcond
|
||||
{
|
||||
public:
|
||||
typedef ValueTraits value_traits;
|
||||
/// @cond
|
||||
typedef bstree_impl< ValueTraits, VoidOrKeyComp, SizeType
|
||||
typedef bstree_impl< ValueTraits, VoidOrKeyOfValue, VoidOrKeyComp, SizeType
|
||||
, ConstantTimeSize, SplayTreeAlgorithms
|
||||
, HeaderHolder> tree_type;
|
||||
typedef tree_type implementation_defined;
|
||||
@@ -86,6 +81,7 @@ class splaytree_impl
|
||||
typedef typename implementation_defined::const_pointer const_pointer;
|
||||
typedef typename implementation_defined::value_type value_type;
|
||||
typedef typename implementation_defined::key_type key_type;
|
||||
typedef typename implementation_defined::key_of_value key_of_value;
|
||||
typedef typename implementation_defined::reference reference;
|
||||
typedef typename implementation_defined::const_reference const_reference;
|
||||
typedef typename implementation_defined::difference_type difference_type;
|
||||
@@ -115,16 +111,16 @@ class splaytree_impl
|
||||
|
||||
typedef typename implementation_defined::insert_commit_data insert_commit_data;
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::bstree(const value_compare &,const value_traits &)
|
||||
explicit splaytree_impl( const value_compare &cmp = value_compare()
|
||||
//! @copydoc ::boost::intrusive::bstree::bstree(const key_compare &,const value_traits &)
|
||||
explicit splaytree_impl( const key_compare &cmp = key_compare()
|
||||
, const value_traits &v_traits = value_traits())
|
||||
: tree_type(cmp, v_traits)
|
||||
{}
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::bstree(bool,Iterator,Iterator,const value_compare &,const value_traits &)
|
||||
//! @copydoc ::boost::intrusive::bstree::bstree(bool,Iterator,Iterator,const key_compare &,const value_traits &)
|
||||
template<class Iterator>
|
||||
splaytree_impl( bool unique, Iterator b, Iterator e
|
||||
, const value_compare &cmp = value_compare()
|
||||
, const key_compare &cmp = key_compare()
|
||||
, const value_traits &v_traits = value_traits())
|
||||
: tree_type(cmp, v_traits)
|
||||
{
|
||||
@@ -210,10 +206,24 @@ class splaytree_impl
|
||||
//! @copydoc ::boost::intrusive::bstree::swap
|
||||
void swap(splaytree_impl& other);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::clone_from
|
||||
//! @copydoc ::boost::intrusive::bstree::clone_from(const bstree&,Cloner,Disposer)
|
||||
//! Additional notes: it also copies the alpha factor from the source container.
|
||||
template <class Cloner, class Disposer>
|
||||
void clone_from(const splaytree_impl &src, Cloner cloner, Disposer disposer);
|
||||
|
||||
#else //BOOST_INTRUSIVE_DOXYGEN_INVOKED
|
||||
|
||||
using tree_type::clone_from;
|
||||
|
||||
#endif //#ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::clone_from(bstree&&,Cloner,Disposer)
|
||||
template <class Cloner, class Disposer>
|
||||
void clone_from(BOOST_RV_REF(splaytree_impl) src, Cloner cloner, Disposer disposer)
|
||||
{ tree_type::clone_from(BOOST_MOVE_BASE(tree_type, src), cloner, disposer); }
|
||||
|
||||
#ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::insert_equal(reference)
|
||||
iterator insert_equal(reference value);
|
||||
|
||||
@@ -230,16 +240,16 @@ class splaytree_impl
|
||||
//! @copydoc ::boost::intrusive::bstree::insert_unique(const_iterator,reference)
|
||||
iterator insert_unique(const_iterator hint, reference value);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::insert_unique_check(const KeyType&,KeyValueCompare,insert_commit_data&)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
//! @copydoc ::boost::intrusive::bstree::insert_unique_check(const KeyType&,KeyTypeKeyCompare,insert_commit_data&)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
std::pair<iterator, bool> insert_unique_check
|
||||
(const KeyType &key, KeyValueCompare key_value_comp, insert_commit_data &commit_data);
|
||||
(const KeyType &key, KeyTypeKeyCompare comp, insert_commit_data &commit_data);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::insert_unique_check(const_iterator,const KeyType&,KeyValueCompare,insert_commit_data&)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
//! @copydoc ::boost::intrusive::bstree::insert_unique_check(const_iterator,const KeyType&,KeyTypeKeyCompare,insert_commit_data&)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
std::pair<iterator, bool> insert_unique_check
|
||||
(const_iterator hint, const KeyType &key
|
||||
,KeyValueCompare key_value_comp, insert_commit_data &commit_data);
|
||||
,KeyTypeKeyCompare comp, insert_commit_data &commit_data);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::insert_unique_commit
|
||||
iterator insert_unique_commit(reference value, const insert_commit_data &commit_data);
|
||||
@@ -263,12 +273,12 @@ class splaytree_impl
|
||||
//! @copydoc ::boost::intrusive::bstree::erase(const_iterator,const_iterator)
|
||||
iterator erase(const_iterator b, const_iterator e);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::erase(const_reference)
|
||||
size_type erase(const_reference value);
|
||||
//! @copydoc ::boost::intrusive::bstree::erase(const key_type &)
|
||||
size_type erase(const key_type &key);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::erase(const KeyType&,KeyValueCompare)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
size_type erase(const KeyType& key, KeyValueCompare comp);
|
||||
//! @copydoc ::boost::intrusive::bstree::erase(const KeyType&,KeyTypeKeyCompare)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
size_type erase(const KeyType& key, KeyTypeKeyCompare comp);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::erase_and_dispose(const_iterator,Disposer)
|
||||
template<class Disposer>
|
||||
@@ -278,13 +288,13 @@ class splaytree_impl
|
||||
template<class Disposer>
|
||||
iterator erase_and_dispose(const_iterator b, const_iterator e, Disposer disposer);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::erase_and_dispose(const_reference, Disposer)
|
||||
//! @copydoc ::boost::intrusive::bstree::erase_and_dispose(const key_type &, Disposer)
|
||||
template<class Disposer>
|
||||
size_type erase_and_dispose(const_reference value, Disposer disposer);
|
||||
size_type erase_and_dispose(const key_type &key, Disposer disposer);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::erase_and_dispose(const KeyType&,KeyValueCompare,Disposer)
|
||||
template<class KeyType, class KeyValueCompare, class Disposer>
|
||||
size_type erase_and_dispose(const KeyType& key, KeyValueCompare comp, Disposer disposer);
|
||||
//! @copydoc ::boost::intrusive::bstree::erase_and_dispose(const KeyType&,KeyTypeKeyCompare,Disposer)
|
||||
template<class KeyType, class KeyTypeKeyCompare, class Disposer>
|
||||
size_type erase_and_dispose(const KeyType& key, KeyTypeKeyCompare comp, Disposer disposer);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::clear
|
||||
void clear();
|
||||
@@ -293,120 +303,120 @@ class splaytree_impl
|
||||
template<class Disposer>
|
||||
void clear_and_dispose(Disposer disposer);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::count(const_reference)const
|
||||
//! @copydoc ::boost::intrusive::bstree::count(const key_type &)const
|
||||
//! Additional note: non-const function, splaying is performed.
|
||||
size_type count(const_reference value);
|
||||
size_type count(const key_type &key);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::count(const KeyType&,KeyValueCompare)const
|
||||
//! @copydoc ::boost::intrusive::bstree::count(const KeyType&,KeyTypeKeyCompare)const
|
||||
//! Additional note: non-const function, splaying is performed.
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
size_type count(const KeyType &key, KeyValueCompare comp);
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
size_type count(const KeyType &key, KeyTypeKeyCompare comp);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::count(const_reference)const
|
||||
//! @copydoc ::boost::intrusive::bstree::count(const key_type &)const
|
||||
//! Additional note: const function, no splaying is performed
|
||||
size_type count(const_reference value) const;
|
||||
size_type count(const key_type &key) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::count(const KeyType&,KeyValueCompare)const
|
||||
//! @copydoc ::boost::intrusive::bstree::count(const KeyType&,KeyTypeKeyCompare)const
|
||||
//! Additional note: const function, no splaying is performed
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
size_type count(const KeyType &key, KeyValueCompare comp) const;
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
size_type count(const KeyType &key, KeyTypeKeyCompare comp) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::lower_bound(const_reference)
|
||||
//! @copydoc ::boost::intrusive::bstree::lower_bound(const key_type &)
|
||||
//! Additional note: non-const function, splaying is performed.
|
||||
iterator lower_bound(const_reference value);
|
||||
iterator lower_bound(const key_type &key);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::lower_bound(const_reference)const
|
||||
//! @copydoc ::boost::intrusive::bstree::lower_bound(const key_type &)const
|
||||
//! Additional note: const function, no splaying is performed
|
||||
const_iterator lower_bound(const_reference value) const;
|
||||
const_iterator lower_bound(const key_type &key) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::lower_bound(const KeyType&,KeyValueCompare)
|
||||
//! @copydoc ::boost::intrusive::bstree::lower_bound(const KeyType&,KeyTypeKeyCompare)
|
||||
//! Additional note: non-const function, splaying is performed for the first
|
||||
//! element of the equal range of "key"
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
iterator lower_bound(const KeyType &key, KeyValueCompare comp);
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
iterator lower_bound(const KeyType &key, KeyTypeKeyCompare comp);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::lower_bound(const KeyType&,KeyValueCompare)const
|
||||
//! @copydoc ::boost::intrusive::bstree::lower_bound(const KeyType&,KeyTypeKeyCompare)const
|
||||
//! Additional note: const function, no splaying is performed
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
const_iterator lower_bound(const KeyType &key, KeyValueCompare comp) const;
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
const_iterator lower_bound(const KeyType &key, KeyTypeKeyCompare comp) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::upper_bound(const_reference)
|
||||
//! @copydoc ::boost::intrusive::bstree::upper_bound(const key_type &)
|
||||
//! Additional note: non-const function, splaying is performed for the first
|
||||
//! element of the equal range of "value"
|
||||
iterator upper_bound(const_reference value);
|
||||
iterator upper_bound(const key_type &key);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::upper_bound(const_reference)const
|
||||
//! @copydoc ::boost::intrusive::bstree::upper_bound(const key_type &)const
|
||||
//! Additional note: const function, no splaying is performed
|
||||
const_iterator upper_bound(const_reference value) const;
|
||||
const_iterator upper_bound(const key_type &key) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::upper_bound(const KeyType&,KeyValueCompare)
|
||||
//! @copydoc ::boost::intrusive::bstree::upper_bound(const KeyType&,KeyTypeKeyCompare)
|
||||
//! Additional note: non-const function, splaying is performed for the first
|
||||
//! element of the equal range of "key"
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
iterator upper_bound(const KeyType &key, KeyValueCompare comp);
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
iterator upper_bound(const KeyType &key, KeyTypeKeyCompare comp);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::upper_bound(const KeyType&,KeyValueCompare)const
|
||||
//! @copydoc ::boost::intrusive::bstree::upper_bound(const KeyType&,KeyTypeKeyCompare)const
|
||||
//! Additional note: const function, no splaying is performed
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
const_iterator upper_bound(const KeyType &key, KeyValueCompare comp) const;
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
const_iterator upper_bound(const KeyType &key, KeyTypeKeyCompare comp) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::find(const_reference)
|
||||
//! @copydoc ::boost::intrusive::bstree::find(const key_type &)
|
||||
//! Additional note: non-const function, splaying is performed for the first
|
||||
//! element of the equal range of "value"
|
||||
iterator find(const_reference value);
|
||||
iterator find(const key_type &key);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::find(const_reference)const
|
||||
//! @copydoc ::boost::intrusive::bstree::find(const key_type &)const
|
||||
//! Additional note: const function, no splaying is performed
|
||||
const_iterator find(const_reference value) const;
|
||||
const_iterator find(const key_type &key) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::find(const KeyType&,KeyValueCompare)
|
||||
//! @copydoc ::boost::intrusive::bstree::find(const KeyType&,KeyTypeKeyCompare)
|
||||
//! Additional note: non-const function, splaying is performed for the first
|
||||
//! element of the equal range of "key"
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
iterator find(const KeyType &key, KeyValueCompare comp);
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
iterator find(const KeyType &key, KeyTypeKeyCompare comp);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::find(const KeyType&,KeyValueCompare)const
|
||||
//! @copydoc ::boost::intrusive::bstree::find(const KeyType&,KeyTypeKeyCompare)const
|
||||
//! Additional note: const function, no splaying is performed
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
const_iterator find(const KeyType &key, KeyValueCompare comp) const;
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
const_iterator find(const KeyType &key, KeyTypeKeyCompare comp) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::equal_range(const_reference)
|
||||
//! @copydoc ::boost::intrusive::bstree::equal_range(const key_type &)
|
||||
//! Additional note: non-const function, splaying is performed for the first
|
||||
//! element of the equal range of "value"
|
||||
std::pair<iterator, iterator> equal_range(const_reference value);
|
||||
std::pair<iterator, iterator> equal_range(const key_type &key);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::equal_range(const_reference)const
|
||||
//! @copydoc ::boost::intrusive::bstree::equal_range(const key_type &)const
|
||||
//! Additional note: const function, no splaying is performed
|
||||
std::pair<const_iterator, const_iterator> equal_range(const_reference value) const;
|
||||
std::pair<const_iterator, const_iterator> equal_range(const key_type &key) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::equal_range(const KeyType&,KeyValueCompare)
|
||||
//! @copydoc ::boost::intrusive::bstree::equal_range(const KeyType&,KeyTypeKeyCompare)
|
||||
//! Additional note: non-const function, splaying is performed for the first
|
||||
//! element of the equal range of "key"
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
std::pair<iterator, iterator> equal_range(const KeyType &key, KeyValueCompare comp);
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
std::pair<iterator, iterator> equal_range(const KeyType &key, KeyTypeKeyCompare comp);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::equal_range(const KeyType&,KeyValueCompare)const
|
||||
//! @copydoc ::boost::intrusive::bstree::equal_range(const KeyType&,KeyTypeKeyCompare)const
|
||||
//! Additional note: const function, no splaying is performed
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
std::pair<const_iterator, const_iterator> equal_range(const KeyType &key, KeyValueCompare comp) const;
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
std::pair<const_iterator, const_iterator> equal_range(const KeyType &key, KeyTypeKeyCompare comp) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::bounded_range(const_reference,const_reference,bool,bool)
|
||||
//! @copydoc ::boost::intrusive::bstree::bounded_range(const key_type &,const key_type &,bool,bool)
|
||||
std::pair<iterator,iterator> bounded_range
|
||||
(const_reference lower_value, const_reference upper_value, bool left_closed, bool right_closed);
|
||||
(const key_type &lower_key, const key_type &upper_key, bool left_closed, bool right_closed);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::bounded_range(const KeyType&,const KeyType&,KeyValueCompare,bool,bool)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
//! @copydoc ::boost::intrusive::bstree::bounded_range(const KeyType&,const KeyType&,KeyTypeKeyCompare,bool,bool)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
std::pair<iterator,iterator> bounded_range
|
||||
(const KeyType& lower_key, const KeyType& upper_key, KeyValueCompare comp, bool left_closed, bool right_closed);
|
||||
(const KeyType& lower_key, const KeyType& upper_key, KeyTypeKeyCompare comp, bool left_closed, bool right_closed);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::bounded_range(const_reference,const_reference,bool,bool)const
|
||||
//! @copydoc ::boost::intrusive::bstree::bounded_range(const key_type &,const key_type &,bool,bool)const
|
||||
std::pair<const_iterator, const_iterator> bounded_range
|
||||
(const_reference lower_value, const_reference upper_value, bool left_closed, bool right_closed) const;
|
||||
(const key_type &lower_key, const key_type &upper_key, bool left_closed, bool right_closed) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::bounded_range(const KeyType&,const KeyType&,KeyValueCompare,bool,bool)const
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
//! @copydoc ::boost::intrusive::bstree::bounded_range(const KeyType&,const KeyType&,KeyTypeKeyCompare,bool,bool)const
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
std::pair<const_iterator, const_iterator> bounded_range
|
||||
(const KeyType& lower_key, const KeyType& upper_key, KeyValueCompare comp, bool left_closed, bool right_closed) const;
|
||||
(const KeyType& lower_key, const KeyType& upper_key, KeyTypeKeyCompare comp, bool left_closed, bool right_closed) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::s_iterator_to(reference)
|
||||
static iterator s_iterator_to(reference value);
|
||||
@@ -455,8 +465,8 @@ class splaytree_impl
|
||||
//! <b>Returns</b>: An iterator to the new root of the tree, end() if the tree is empty.
|
||||
//!
|
||||
//! <b>Throws</b>: If the comparison functor throws.
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
iterator splay_down(const KeyType &key, KeyValueCompare comp)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
iterator splay_down(const KeyType &key, KeyTypeKeyCompare comp)
|
||||
{
|
||||
detail::key_nodeptr_comp<value_compare, value_traits>
|
||||
key_node_comp(comp, &this->get_value_traits());
|
||||
@@ -473,8 +483,8 @@ class splaytree_impl
|
||||
//! <b>Returns</b>: An iterator to the new root of the tree, end() if the tree is empty.
|
||||
//!
|
||||
//! <b>Throws</b>: If the predicate throws.
|
||||
iterator splay_down(const_reference value)
|
||||
{ return this->splay_down(value, this->value_comp()); }
|
||||
iterator splay_down(const key_type &key)
|
||||
{ return this->splay_down(key, this->key_comp()); }
|
||||
|
||||
#ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
|
||||
//! @copydoc ::boost::intrusive::bstree::rebalance
|
||||
@@ -507,7 +517,7 @@ template<class T, class ...Options>
|
||||
#else
|
||||
template<class T, class O1 = void, class O2 = void
|
||||
, class O3 = void, class O4 = void
|
||||
, class O5 = void>
|
||||
, class O5 = void, class O6 = void>
|
||||
#endif
|
||||
struct make_splaytree
|
||||
{
|
||||
@@ -515,7 +525,7 @@ struct make_splaytree
|
||||
typedef typename pack_options
|
||||
< splaytree_defaults,
|
||||
#if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
|
||||
O1, O2, O3, O4, O5
|
||||
O1, O2, O3, O4, O5, O6
|
||||
#else
|
||||
Options...
|
||||
#endif
|
||||
@@ -526,6 +536,7 @@ struct make_splaytree
|
||||
|
||||
typedef splaytree_impl
|
||||
< value_traits
|
||||
, typename packed_options::key_of_value
|
||||
, typename packed_options::compare
|
||||
, typename packed_options::size_type
|
||||
, packed_options::constant_time_size
|
||||
@@ -539,14 +550,14 @@ struct make_splaytree
|
||||
#ifndef BOOST_INTRUSIVE_DOXYGEN_INVOKED
|
||||
|
||||
#if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
|
||||
template<class T, class O1, class O2, class O3, class O4, class O5>
|
||||
template<class T, class O1, class O2, class O3, class O4, class O5, class O6>
|
||||
#else
|
||||
template<class T, class ...Options>
|
||||
#endif
|
||||
class splaytree
|
||||
: public make_splaytree<T,
|
||||
#if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
|
||||
O1, O2, O3, O4, O5
|
||||
O1, O2, O3, O4, O5, O6
|
||||
#else
|
||||
Options...
|
||||
#endif
|
||||
@@ -555,7 +566,7 @@ class splaytree
|
||||
typedef typename make_splaytree
|
||||
<T,
|
||||
#if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
|
||||
O1, O2, O3, O4, O5
|
||||
O1, O2, O3, O4, O5, O6
|
||||
#else
|
||||
Options...
|
||||
#endif
|
||||
@@ -563,7 +574,7 @@ class splaytree
|
||||
BOOST_MOVABLE_BUT_NOT_COPYABLE(splaytree)
|
||||
|
||||
public:
|
||||
typedef typename Base::value_compare value_compare;
|
||||
typedef typename Base::key_compare key_compare;
|
||||
typedef typename Base::value_traits value_traits;
|
||||
typedef typename Base::iterator iterator;
|
||||
typedef typename Base::const_iterator const_iterator;
|
||||
@@ -573,14 +584,14 @@ class splaytree
|
||||
//Assert if passed value traits are compatible with the type
|
||||
BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value));
|
||||
|
||||
explicit splaytree( const value_compare &cmp = value_compare()
|
||||
explicit splaytree( const key_compare &cmp = key_compare()
|
||||
, const value_traits &v_traits = value_traits())
|
||||
: Base(cmp, v_traits)
|
||||
{}
|
||||
|
||||
template<class Iterator>
|
||||
splaytree( bool unique, Iterator b, Iterator e
|
||||
, const value_compare &cmp = value_compare()
|
||||
, const key_compare &cmp = key_compare()
|
||||
, const value_traits &v_traits = value_traits())
|
||||
: Base(unique, b, e, cmp, v_traits)
|
||||
{}
|
||||
@@ -592,6 +603,14 @@ class splaytree
|
||||
splaytree& operator=(BOOST_RV_REF(splaytree) x)
|
||||
{ return static_cast<splaytree &>(this->Base::operator=(BOOST_MOVE_BASE(Base, x))); }
|
||||
|
||||
template <class Cloner, class Disposer>
|
||||
void clone_from(const splaytree &src, Cloner cloner, Disposer disposer)
|
||||
{ Base::clone_from(src, cloner, disposer); }
|
||||
|
||||
template <class Cloner, class Disposer>
|
||||
void clone_from(BOOST_RV_REF(splaytree) src, Cloner cloner, Disposer disposer)
|
||||
{ Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer); }
|
||||
|
||||
static splaytree &container_from_end_iterator(iterator end_iterator)
|
||||
{ return static_cast<splaytree &>(Base::container_from_end_iterator(end_iterator)); }
|
||||
|
||||
|
||||
+185
-164
@@ -47,20 +47,16 @@ namespace intrusive {
|
||||
/// @cond
|
||||
|
||||
struct treap_defaults
|
||||
: bstree_defaults
|
||||
{
|
||||
typedef default_bstree_hook_applier proto_value_traits;
|
||||
static const bool constant_time_size = true;
|
||||
typedef std::size_t size_type;
|
||||
typedef void compare;
|
||||
typedef void priority;
|
||||
typedef void header_holder_type;
|
||||
};
|
||||
|
||||
/// @endcond
|
||||
|
||||
//! The class template treap is an intrusive treap container that
|
||||
//! is used to construct intrusive set and multiset containers. The no-throw
|
||||
//! guarantee holds only, if the value_compare object and priority_compare object
|
||||
//! guarantee holds only, if the key_compare object and priority_compare object
|
||||
//! don't throw.
|
||||
//!
|
||||
//! The template parameter \c T is the type to be managed by the container.
|
||||
@@ -74,24 +70,24 @@ struct treap_defaults
|
||||
#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED)
|
||||
template<class T, class ...Options>
|
||||
#else
|
||||
template<class ValueTraits, class VoidOrKeyComp, class VoidOrPrioComp, class SizeType, bool ConstantTimeSize, typename HeaderHolder>
|
||||
template<class ValueTraits, class VoidOrKeyOfValue, class VoidOrKeyComp, class VoidOrPrioComp, class SizeType, bool ConstantTimeSize, typename HeaderHolder>
|
||||
#endif
|
||||
class treap_impl
|
||||
/// @cond
|
||||
: public bstree_impl<ValueTraits, VoidOrKeyComp, SizeType, ConstantTimeSize, BsTreeAlgorithms, HeaderHolder>
|
||||
: public bstree_impl<ValueTraits, VoidOrKeyOfValue, VoidOrKeyComp, SizeType, ConstantTimeSize, BsTreeAlgorithms, HeaderHolder>
|
||||
//Use public inheritance to avoid MSVC bugs with closures
|
||||
, public detail::ebo_functor_holder
|
||||
< typename get_prio
|
||||
< VoidOrPrioComp
|
||||
, typename bstree_impl
|
||||
<ValueTraits, VoidOrKeyComp, SizeType, ConstantTimeSize, BsTreeAlgorithms, HeaderHolder>::value_type>::type
|
||||
<ValueTraits, VoidOrKeyOfValue, VoidOrKeyComp, SizeType, ConstantTimeSize, BsTreeAlgorithms, HeaderHolder>::value_type>::type
|
||||
>
|
||||
/// @endcond
|
||||
{
|
||||
public:
|
||||
typedef ValueTraits value_traits;
|
||||
/// @cond
|
||||
typedef bstree_impl< ValueTraits, VoidOrKeyComp, SizeType
|
||||
typedef bstree_impl< ValueTraits, VoidOrKeyOfValue, VoidOrKeyComp, SizeType
|
||||
, ConstantTimeSize, BsTreeAlgorithms
|
||||
, HeaderHolder> tree_type;
|
||||
typedef tree_type implementation_defined;
|
||||
@@ -108,6 +104,7 @@ class treap_impl
|
||||
typedef typename implementation_defined::const_pointer const_pointer;
|
||||
typedef typename implementation_defined::value_type value_type;
|
||||
typedef typename implementation_defined::key_type key_type;
|
||||
typedef typename implementation_defined::key_of_value key_of_value;
|
||||
typedef typename implementation_defined::reference reference;
|
||||
typedef typename implementation_defined::const_reference const_reference;
|
||||
typedef typename implementation_defined::difference_type difference_type;
|
||||
@@ -129,6 +126,15 @@ class treap_impl
|
||||
static const bool stateful_value_traits = implementation_defined::stateful_value_traits;
|
||||
static const bool safemode_or_autounlink = is_safe_autounlink<value_traits::link_mode>::value;
|
||||
|
||||
typedef detail::key_nodeptr_comp<priority_compare, value_traits> value_node_prio_comp_t;
|
||||
|
||||
template<class KeyPrioComp>
|
||||
detail::key_nodeptr_comp<KeyPrioComp, value_traits> key_node_prio_comp(KeyPrioComp keypriocomp) const
|
||||
{ return detail::key_nodeptr_comp<KeyPrioComp, value_traits>(keypriocomp, &this->get_value_traits()); }
|
||||
|
||||
value_node_prio_comp_t value_node_prio_comp() const
|
||||
{ return this->key_node_prio_comp(this->priv_pcomp()); }
|
||||
|
||||
/// @cond
|
||||
private:
|
||||
|
||||
@@ -153,7 +159,7 @@ class treap_impl
|
||||
//! <b>Throws</b>: If value_traits::node_traits::node
|
||||
//! constructor throws (this does not happen with predefined Boost.Intrusive hooks)
|
||||
//! or the copy constructor of the value_compare/priority_compare objects throw. Basic guarantee.
|
||||
explicit treap_impl( const value_compare &cmp = value_compare()
|
||||
explicit treap_impl( const key_compare &cmp = key_compare()
|
||||
, const priority_compare &pcmp = priority_compare()
|
||||
, const value_traits &v_traits = value_traits())
|
||||
: tree_type(cmp, v_traits), prio_base(pcmp)
|
||||
@@ -170,11 +176,11 @@ class treap_impl
|
||||
//!
|
||||
//! <b>Throws</b>: If value_traits::node_traits::node
|
||||
//! constructor throws (this does not happen with predefined Boost.Intrusive hooks)
|
||||
//! or the copy constructor/operator() of the value_compare/priority_compare objects
|
||||
//! or the copy constructor/operator() of the key_compare/priority_compare objects
|
||||
//! throw. Basic guarantee.
|
||||
template<class Iterator>
|
||||
treap_impl( bool unique, Iterator b, Iterator e
|
||||
, const value_compare &cmp = value_compare()
|
||||
, const key_compare &cmp = key_compare()
|
||||
, const priority_compare &pcmp = priority_compare()
|
||||
, const value_traits &v_traits = value_traits())
|
||||
: tree_type(cmp, v_traits), prio_base(pcmp)
|
||||
@@ -356,6 +362,27 @@ class treap_impl
|
||||
this->priv_pcomp() = src.priv_pcomp();
|
||||
}
|
||||
|
||||
//! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw.
|
||||
//! Cloner should yield to nodes equivalent to the original nodes.
|
||||
//!
|
||||
//! <b>Effects</b>: Erases all the elements from *this
|
||||
//! calling Disposer::operator()(pointer), clones all the
|
||||
//! elements from src calling Cloner::operator()(reference)
|
||||
//! and inserts them on *this. Copies the predicate from the source container.
|
||||
//!
|
||||
//! 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 or predicate copy assignment throws. Basic guarantee.
|
||||
template <class Cloner, class Disposer>
|
||||
void clone_from(BOOST_RV_REF(treap_impl) src, Cloner cloner, Disposer disposer)
|
||||
{
|
||||
tree_type::clone_from(BOOST_MOVE_BASE(tree_type, src), cloner, disposer);
|
||||
this->priv_pcomp() = ::boost::move(src.priv_pcomp());
|
||||
}
|
||||
|
||||
//! <b>Requires</b>: value must be an lvalue
|
||||
//!
|
||||
//! <b>Effects</b>: Inserts value into the container before the upper bound.
|
||||
@@ -363,21 +390,21 @@ class treap_impl
|
||||
//! <b>Complexity</b>: Average complexity for insert element is at
|
||||
//! most logarithmic.
|
||||
//!
|
||||
//! <b>Throws</b>: If the internal value_compare or priority_compare functions throw. Strong guarantee.
|
||||
//! <b>Throws</b>: If the internal key_compare or priority_compare functions throw. Strong guarantee.
|
||||
//!
|
||||
//! <b>Note</b>: Does not affect the validity of iterators and references.
|
||||
//! No copy-constructors are called.
|
||||
iterator insert_equal(reference value)
|
||||
{
|
||||
detail::key_nodeptr_comp<value_compare, value_traits>
|
||||
key_node_comp(this->value_comp(), &this->get_value_traits());
|
||||
detail::key_nodeptr_comp<priority_compare, value_traits>
|
||||
key_node_pcomp(this->priv_pcomp(), &this->get_value_traits());
|
||||
node_ptr to_insert(this->get_value_traits().to_node_ptr(value));
|
||||
if(safemode_or_autounlink)
|
||||
BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert));
|
||||
iterator ret(node_algorithms::insert_equal_upper_bound
|
||||
(this->tree_type::header_ptr(), to_insert, key_node_comp, key_node_pcomp), this->priv_value_traits_ptr());
|
||||
BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(!safemode_or_autounlink || node_algorithms::unique(to_insert));
|
||||
iterator ret
|
||||
( node_algorithms::insert_equal_upper_bound
|
||||
( this->tree_type::header_ptr()
|
||||
, to_insert
|
||||
, this->key_node_comp(this->key_comp())
|
||||
, this->value_node_prio_comp())
|
||||
, this->priv_value_traits_ptr());
|
||||
this->tree_type::sz_traits().increment();
|
||||
return ret;
|
||||
}
|
||||
@@ -392,21 +419,22 @@ class treap_impl
|
||||
//! <b>Complexity</b>: Logarithmic in general, but it is amortized
|
||||
//! constant time if t is inserted immediately before hint.
|
||||
//!
|
||||
//! <b>Throws</b>: If the internal value_compare or priority_compare functions throw. Strong guarantee.
|
||||
//! <b>Throws</b>: If the internal key_compare or priority_compare functions throw. Strong guarantee.
|
||||
//!
|
||||
//! <b>Note</b>: Does not affect the validity of iterators and references.
|
||||
//! No copy-constructors are called.
|
||||
iterator insert_equal(const_iterator hint, reference value)
|
||||
{
|
||||
detail::key_nodeptr_comp<value_compare, value_traits>
|
||||
key_node_comp(this->value_comp(), &this->get_value_traits());
|
||||
detail::key_nodeptr_comp<priority_compare, value_traits>
|
||||
key_node_pcomp(this->priv_pcomp(), &this->get_value_traits());
|
||||
node_ptr to_insert(this->get_value_traits().to_node_ptr(value));
|
||||
if(safemode_or_autounlink)
|
||||
BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert));
|
||||
iterator ret (node_algorithms::insert_equal
|
||||
(this->tree_type::header_ptr(), hint.pointed_node(), to_insert, key_node_comp, key_node_pcomp), this->priv_value_traits_ptr());
|
||||
BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(!safemode_or_autounlink || node_algorithms::unique(to_insert));
|
||||
iterator ret
|
||||
(node_algorithms::insert_equal
|
||||
( this->tree_type::header_ptr()
|
||||
, hint.pointed_node()
|
||||
, to_insert
|
||||
, this->key_node_comp(this->key_comp())
|
||||
, this->value_node_prio_comp())
|
||||
, this->priv_value_traits_ptr());
|
||||
this->tree_type::sz_traits().increment();
|
||||
return ret;
|
||||
}
|
||||
@@ -419,9 +447,9 @@ class treap_impl
|
||||
//!
|
||||
//! <b>Complexity</b>: Insert range is in general O(N * log(N)), where N is the
|
||||
//! size of the range. However, it is linear in N if the range is already sorted
|
||||
//! by value_comp().
|
||||
//! by key_comp().
|
||||
//!
|
||||
//! <b>Throws</b>: If the internal value_compare or priority_compare functions throw.
|
||||
//! <b>Throws</b>: If the internal key_compare or priority_compare functions throw.
|
||||
//! Strong guarantee.
|
||||
//!
|
||||
//! <b>Note</b>: Does not affect the validity of iterators and references.
|
||||
@@ -442,7 +470,7 @@ class treap_impl
|
||||
//! <b>Complexity</b>: Average complexity for insert element is at
|
||||
//! most logarithmic.
|
||||
//!
|
||||
//! <b>Throws</b>: If the internal value_compare or priority_compare functions throw.
|
||||
//! <b>Throws</b>: If the internal key_compare or priority_compare functions throw.
|
||||
//! Strong guarantee.
|
||||
//!
|
||||
//! <b>Note</b>: Does not affect the validity of iterators and references.
|
||||
@@ -450,10 +478,11 @@ class treap_impl
|
||||
std::pair<iterator, bool> insert_unique(reference value)
|
||||
{
|
||||
insert_commit_data commit_data;
|
||||
std::pair<iterator, bool> ret = insert_unique_check(value, this->value_comp(), this->priv_pcomp(), commit_data);
|
||||
std::pair<iterator, bool> ret = this->insert_unique_check
|
||||
(value, this->comp(), this->priv_pcomp(), commit_data);
|
||||
if(!ret.second)
|
||||
return ret;
|
||||
return std::pair<iterator, bool> (insert_unique_commit(value, commit_data), true);
|
||||
return std::pair<iterator, bool> (this->insert_unique_commit(value, commit_data), true);
|
||||
}
|
||||
|
||||
//! <b>Requires</b>: value must be an lvalue, and "hint" must be
|
||||
@@ -466,7 +495,7 @@ class treap_impl
|
||||
//! constant time (two comparisons in the worst case)
|
||||
//! if t is inserted immediately before hint.
|
||||
//!
|
||||
//! <b>Throws</b>: If the internal value_compare or priority_compare functions throw.
|
||||
//! <b>Throws</b>: If the internal key_compare or priority_compare functions throw.
|
||||
//! Strong guarantee.
|
||||
//!
|
||||
//! <b>Note</b>: Does not affect the validity of iterators and references.
|
||||
@@ -474,10 +503,11 @@ class treap_impl
|
||||
iterator insert_unique(const_iterator hint, reference value)
|
||||
{
|
||||
insert_commit_data commit_data;
|
||||
std::pair<iterator, bool> ret = insert_unique_check(hint, value, this->value_comp(), this->priv_pcomp(), commit_data);
|
||||
std::pair<iterator, bool> ret = this->insert_unique_check
|
||||
(hint, value, this->comp(), this->priv_pcomp(), commit_data);
|
||||
if(!ret.second)
|
||||
return ret.first;
|
||||
return insert_unique_commit(value, commit_data);
|
||||
return this->insert_unique_commit(value, commit_data);
|
||||
}
|
||||
|
||||
//! <b>Requires</b>: Dereferencing iterator must yield an lvalue
|
||||
@@ -487,9 +517,9 @@ class treap_impl
|
||||
//!
|
||||
//! <b>Complexity</b>: Insert range is in general O(N * log(N)), where N is the
|
||||
//! size of the range. However, it is linear in N if the range is already sorted
|
||||
//! by value_comp().
|
||||
//! by key_comp().
|
||||
//!
|
||||
//! <b>Throws</b>: If the internal value_compare or priority_compare functions throw.
|
||||
//! <b>Throws</b>: If the internal key_compare or priority_compare functions throw.
|
||||
//! Strong guarantee.
|
||||
//!
|
||||
//! <b>Note</b>: Does not affect the validity of iterators and references.
|
||||
@@ -508,11 +538,11 @@ class treap_impl
|
||||
}
|
||||
}
|
||||
|
||||
//! <b>Requires</b>: key_value_comp must be a comparison function that induces
|
||||
//! the same strict weak ordering as value_compare.
|
||||
//! <b>Requires</b>: comp must be a comparison function that induces
|
||||
//! the same strict weak ordering as key_compare.
|
||||
//! key_value_pcomp must be a comparison function that induces
|
||||
//! the same strict weak ordering as priority_compare. The difference is that
|
||||
//! key_value_pcomp and key_value_comp compare an arbitrary key with the contained values.
|
||||
//! key_value_pcomp and comp compare an arbitrary key with the contained values.
|
||||
//!
|
||||
//! <b>Effects</b>: Checks if a value can be inserted in the container, using
|
||||
//! a user provided key instead of the value itself.
|
||||
@@ -525,7 +555,7 @@ class treap_impl
|
||||
//!
|
||||
//! <b>Complexity</b>: Average complexity is at most logarithmic.
|
||||
//!
|
||||
//! <b>Throws</b>: If the key_value_comp or key_value_pcomp
|
||||
//! <b>Throws</b>: If the comp or key_value_pcomp
|
||||
//! ordering functions throw. Strong guarantee.
|
||||
//!
|
||||
//! <b>Notes</b>: This function is used to improve performance when constructing
|
||||
@@ -541,26 +571,23 @@ class treap_impl
|
||||
//!
|
||||
//! "commit_data" remains valid for a subsequent "insert_commit" only if no more
|
||||
//! objects are inserted or erased from the container.
|
||||
template<class KeyType, class KeyValueCompare, class KeyValuePrioCompare>
|
||||
template<class KeyType, class KeyTypeKeyCompare, class KeyValuePrioCompare>
|
||||
std::pair<iterator, bool> insert_unique_check
|
||||
( const KeyType &key, KeyValueCompare key_value_comp
|
||||
( const KeyType &key, KeyTypeKeyCompare comp
|
||||
, KeyValuePrioCompare key_value_pcomp, insert_commit_data &commit_data)
|
||||
{
|
||||
detail::key_nodeptr_comp<KeyValueCompare, value_traits>
|
||||
ocomp(key_value_comp, &this->get_value_traits());
|
||||
detail::key_nodeptr_comp<KeyValuePrioCompare, value_traits>
|
||||
pcomp(key_value_pcomp, &this->get_value_traits());
|
||||
std::pair<node_ptr, bool> ret =
|
||||
std::pair<node_ptr, bool> const ret =
|
||||
(node_algorithms::insert_unique_check
|
||||
(this->tree_type::header_ptr(), key, ocomp, pcomp, commit_data));
|
||||
( this->tree_type::header_ptr(), key
|
||||
, this->key_node_comp(comp), this->key_node_prio_comp(key_value_pcomp), commit_data));
|
||||
return std::pair<iterator, bool>(iterator(ret.first, this->priv_value_traits_ptr()), ret.second);
|
||||
}
|
||||
|
||||
//! <b>Requires</b>: key_value_comp must be a comparison function that induces
|
||||
//! the same strict weak ordering as value_compare.
|
||||
//! <b>Requires</b>: comp must be a comparison function that induces
|
||||
//! the same strict weak ordering as key_compare.
|
||||
//! key_value_pcomp must be a comparison function that induces
|
||||
//! the same strict weak ordering as priority_compare. The difference is that
|
||||
//! key_value_pcomp and key_value_comp compare an arbitrary key with the contained values.
|
||||
//! key_value_pcomp and comp compare an arbitrary key with the contained values.
|
||||
//!
|
||||
//! <b>Effects</b>: Checks if a value can be inserted in the container, using
|
||||
//! a user provided key instead of the value itself, using "hint"
|
||||
@@ -575,7 +602,7 @@ class treap_impl
|
||||
//! <b>Complexity</b>: Logarithmic in general, but it's amortized
|
||||
//! constant time if t is inserted immediately before hint.
|
||||
//!
|
||||
//! <b>Throws</b>: If the key_value_comp or key_value_pcomp
|
||||
//! <b>Throws</b>: If the comp or key_value_pcomp
|
||||
//! ordering functions throw. Strong guarantee.
|
||||
//!
|
||||
//! <b>Notes</b>: This function is used to improve performance when constructing
|
||||
@@ -591,20 +618,17 @@ class treap_impl
|
||||
//!
|
||||
//! "commit_data" remains valid for a subsequent "insert_commit" only if no more
|
||||
//! objects are inserted or erased from the container.
|
||||
template<class KeyType, class KeyValueCompare, class KeyValuePrioCompare>
|
||||
template<class KeyType, class KeyTypeKeyCompare, class KeyValuePrioCompare>
|
||||
std::pair<iterator, bool> insert_unique_check
|
||||
( const_iterator hint, const KeyType &key
|
||||
, KeyValueCompare key_value_comp
|
||||
, KeyTypeKeyCompare comp
|
||||
, KeyValuePrioCompare key_value_pcomp
|
||||
, insert_commit_data &commit_data)
|
||||
{
|
||||
detail::key_nodeptr_comp<KeyValueCompare, value_traits>
|
||||
ocomp(key_value_comp, &this->get_value_traits());
|
||||
detail::key_nodeptr_comp<KeyValuePrioCompare, value_traits>
|
||||
pcomp(key_value_pcomp, &this->get_value_traits());
|
||||
std::pair<node_ptr, bool> ret =
|
||||
std::pair<node_ptr, bool> const ret =
|
||||
(node_algorithms::insert_unique_check
|
||||
(this->tree_type::header_ptr(), hint.pointed_node(), key, ocomp, pcomp, commit_data));
|
||||
( this->tree_type::header_ptr(), hint.pointed_node(), key
|
||||
, this->key_node_comp(comp), this->key_node_prio_comp(key_value_pcomp), commit_data));
|
||||
return std::pair<iterator, bool>(iterator(ret.first, this->priv_value_traits_ptr()), ret.second);
|
||||
}
|
||||
|
||||
@@ -628,8 +652,7 @@ class treap_impl
|
||||
iterator insert_unique_commit(reference value, const insert_commit_data &commit_data)
|
||||
{
|
||||
node_ptr to_insert(this->get_value_traits().to_node_ptr(value));
|
||||
if(safemode_or_autounlink)
|
||||
BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert));
|
||||
BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(!safemode_or_autounlink || node_algorithms::unique(to_insert));
|
||||
node_algorithms::insert_unique_commit(this->tree_type::header_ptr(), to_insert, commit_data);
|
||||
this->tree_type::sz_traits().increment();
|
||||
return iterator(to_insert, this->priv_value_traits_ptr());
|
||||
@@ -652,12 +675,11 @@ class treap_impl
|
||||
iterator insert_before(const_iterator pos, reference value)
|
||||
{
|
||||
node_ptr to_insert(this->get_value_traits().to_node_ptr(value));
|
||||
if(safemode_or_autounlink)
|
||||
BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert));
|
||||
detail::key_nodeptr_comp<priority_compare, value_traits>
|
||||
pcomp(this->priv_pcomp(), &this->get_value_traits());
|
||||
iterator ret (node_algorithms::insert_before
|
||||
(this->tree_type::header_ptr(), pos.pointed_node(), to_insert, pcomp), this->priv_value_traits_ptr());
|
||||
BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(!safemode_or_autounlink || node_algorithms::unique(to_insert));
|
||||
iterator ret
|
||||
( node_algorithms::insert_before
|
||||
( this->tree_type::header_ptr(), pos.pointed_node(), to_insert, this->value_node_prio_comp())
|
||||
, this->priv_value_traits_ptr());
|
||||
this->tree_type::sz_traits().increment();
|
||||
return ret;
|
||||
}
|
||||
@@ -679,11 +701,8 @@ class treap_impl
|
||||
void push_back(reference value)
|
||||
{
|
||||
node_ptr to_insert(this->get_value_traits().to_node_ptr(value));
|
||||
if(safemode_or_autounlink)
|
||||
BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert));
|
||||
detail::key_nodeptr_comp<priority_compare, value_traits>
|
||||
pcomp(this->priv_pcomp(), &this->get_value_traits());
|
||||
node_algorithms::push_back(this->tree_type::header_ptr(), to_insert, pcomp);
|
||||
BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(!safemode_or_autounlink || node_algorithms::unique(to_insert));
|
||||
node_algorithms::push_back(this->tree_type::header_ptr(), to_insert, this->value_node_prio_comp());
|
||||
this->tree_type::sz_traits().increment();
|
||||
}
|
||||
|
||||
@@ -704,11 +723,8 @@ class treap_impl
|
||||
void push_front(reference value)
|
||||
{
|
||||
node_ptr to_insert(this->get_value_traits().to_node_ptr(value));
|
||||
if(safemode_or_autounlink)
|
||||
BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert));
|
||||
detail::key_nodeptr_comp<priority_compare, value_traits>
|
||||
pcomp(this->priv_pcomp(), &this->get_value_traits());
|
||||
node_algorithms::push_front(this->tree_type::header_ptr(), to_insert, pcomp);
|
||||
BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(!safemode_or_autounlink || node_algorithms::unique(to_insert));
|
||||
node_algorithms::push_front(this->tree_type::header_ptr(), to_insert, this->value_node_prio_comp());
|
||||
this->tree_type::sz_traits().increment();
|
||||
}
|
||||
|
||||
@@ -725,11 +741,8 @@ class treap_impl
|
||||
const_iterator ret(i);
|
||||
++ret;
|
||||
node_ptr to_erase(i.pointed_node());
|
||||
if(safemode_or_autounlink)
|
||||
BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(!node_algorithms::unique(to_erase));
|
||||
detail::key_nodeptr_comp<priority_compare, value_traits>
|
||||
key_node_pcomp(this->priv_pcomp(), &this->get_value_traits());
|
||||
node_algorithms::erase(this->tree_type::header_ptr(), to_erase, key_node_pcomp);
|
||||
BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(!safemode_or_autounlink || !node_algorithms::unique(to_erase));
|
||||
node_algorithms::erase(this->tree_type::header_ptr(), to_erase, this->value_node_prio_comp());
|
||||
this->tree_type::sz_traits().decrement();
|
||||
if(safemode_or_autounlink)
|
||||
node_algorithms::init(to_erase);
|
||||
@@ -758,8 +771,8 @@ class treap_impl
|
||||
//!
|
||||
//! <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->value_comp()); }
|
||||
size_type erase(const key_type &key)
|
||||
{ return this->erase(key, this->key_comp()); }
|
||||
|
||||
//! <b>Effects</b>: Erases all the elements with the given key.
|
||||
//! according to the comparison functor "comp".
|
||||
@@ -773,10 +786,10 @@ class treap_impl
|
||||
//!
|
||||
//! <b>Note</b>: Invalidates the iterators (but not the references)
|
||||
//! to the erased elements. No destructors are called.
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
BOOST_INTRUSIVE_DOC1ST(size_type
|
||||
, typename detail::disable_if_convertible<KeyValueCompare BOOST_INTRUSIVE_I const_iterator BOOST_INTRUSIVE_I size_type>::type)
|
||||
erase(const KeyType& key, KeyValueCompare comp)
|
||||
, typename detail::disable_if_convertible<KeyTypeKeyCompare BOOST_INTRUSIVE_I const_iterator BOOST_INTRUSIVE_I size_type>::type)
|
||||
erase(const KeyType& key, KeyTypeKeyCompare comp)
|
||||
{
|
||||
std::pair<iterator,iterator> p = this->equal_range(key, comp);
|
||||
size_type n;
|
||||
@@ -841,9 +854,9 @@ class treap_impl
|
||||
//! <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)
|
||||
size_type erase_and_dispose(const key_type &key, Disposer disposer)
|
||||
{
|
||||
std::pair<iterator,iterator> p = this->equal_range(value);
|
||||
std::pair<iterator,iterator> p = this->equal_range(key);
|
||||
size_type n;
|
||||
private_erase(p.first, p.second, n, disposer);
|
||||
return n;
|
||||
@@ -864,10 +877,10 @@ class treap_impl
|
||||
//!
|
||||
//! <b>Note</b>: Invalidates the iterators
|
||||
//! to the erased elements.
|
||||
template<class KeyType, class KeyValueCompare, class Disposer>
|
||||
template<class KeyType, class KeyTypeKeyCompare, class Disposer>
|
||||
BOOST_INTRUSIVE_DOC1ST(size_type
|
||||
, typename detail::disable_if_convertible<KeyValueCompare BOOST_INTRUSIVE_I const_iterator BOOST_INTRUSIVE_I size_type>::type)
|
||||
erase_and_dispose(const KeyType& key, KeyValueCompare comp, Disposer disposer)
|
||||
, typename detail::disable_if_convertible<KeyTypeKeyCompare BOOST_INTRUSIVE_I const_iterator BOOST_INTRUSIVE_I size_type>::type)
|
||||
erase_and_dispose(const KeyType& key, KeyTypeKeyCompare comp, Disposer disposer)
|
||||
{
|
||||
std::pair<iterator,iterator> p = this->equal_range(key, comp);
|
||||
size_type n;
|
||||
@@ -909,9 +922,8 @@ class treap_impl
|
||||
template <class ExtraChecker>
|
||||
void check(ExtraChecker extra_checker) const
|
||||
{
|
||||
typedef detail::key_nodeptr_comp<priority_compare, value_traits> nodeptr_prio_comp_t;
|
||||
nodeptr_prio_comp_t nodeptr_prio_comp(priv_pcomp(), &this->get_value_traits());
|
||||
tree_type::check(detail::treap_node_extra_checker<ValueTraits, nodeptr_prio_comp_t, ExtraChecker>(nodeptr_prio_comp, extra_checker));
|
||||
tree_type::check(detail::treap_node_extra_checker
|
||||
<ValueTraits, value_node_prio_comp_t, ExtraChecker>(this->value_node_prio_comp(), extra_checker));
|
||||
}
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::check()const
|
||||
@@ -919,88 +931,88 @@ class treap_impl
|
||||
{ check(detail::empty_node_checker<ValueTraits>()); }
|
||||
|
||||
#ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
|
||||
//! @copydoc ::boost::intrusive::bstree::count(const_reference)const
|
||||
size_type count(const_reference value) const;
|
||||
//! @copydoc ::boost::intrusive::bstree::count(const key_type &)const
|
||||
size_type count(const key_type &key) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::count(const KeyType&,KeyValueCompare)const
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
size_type count(const KeyType& key, KeyValueCompare comp) const;
|
||||
//! @copydoc ::boost::intrusive::bstree::count(const KeyType&,KeyTypeKeyCompare)const
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
size_type count(const KeyType& key, KeyTypeKeyCompare comp) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::lower_bound(const_reference)
|
||||
iterator lower_bound(const_reference value);
|
||||
//! @copydoc ::boost::intrusive::bstree::lower_bound(const key_type &)
|
||||
iterator lower_bound(const key_type &key);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::lower_bound(const KeyType&,KeyValueCompare)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
iterator lower_bound(const KeyType& key, KeyValueCompare comp);
|
||||
//! @copydoc ::boost::intrusive::bstree::lower_bound(const KeyType&,KeyTypeKeyCompare)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
iterator lower_bound(const KeyType& key, KeyTypeKeyCompare comp);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::lower_bound(const_reference)const
|
||||
const_iterator lower_bound(const_reference value) const;
|
||||
//! @copydoc ::boost::intrusive::bstree::lower_bound(const key_type &)const
|
||||
const_iterator lower_bound(const key_type &key) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::lower_bound(const KeyType&,KeyValueCompare)const
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
const_iterator lower_bound(const KeyType& key, KeyValueCompare comp) const;
|
||||
//! @copydoc ::boost::intrusive::bstree::lower_bound(const KeyType&,KeyTypeKeyCompare)const
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
const_iterator lower_bound(const KeyType& key, KeyTypeKeyCompare comp) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::upper_bound(const_reference)
|
||||
iterator upper_bound(const_reference value);
|
||||
//! @copydoc ::boost::intrusive::bstree::upper_bound(const key_type &)
|
||||
iterator upper_bound(const key_type &key);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::upper_bound(const KeyType&,KeyValueCompare)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
iterator upper_bound(const KeyType& key, KeyValueCompare comp);
|
||||
//! @copydoc ::boost::intrusive::bstree::upper_bound(const KeyType&,KeyTypeKeyCompare)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
iterator upper_bound(const KeyType& key, KeyTypeKeyCompare comp);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::upper_bound(const_reference)const
|
||||
const_iterator upper_bound(const_reference value) const;
|
||||
//! @copydoc ::boost::intrusive::bstree::upper_bound(const key_type &)const
|
||||
const_iterator upper_bound(const key_type &key) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::upper_bound(const KeyType&,KeyValueCompare)const
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
const_iterator upper_bound(const KeyType& key, KeyValueCompare comp) const;
|
||||
//! @copydoc ::boost::intrusive::bstree::upper_bound(const KeyType&,KeyTypeKeyCompare)const
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
const_iterator upper_bound(const KeyType& key, KeyTypeKeyCompare comp) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::find(const_reference)
|
||||
iterator find(const_reference value);
|
||||
//! @copydoc ::boost::intrusive::bstree::find(const key_type &)
|
||||
iterator find(const key_type &key);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::find(const KeyType&,KeyValueCompare)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
iterator find(const KeyType& key, KeyValueCompare comp);
|
||||
//! @copydoc ::boost::intrusive::bstree::find(const KeyType&,KeyTypeKeyCompare)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
iterator find(const KeyType& key, KeyTypeKeyCompare comp);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::find(const_reference)const
|
||||
const_iterator find(const_reference value) const;
|
||||
//! @copydoc ::boost::intrusive::bstree::find(const key_type &)const
|
||||
const_iterator find(const key_type &key) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::find(const KeyType&,KeyValueCompare)const
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
const_iterator find(const KeyType& key, KeyValueCompare comp) const;
|
||||
//! @copydoc ::boost::intrusive::bstree::find(const KeyType&,KeyTypeKeyCompare)const
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
const_iterator find(const KeyType& key, KeyTypeKeyCompare comp) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::equal_range(const_reference)
|
||||
std::pair<iterator,iterator> equal_range(const_reference value);
|
||||
//! @copydoc ::boost::intrusive::bstree::equal_range(const key_type &)
|
||||
std::pair<iterator,iterator> equal_range(const key_type &key);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::equal_range(const KeyType&,KeyValueCompare)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
std::pair<iterator,iterator> equal_range(const KeyType& key, KeyValueCompare comp);
|
||||
//! @copydoc ::boost::intrusive::bstree::equal_range(const KeyType&,KeyTypeKeyCompare)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
std::pair<iterator,iterator> equal_range(const KeyType& key, KeyTypeKeyCompare comp);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::equal_range(const_reference)const
|
||||
//! @copydoc ::boost::intrusive::bstree::equal_range(const key_type &)const
|
||||
std::pair<const_iterator, const_iterator>
|
||||
equal_range(const_reference value) const;
|
||||
equal_range(const key_type &key) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::equal_range(const KeyType&,KeyValueCompare)const
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
//! @copydoc ::boost::intrusive::bstree::equal_range(const KeyType&,KeyTypeKeyCompare)const
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
std::pair<const_iterator, const_iterator>
|
||||
equal_range(const KeyType& key, KeyValueCompare comp) const;
|
||||
equal_range(const KeyType& key, KeyTypeKeyCompare comp) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::bounded_range(const_reference,const_reference,bool,bool)
|
||||
//! @copydoc ::boost::intrusive::bstree::bounded_range(const key_type &,const key_type &,bool,bool)
|
||||
std::pair<iterator,iterator> bounded_range
|
||||
(const_reference lower_value, const_reference upper_value, bool left_closed, bool right_closed);
|
||||
(const key_type &lower_key, const key_type &upper_key, bool left_closed, bool right_closed);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::bounded_range(const KeyType&,const KeyType&,KeyValueCompare,bool,bool)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
//! @copydoc ::boost::intrusive::bstree::bounded_range(const KeyType&,const KeyType&,KeyTypeKeyCompare,bool,bool)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
std::pair<iterator,iterator> bounded_range
|
||||
(const KeyType& lower_key, const KeyType& upper_key, KeyValueCompare comp, bool left_closed, bool right_closed);
|
||||
(const KeyType& lower_key, const KeyType& upper_key, KeyTypeKeyCompare comp, bool left_closed, bool right_closed);
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::bounded_range(const_reference,const_reference,bool,bool)const
|
||||
//! @copydoc ::boost::intrusive::bstree::bounded_range(const key_type &,const key_type &,bool,bool)const
|
||||
std::pair<const_iterator, const_iterator>
|
||||
bounded_range(const_reference lower_value, const_reference upper_value, bool left_closed, bool right_closed) const;
|
||||
bounded_range(const key_type &lower_key, const key_type &upper_key, bool left_closed, bool right_closed) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::bounded_range(const KeyType&,const KeyType&,KeyValueCompare,bool,bool)const
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
//! @copydoc ::boost::intrusive::bstree::bounded_range(const KeyType&,const KeyType&,KeyTypeKeyCompare,bool,bool)const
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
std::pair<const_iterator, const_iterator> bounded_range
|
||||
(const KeyType& lower_key, const KeyType& upper_key, KeyValueCompare comp, bool left_closed, bool right_closed) const;
|
||||
(const KeyType& lower_key, const KeyType& upper_key, KeyTypeKeyCompare comp, bool left_closed, bool right_closed) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::bstree::s_iterator_to(reference)
|
||||
static iterator s_iterator_to(reference value);
|
||||
@@ -1069,14 +1081,14 @@ template<class T, class ...Options>
|
||||
#else
|
||||
template<class T, class O1 = void, class O2 = void
|
||||
, class O3 = void, class O4 = void
|
||||
, class O5 = void>
|
||||
, class O5 = void, class O6 = void>
|
||||
#endif
|
||||
struct make_treap
|
||||
{
|
||||
typedef typename pack_options
|
||||
< treap_defaults,
|
||||
#if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
|
||||
O1, O2, O3, O4, O5
|
||||
O1, O2, O3, O4, O5, O6
|
||||
#else
|
||||
Options...
|
||||
#endif
|
||||
@@ -1087,6 +1099,7 @@ struct make_treap
|
||||
|
||||
typedef treap_impl
|
||||
< value_traits
|
||||
, typename packed_options::key_of_value
|
||||
, typename packed_options::compare
|
||||
, typename packed_options::priority
|
||||
, typename packed_options::size_type
|
||||
@@ -1100,14 +1113,14 @@ struct make_treap
|
||||
#ifndef BOOST_INTRUSIVE_DOXYGEN_INVOKED
|
||||
|
||||
#if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
|
||||
template<class T, class O1, class O2, class O3, class O4, class O5>
|
||||
template<class T, class O1, class O2, class O3, class O4, class O5, class O6>
|
||||
#else
|
||||
template<class T, class ...Options>
|
||||
#endif
|
||||
class treap
|
||||
: public make_treap<T,
|
||||
#if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
|
||||
O1, O2, O3, O4, O5
|
||||
O1, O2, O3, O4, O5, O6
|
||||
#else
|
||||
Options...
|
||||
#endif
|
||||
@@ -1116,7 +1129,7 @@ class treap
|
||||
typedef typename make_treap
|
||||
<T,
|
||||
#if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
|
||||
O1, O2, O3, O4, O5
|
||||
O1, O2, O3, O4, O5, O6
|
||||
#else
|
||||
Options...
|
||||
#endif
|
||||
@@ -1124,7 +1137,7 @@ class treap
|
||||
BOOST_MOVABLE_BUT_NOT_COPYABLE(treap)
|
||||
|
||||
public:
|
||||
typedef typename Base::value_compare value_compare;
|
||||
typedef typename Base::key_compare key_compare;
|
||||
typedef typename Base::priority_compare priority_compare;
|
||||
typedef typename Base::value_traits value_traits;
|
||||
typedef typename Base::iterator iterator;
|
||||
@@ -1135,7 +1148,7 @@ class treap
|
||||
//Assert if passed value traits are compatible with the type
|
||||
BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value));
|
||||
|
||||
explicit treap( const value_compare &cmp = value_compare()
|
||||
explicit treap( const key_compare &cmp = key_compare()
|
||||
, const priority_compare &pcmp = priority_compare()
|
||||
, const value_traits &v_traits = value_traits())
|
||||
: Base(cmp, pcmp, v_traits)
|
||||
@@ -1143,7 +1156,7 @@ class treap
|
||||
|
||||
template<class Iterator>
|
||||
treap( bool unique, Iterator b, Iterator e
|
||||
, const value_compare &cmp = value_compare()
|
||||
, const key_compare &cmp = key_compare()
|
||||
, const priority_compare &pcmp = priority_compare()
|
||||
, const value_traits &v_traits = value_traits())
|
||||
: Base(unique, b, e, cmp, pcmp, v_traits)
|
||||
@@ -1156,6 +1169,14 @@ class treap
|
||||
treap& operator=(BOOST_RV_REF(treap) x)
|
||||
{ return static_cast<treap&>(this->Base::operator=(BOOST_MOVE_BASE(Base, x))); }
|
||||
|
||||
template <class Cloner, class Disposer>
|
||||
void clone_from(const treap &src, Cloner cloner, Disposer disposer)
|
||||
{ Base::clone_from(src, cloner, disposer); }
|
||||
|
||||
template <class Cloner, class Disposer>
|
||||
void clone_from(BOOST_RV_REF(treap) src, Cloner cloner, Disposer disposer)
|
||||
{ Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer); }
|
||||
|
||||
static treap &container_from_end_iterator(iterator end_iterator)
|
||||
{ return static_cast<treap &>(Base::container_from_end_iterator(end_iterator)); }
|
||||
|
||||
|
||||
@@ -40,16 +40,16 @@ namespace intrusive {
|
||||
#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED)
|
||||
template<class T, class ...Options>
|
||||
#else
|
||||
template<class ValueTraits, class VoidOrKeyComp, class VoidOrPrioComp, class SizeType, bool ConstantTimeSize, typename HeaderHolder>
|
||||
template<class ValueTraits, class VoidOrKeyOfValue, class VoidOrKeyComp, class VoidOrPrioComp, class SizeType, bool ConstantTimeSize, typename HeaderHolder>
|
||||
#endif
|
||||
class treap_set_impl
|
||||
#ifndef BOOST_INTRUSIVE_DOXYGEN_INVOKED
|
||||
: public treap_impl<ValueTraits, VoidOrKeyComp, VoidOrPrioComp, SizeType, ConstantTimeSize, HeaderHolder>
|
||||
: public treap_impl<ValueTraits, VoidOrKeyOfValue, VoidOrKeyComp, VoidOrPrioComp, SizeType, ConstantTimeSize, HeaderHolder>
|
||||
#endif
|
||||
{
|
||||
/// @cond
|
||||
public:
|
||||
typedef treap_impl<ValueTraits, VoidOrKeyComp, VoidOrPrioComp, SizeType, ConstantTimeSize, HeaderHolder> tree_type;
|
||||
typedef treap_impl<ValueTraits, VoidOrKeyOfValue, VoidOrKeyComp, VoidOrPrioComp, SizeType, ConstantTimeSize, HeaderHolder> tree_type;
|
||||
BOOST_MOVABLE_BUT_NOT_COPYABLE(treap_set_impl)
|
||||
|
||||
typedef tree_type implementation_defined;
|
||||
@@ -58,6 +58,8 @@ class treap_set_impl
|
||||
public:
|
||||
typedef typename implementation_defined::value_type value_type;
|
||||
typedef typename implementation_defined::value_traits value_traits;
|
||||
typedef typename implementation_defined::key_type key_type;
|
||||
typedef typename implementation_defined::key_of_value key_of_value;
|
||||
typedef typename implementation_defined::pointer pointer;
|
||||
typedef typename implementation_defined::const_pointer const_pointer;
|
||||
typedef typename implementation_defined::reference reference;
|
||||
@@ -65,8 +67,8 @@ class treap_set_impl
|
||||
typedef typename implementation_defined::difference_type difference_type;
|
||||
typedef typename implementation_defined::size_type size_type;
|
||||
typedef typename implementation_defined::value_compare value_compare;
|
||||
typedef typename implementation_defined::priority_compare priority_compare;
|
||||
typedef typename implementation_defined::key_compare key_compare;
|
||||
typedef typename implementation_defined::priority_compare priority_compare;
|
||||
typedef typename implementation_defined::iterator iterator;
|
||||
typedef typename implementation_defined::const_iterator const_iterator;
|
||||
typedef typename implementation_defined::reverse_iterator reverse_iterator;
|
||||
@@ -87,8 +89,8 @@ class treap_set_impl
|
||||
//!
|
||||
//! <b>Throws</b>: If value_traits::node_traits::node
|
||||
//! constructor throws (this does not happen with predefined Boost.Intrusive hooks)
|
||||
//! or the copy constructor of the value_compare object throws.
|
||||
explicit treap_set_impl( const value_compare &cmp = value_compare()
|
||||
//! or the copy constructor of the key_compare object throws.
|
||||
explicit treap_set_impl( const key_compare &cmp = key_compare()
|
||||
, const priority_compare &pcmp = priority_compare()
|
||||
, const value_traits &v_traits = value_traits())
|
||||
: tree_type(cmp, pcmp, v_traits)
|
||||
@@ -105,10 +107,10 @@ class treap_set_impl
|
||||
//!
|
||||
//! <b>Throws</b>: If value_traits::node_traits::node
|
||||
//! constructor throws (this does not happen with predefined Boost.Intrusive hooks)
|
||||
//! or the copy constructor/operator() of the value_compare object throws.
|
||||
//! or the copy constructor/operator() of the key_compare object throws.
|
||||
template<class Iterator>
|
||||
treap_set_impl( Iterator b, Iterator e
|
||||
, const value_compare &cmp = value_compare()
|
||||
, const key_compare &cmp = key_compare()
|
||||
, const priority_compare &pcmp = priority_compare()
|
||||
, const value_traits &v_traits = value_traits())
|
||||
: tree_type(true, b, e, cmp, pcmp, v_traits)
|
||||
@@ -192,10 +194,23 @@ class treap_set_impl
|
||||
//! @copydoc ::boost::intrusive::treap::swap
|
||||
void swap(treap_set_impl& other);
|
||||
|
||||
//! @copydoc ::boost::intrusive::treap::clone_from
|
||||
//! @copydoc ::boost::intrusive::treap::clone_from(const treap&,Cloner,Disposer)
|
||||
template <class Cloner, class Disposer>
|
||||
void clone_from(const treap_set_impl &src, Cloner cloner, Disposer disposer);
|
||||
|
||||
#else
|
||||
|
||||
using tree_type::clone_from;
|
||||
|
||||
#endif
|
||||
|
||||
//! @copydoc ::boost::intrusive::treap::clone_from(treap&&,Cloner,Disposer)
|
||||
template <class Cloner, class Disposer>
|
||||
void clone_from(BOOST_RV_REF(treap_set_impl) src, Cloner cloner, Disposer disposer)
|
||||
{ tree_type::clone_from(BOOST_MOVE_BASE(tree_type, src), cloner, disposer); }
|
||||
|
||||
#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED)
|
||||
|
||||
//! @copydoc ::boost::intrusive::treap::top()
|
||||
iterator top();
|
||||
|
||||
@@ -226,20 +241,20 @@ class treap_set_impl
|
||||
iterator insert(const_iterator hint, reference value)
|
||||
{ return tree_type::insert_unique(hint, value); }
|
||||
|
||||
//! @copydoc ::boost::intrusive::treap::insert_unique_check(const KeyType&,KeyValueCompare,KeyValuePrioCompare,insert_commit_data&)
|
||||
template<class KeyType, class KeyValueCompare, class KeyValuePrioCompare>
|
||||
//! @copydoc ::boost::intrusive::treap::insert_unique_check(const KeyType&,KeyTypeKeyCompare,KeyValuePrioCompare,insert_commit_data&)
|
||||
template<class KeyType, class KeyTypeKeyCompare, class KeyValuePrioCompare>
|
||||
std::pair<iterator, bool> insert_check
|
||||
( const KeyType &key, KeyValueCompare key_value_comp, KeyValuePrioCompare key_value_pcomp
|
||||
( const KeyType &key, KeyTypeKeyCompare comp, KeyValuePrioCompare key_value_pcomp
|
||||
, insert_commit_data &commit_data)
|
||||
{ return tree_type::insert_unique_check(key, key_value_comp, key_value_pcomp, commit_data); }
|
||||
{ return tree_type::insert_unique_check(key, comp, key_value_pcomp, commit_data); }
|
||||
|
||||
//! @copydoc ::boost::intrusive::treap::insert_unique_check(const_iterator,const KeyType&,KeyValueCompare,KeyValuePrioCompare,insert_commit_data&)
|
||||
template<class KeyType, class KeyValueCompare, class KeyValuePrioCompare>
|
||||
//! @copydoc ::boost::intrusive::treap::insert_unique_check(const_iterator,const KeyType&,KeyTypeKeyCompare,KeyValuePrioCompare,insert_commit_data&)
|
||||
template<class KeyType, class KeyTypeKeyCompare, class KeyValuePrioCompare>
|
||||
std::pair<iterator, bool> insert_check
|
||||
( const_iterator hint, const KeyType &key
|
||||
, KeyValueCompare key_value_comp, KeyValuePrioCompare key_value_pcomp
|
||||
, KeyTypeKeyCompare comp, KeyValuePrioCompare key_value_pcomp
|
||||
, insert_commit_data &commit_data)
|
||||
{ return tree_type::insert_unique_check(hint, key, key_value_comp, key_value_pcomp, commit_data); }
|
||||
{ return tree_type::insert_unique_check(hint, key, comp, key_value_pcomp, commit_data); }
|
||||
|
||||
//! @copydoc ::boost::intrusive::treap::insert_unique(Iterator,Iterator)
|
||||
template<class Iterator>
|
||||
@@ -266,12 +281,12 @@ class treap_set_impl
|
||||
//! @copydoc ::boost::intrusive::treap::erase(const_iterator,const_iterator)
|
||||
iterator erase(const_iterator b, const_iterator e);
|
||||
|
||||
//! @copydoc ::boost::intrusive::treap::erase(const_reference)
|
||||
size_type erase(const_reference value);
|
||||
//! @copydoc ::boost::intrusive::treap::erase(const key_type &)
|
||||
size_type erase(const key_type &key);
|
||||
|
||||
//! @copydoc ::boost::intrusive::treap::erase(const KeyType&,KeyValueCompare)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
size_type erase(const KeyType& key, KeyValueCompare comp);
|
||||
//! @copydoc ::boost::intrusive::treap::erase(const KeyType&,KeyTypeKeyCompare)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
size_type erase(const KeyType& key, KeyTypeKeyCompare comp);
|
||||
|
||||
//! @copydoc ::boost::intrusive::treap::erase_and_dispose(const_iterator,Disposer)
|
||||
template<class Disposer>
|
||||
@@ -281,13 +296,13 @@ class treap_set_impl
|
||||
template<class Disposer>
|
||||
iterator erase_and_dispose(const_iterator b, const_iterator e, Disposer disposer);
|
||||
|
||||
//! @copydoc ::boost::intrusive::treap::erase_and_dispose(const_reference, Disposer)
|
||||
//! @copydoc ::boost::intrusive::treap::erase_and_dispose(const key_type &, Disposer)
|
||||
template<class Disposer>
|
||||
size_type erase_and_dispose(const_reference value, Disposer disposer);
|
||||
size_type erase_and_dispose(const key_type &key, Disposer disposer);
|
||||
|
||||
//! @copydoc ::boost::intrusive::treap::erase_and_dispose(const KeyType&,KeyValueCompare,Disposer)
|
||||
template<class KeyType, class KeyValueCompare, class Disposer>
|
||||
size_type erase_and_dispose(const KeyType& key, KeyValueCompare comp, Disposer disposer);
|
||||
//! @copydoc ::boost::intrusive::treap::erase_and_dispose(const KeyType&,KeyTypeKeyCompare,Disposer)
|
||||
template<class KeyType, class KeyTypeKeyCompare, class Disposer>
|
||||
size_type erase_and_dispose(const KeyType& key, KeyTypeKeyCompare comp, Disposer disposer);
|
||||
|
||||
//! @copydoc ::boost::intrusive::treap::clear
|
||||
void clear();
|
||||
@@ -298,100 +313,100 @@ class treap_set_impl
|
||||
|
||||
#endif // #ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
|
||||
|
||||
//! @copydoc ::boost::intrusive::treap::count(const_reference)const
|
||||
size_type count(const_reference value) const
|
||||
{ return static_cast<size_type>(this->tree_type::find(value) != this->tree_type::cend()); }
|
||||
//! @copydoc ::boost::intrusive::treap::count(const key_type &)const
|
||||
size_type count(const key_type &key) const
|
||||
{ return static_cast<size_type>(this->tree_type::find(key) != this->tree_type::cend()); }
|
||||
|
||||
//! @copydoc ::boost::intrusive::treap::count(const KeyType&,KeyValueCompare)const
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
size_type count(const KeyType& key, KeyValueCompare comp) const
|
||||
//! @copydoc ::boost::intrusive::treap::count(const KeyType&,KeyTypeKeyCompare)const
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
size_type count(const KeyType& key, KeyTypeKeyCompare comp) const
|
||||
{ return static_cast<size_type>(this->tree_type::find(key, comp) != this->tree_type::cend()); }
|
||||
|
||||
#ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
|
||||
|
||||
//! @copydoc ::boost::intrusive::treap::lower_bound(const_reference)
|
||||
iterator lower_bound(const_reference value);
|
||||
//! @copydoc ::boost::intrusive::treap::lower_bound(const key_type &)
|
||||
iterator lower_bound(const key_type &key);
|
||||
|
||||
//! @copydoc ::boost::intrusive::treap::lower_bound(const KeyType&,KeyValueCompare)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
iterator lower_bound(const KeyType& key, KeyValueCompare comp);
|
||||
//! @copydoc ::boost::intrusive::treap::lower_bound(const KeyType&,KeyTypeKeyCompare)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
iterator lower_bound(const KeyType& key, KeyTypeKeyCompare comp);
|
||||
|
||||
//! @copydoc ::boost::intrusive::treap::lower_bound(const_reference)const
|
||||
const_iterator lower_bound(const_reference value) const;
|
||||
//! @copydoc ::boost::intrusive::treap::lower_bound(const key_type &)const
|
||||
const_iterator lower_bound(const key_type &key) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::treap::lower_bound(const KeyType&,KeyValueCompare)const
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
const_iterator lower_bound(const KeyType& key, KeyValueCompare comp) const;
|
||||
//! @copydoc ::boost::intrusive::treap::lower_bound(const KeyType&,KeyTypeKeyCompare)const
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
const_iterator lower_bound(const KeyType& key, KeyTypeKeyCompare comp) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::treap::upper_bound(const_reference)
|
||||
iterator upper_bound(const_reference value);
|
||||
//! @copydoc ::boost::intrusive::treap::upper_bound(const key_type &)
|
||||
iterator upper_bound(const key_type &key);
|
||||
|
||||
//! @copydoc ::boost::intrusive::treap::upper_bound(const KeyType&,KeyValueCompare)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
iterator upper_bound(const KeyType& key, KeyValueCompare comp);
|
||||
//! @copydoc ::boost::intrusive::treap::upper_bound(const KeyType&,KeyTypeKeyCompare)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
iterator upper_bound(const KeyType& key, KeyTypeKeyCompare comp);
|
||||
|
||||
//! @copydoc ::boost::intrusive::treap::upper_bound(const_reference)const
|
||||
const_iterator upper_bound(const_reference value) const;
|
||||
//! @copydoc ::boost::intrusive::treap::upper_bound(const key_type &)const
|
||||
const_iterator upper_bound(const key_type &key) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::treap::upper_bound(const KeyType&,KeyValueCompare)const
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
const_iterator upper_bound(const KeyType& key, KeyValueCompare comp) const;
|
||||
//! @copydoc ::boost::intrusive::treap::upper_bound(const KeyType&,KeyTypeKeyCompare)const
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
const_iterator upper_bound(const KeyType& key, KeyTypeKeyCompare comp) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::treap::find(const_reference)
|
||||
iterator find(const_reference value);
|
||||
//! @copydoc ::boost::intrusive::treap::find(const key_type &)
|
||||
iterator find(const key_type &key);
|
||||
|
||||
//! @copydoc ::boost::intrusive::treap::find(const KeyType&,KeyValueCompare)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
iterator find(const KeyType& key, KeyValueCompare comp);
|
||||
//! @copydoc ::boost::intrusive::treap::find(const KeyType&,KeyTypeKeyCompare)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
iterator find(const KeyType& key, KeyTypeKeyCompare comp);
|
||||
|
||||
//! @copydoc ::boost::intrusive::treap::find(const_reference)const
|
||||
const_iterator find(const_reference value) const;
|
||||
//! @copydoc ::boost::intrusive::treap::find(const key_type &)const
|
||||
const_iterator find(const key_type &key) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::treap::find(const KeyType&,KeyValueCompare)const
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
const_iterator find(const KeyType& key, KeyValueCompare comp) const;
|
||||
//! @copydoc ::boost::intrusive::treap::find(const KeyType&,KeyTypeKeyCompare)const
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
const_iterator find(const KeyType& key, KeyTypeKeyCompare comp) const;
|
||||
|
||||
#endif // #ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
|
||||
|
||||
//! @copydoc ::boost::intrusive::rbtree::equal_range(const_reference)
|
||||
std::pair<iterator,iterator> equal_range(const_reference value)
|
||||
{ return this->tree_type::lower_bound_range(value); }
|
||||
//! @copydoc ::boost::intrusive::rbtree::equal_range(const key_type &)
|
||||
std::pair<iterator,iterator> equal_range(const key_type &key)
|
||||
{ return this->tree_type::lower_bound_range(key); }
|
||||
|
||||
//! @copydoc ::boost::intrusive::rbtree::equal_range(const KeyType&,KeyValueCompare)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
std::pair<iterator,iterator> equal_range(const KeyType& key, KeyValueCompare comp)
|
||||
//! @copydoc ::boost::intrusive::rbtree::equal_range(const KeyType&,KeyTypeKeyCompare)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
std::pair<iterator,iterator> equal_range(const KeyType& key, KeyTypeKeyCompare comp)
|
||||
{ return this->tree_type::lower_bound_range(key, comp); }
|
||||
|
||||
//! @copydoc ::boost::intrusive::rbtree::equal_range(const_reference)const
|
||||
//! @copydoc ::boost::intrusive::rbtree::equal_range(const key_type &)const
|
||||
std::pair<const_iterator, const_iterator>
|
||||
equal_range(const_reference value) const
|
||||
{ return this->tree_type::lower_bound_range(value); }
|
||||
equal_range(const key_type &key) const
|
||||
{ return this->tree_type::lower_bound_range(key); }
|
||||
|
||||
//! @copydoc ::boost::intrusive::rbtree::equal_range(const KeyType&,KeyValueCompare)const
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
//! @copydoc ::boost::intrusive::rbtree::equal_range(const KeyType&,KeyTypeKeyCompare)const
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
std::pair<const_iterator, const_iterator>
|
||||
equal_range(const KeyType& key, KeyValueCompare comp) const
|
||||
equal_range(const KeyType& key, KeyTypeKeyCompare comp) const
|
||||
{ return this->tree_type::lower_bound_range(key, comp); }
|
||||
|
||||
#ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
|
||||
|
||||
//! @copydoc ::boost::intrusive::treap::bounded_range(const_reference,const_reference,bool,bool)
|
||||
//! @copydoc ::boost::intrusive::treap::bounded_range(const key_type &,const key_type &,bool,bool)
|
||||
std::pair<iterator,iterator> bounded_range
|
||||
(const_reference lower_value, const_reference upper_value, bool left_closed, bool right_closed);
|
||||
(const key_type &lower_key, const key_type &upper_key, bool left_closed, bool right_closed);
|
||||
|
||||
//! @copydoc ::boost::intrusive::treap::bounded_range(const KeyType&,const KeyType&,KeyValueCompare,bool,bool)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
//! @copydoc ::boost::intrusive::treap::bounded_range(const KeyType&,const KeyType&,KeyTypeKeyCompare,bool,bool)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
std::pair<iterator,iterator> bounded_range
|
||||
(const KeyType& lower_key, const KeyType& upper_key, KeyValueCompare comp, bool left_closed, bool right_closed);
|
||||
(const KeyType& lower_key, const KeyType& upper_key, KeyTypeKeyCompare comp, bool left_closed, bool right_closed);
|
||||
|
||||
//! @copydoc ::boost::intrusive::treap::bounded_range(const_reference,const_reference,bool,bool)const
|
||||
//! @copydoc ::boost::intrusive::treap::bounded_range(const key_type &,const key_type &,bool,bool)const
|
||||
std::pair<const_iterator, const_iterator>
|
||||
bounded_range(const_reference lower_value, const_reference upper_value, bool left_closed, bool right_closed) const;
|
||||
bounded_range(const key_type &lower_key, const key_type &upper_key, bool left_closed, bool right_closed) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::treap::bounded_range(const KeyType&,const KeyType&,KeyValueCompare,bool,bool)const
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
//! @copydoc ::boost::intrusive::treap::bounded_range(const KeyType&,const KeyType&,KeyTypeKeyCompare,bool,bool)const
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
std::pair<const_iterator, const_iterator> bounded_range
|
||||
(const KeyType& lower_key, const KeyType& upper_key, KeyValueCompare comp, bool left_closed, bool right_closed) const;
|
||||
(const KeyType& lower_key, const KeyType& upper_key, KeyTypeKeyCompare comp, bool left_closed, bool right_closed) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::treap::s_iterator_to(reference)
|
||||
static iterator s_iterator_to(reference value);
|
||||
@@ -428,14 +443,14 @@ template<class T, class ...Options>
|
||||
#else
|
||||
template<class T, class O1 = void, class O2 = void
|
||||
, class O3 = void, class O4 = void
|
||||
, class O5 = void>
|
||||
, class O5 = void, class O6 = void>
|
||||
#endif
|
||||
struct make_treap_set
|
||||
{
|
||||
typedef typename pack_options
|
||||
< treap_defaults,
|
||||
#if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
|
||||
O1, O2, O3, O4, O5
|
||||
O1, O2, O3, O4, O5, O6
|
||||
#else
|
||||
Options...
|
||||
#endif
|
||||
@@ -446,6 +461,7 @@ struct make_treap_set
|
||||
|
||||
typedef treap_set_impl
|
||||
< value_traits
|
||||
, typename packed_options::key_of_value
|
||||
, typename packed_options::compare
|
||||
, typename packed_options::priority
|
||||
, typename packed_options::size_type
|
||||
@@ -459,14 +475,14 @@ struct make_treap_set
|
||||
#ifndef BOOST_INTRUSIVE_DOXYGEN_INVOKED
|
||||
|
||||
#if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
|
||||
template<class T, class O1, class O2, class O3, class O4, class O5>
|
||||
template<class T, class O1, class O2, class O3, class O4, class O5, class O6>
|
||||
#else
|
||||
template<class T, class ...Options>
|
||||
#endif
|
||||
class treap_set
|
||||
: public make_treap_set<T,
|
||||
#if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
|
||||
O1, O2, O3, O4, O5
|
||||
O1, O2, O3, O4, O5, O6
|
||||
#else
|
||||
Options...
|
||||
#endif
|
||||
@@ -475,7 +491,7 @@ class treap_set
|
||||
typedef typename make_treap_set
|
||||
<T,
|
||||
#if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
|
||||
O1, O2, O3, O4, O5
|
||||
O1, O2, O3, O4, O5, O6
|
||||
#else
|
||||
Options...
|
||||
#endif
|
||||
@@ -483,7 +499,7 @@ class treap_set
|
||||
BOOST_MOVABLE_BUT_NOT_COPYABLE(treap_set)
|
||||
|
||||
public:
|
||||
typedef typename Base::value_compare value_compare;
|
||||
typedef typename Base::key_compare key_compare;
|
||||
typedef typename Base::priority_compare priority_compare;
|
||||
typedef typename Base::value_traits value_traits;
|
||||
typedef typename Base::iterator iterator;
|
||||
@@ -492,7 +508,7 @@ class treap_set
|
||||
//Assert if passed value traits are compatible with the type
|
||||
BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value));
|
||||
|
||||
explicit treap_set( const value_compare &cmp = value_compare()
|
||||
explicit treap_set( const key_compare &cmp = key_compare()
|
||||
, const priority_compare &pcmp = priority_compare()
|
||||
, const value_traits &v_traits = value_traits())
|
||||
: Base(cmp, pcmp, v_traits)
|
||||
@@ -500,7 +516,7 @@ class treap_set
|
||||
|
||||
template<class Iterator>
|
||||
treap_set( Iterator b, Iterator e
|
||||
, const value_compare &cmp = value_compare()
|
||||
, const key_compare &cmp = key_compare()
|
||||
, const priority_compare &pcmp = priority_compare()
|
||||
, const value_traits &v_traits = value_traits())
|
||||
: Base(b, e, cmp, pcmp, v_traits)
|
||||
@@ -513,6 +529,14 @@ class treap_set
|
||||
treap_set& operator=(BOOST_RV_REF(treap_set) x)
|
||||
{ return static_cast<treap_set &>(this->Base::operator=(BOOST_MOVE_BASE(Base, x))); }
|
||||
|
||||
template <class Cloner, class Disposer>
|
||||
void clone_from(const treap_set &src, Cloner cloner, Disposer disposer)
|
||||
{ Base::clone_from(src, cloner, disposer); }
|
||||
|
||||
template <class Cloner, class Disposer>
|
||||
void clone_from(BOOST_RV_REF(treap_set) src, Cloner cloner, Disposer disposer)
|
||||
{ Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer); }
|
||||
|
||||
static treap_set &container_from_end_iterator(iterator end_iterator)
|
||||
{ return static_cast<treap_set &>(Base::container_from_end_iterator(end_iterator)); }
|
||||
|
||||
@@ -542,15 +566,15 @@ class treap_set
|
||||
#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED)
|
||||
template<class T, class ...Options>
|
||||
#else
|
||||
template<class ValueTraits, class VoidOrKeyComp, class VoidOrPrioComp, class SizeType, bool ConstantTimeSize, typename HeaderHolder>
|
||||
template<class ValueTraits, class VoidOrKeyOfValue, class VoidOrKeyComp, class VoidOrPrioComp, class SizeType, bool ConstantTimeSize, typename HeaderHolder>
|
||||
#endif
|
||||
class treap_multiset_impl
|
||||
#ifndef BOOST_INTRUSIVE_DOXYGEN_INVOKED
|
||||
: public treap_impl<ValueTraits, VoidOrKeyComp, VoidOrPrioComp, SizeType, ConstantTimeSize, HeaderHolder>
|
||||
: public treap_impl<ValueTraits, VoidOrKeyOfValue, VoidOrKeyComp, VoidOrPrioComp, SizeType, ConstantTimeSize, HeaderHolder>
|
||||
#endif
|
||||
{
|
||||
/// @cond
|
||||
typedef treap_impl<ValueTraits, VoidOrKeyComp, VoidOrPrioComp, SizeType, ConstantTimeSize, HeaderHolder> tree_type;
|
||||
typedef treap_impl<ValueTraits, VoidOrKeyOfValue, VoidOrKeyComp, VoidOrPrioComp, SizeType, ConstantTimeSize, HeaderHolder> tree_type;
|
||||
BOOST_MOVABLE_BUT_NOT_COPYABLE(treap_multiset_impl)
|
||||
|
||||
typedef tree_type implementation_defined;
|
||||
@@ -559,6 +583,8 @@ class treap_multiset_impl
|
||||
public:
|
||||
typedef typename implementation_defined::value_type value_type;
|
||||
typedef typename implementation_defined::value_traits value_traits;
|
||||
typedef typename implementation_defined::key_type key_type;
|
||||
typedef typename implementation_defined::key_of_value key_of_value;
|
||||
typedef typename implementation_defined::pointer pointer;
|
||||
typedef typename implementation_defined::const_pointer const_pointer;
|
||||
typedef typename implementation_defined::reference reference;
|
||||
@@ -566,8 +592,8 @@ class treap_multiset_impl
|
||||
typedef typename implementation_defined::difference_type difference_type;
|
||||
typedef typename implementation_defined::size_type size_type;
|
||||
typedef typename implementation_defined::value_compare value_compare;
|
||||
typedef typename implementation_defined::priority_compare priority_compare;
|
||||
typedef typename implementation_defined::key_compare key_compare;
|
||||
typedef typename implementation_defined::priority_compare priority_compare;
|
||||
typedef typename implementation_defined::iterator iterator;
|
||||
typedef typename implementation_defined::const_iterator const_iterator;
|
||||
typedef typename implementation_defined::reverse_iterator reverse_iterator;
|
||||
@@ -588,8 +614,8 @@ class treap_multiset_impl
|
||||
//!
|
||||
//! <b>Throws</b>: If value_traits::node_traits::node
|
||||
//! constructor throws (this does not happen with predefined Boost.Intrusive hooks)
|
||||
//! or the copy constructor of the value_compare object throws.
|
||||
explicit treap_multiset_impl( const value_compare &cmp = value_compare()
|
||||
//! or the copy constructor of the key_compare object throws.
|
||||
explicit treap_multiset_impl( const key_compare &cmp = key_compare()
|
||||
, const priority_compare &pcmp = priority_compare()
|
||||
, const value_traits &v_traits = value_traits())
|
||||
: tree_type(cmp, pcmp, v_traits)
|
||||
@@ -606,10 +632,10 @@ class treap_multiset_impl
|
||||
//!
|
||||
//! <b>Throws</b>: If value_traits::node_traits::node
|
||||
//! constructor throws (this does not happen with predefined Boost.Intrusive hooks)
|
||||
//! or the copy constructor/operator() of the value_compare object throws.
|
||||
//! or the copy constructor/operator() of the key_compare object throws.
|
||||
template<class Iterator>
|
||||
treap_multiset_impl( Iterator b, Iterator e
|
||||
, const value_compare &cmp = value_compare()
|
||||
, const key_compare &cmp = key_compare()
|
||||
, const priority_compare &pcmp = priority_compare()
|
||||
, const value_traits &v_traits = value_traits())
|
||||
: tree_type(false, b, e, cmp, pcmp, v_traits)
|
||||
@@ -693,10 +719,23 @@ class treap_multiset_impl
|
||||
//! @copydoc ::boost::intrusive::treap::swap
|
||||
void swap(treap_multiset_impl& other);
|
||||
|
||||
//! @copydoc ::boost::intrusive::treap::clone_from
|
||||
//! @copydoc ::boost::intrusive::treap::clone_from(const treap&,Cloner,Disposer)
|
||||
template <class Cloner, class Disposer>
|
||||
void clone_from(const treap_multiset_impl &src, Cloner cloner, Disposer disposer);
|
||||
|
||||
#else
|
||||
|
||||
using tree_type::clone_from;
|
||||
|
||||
#endif
|
||||
|
||||
//! @copydoc ::boost::intrusive::treap::clone_from(treap&&,Cloner,Disposer)
|
||||
template <class Cloner, class Disposer>
|
||||
void clone_from(BOOST_RV_REF(treap_multiset_impl) src, Cloner cloner, Disposer disposer)
|
||||
{ tree_type::clone_from(BOOST_MOVE_BASE(tree_type, src), cloner, disposer); }
|
||||
|
||||
#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED)
|
||||
|
||||
//! @copydoc ::boost::intrusive::treap::top()
|
||||
iterator top();
|
||||
|
||||
@@ -748,12 +787,12 @@ class treap_multiset_impl
|
||||
//! @copydoc ::boost::intrusive::treap::erase(const_iterator,const_iterator)
|
||||
iterator erase(const_iterator b, const_iterator e);
|
||||
|
||||
//! @copydoc ::boost::intrusive::treap::erase(const_reference)
|
||||
size_type erase(const_reference value);
|
||||
//! @copydoc ::boost::intrusive::treap::erase(const key_type &)
|
||||
size_type erase(const key_type &key);
|
||||
|
||||
//! @copydoc ::boost::intrusive::treap::erase(const KeyType&,KeyValueCompare)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
size_type erase(const KeyType& key, KeyValueCompare comp);
|
||||
//! @copydoc ::boost::intrusive::treap::erase(const KeyType&,KeyTypeKeyCompare)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
size_type erase(const KeyType& key, KeyTypeKeyCompare comp);
|
||||
|
||||
//! @copydoc ::boost::intrusive::treap::erase_and_dispose(const_iterator,Disposer)
|
||||
template<class Disposer>
|
||||
@@ -763,13 +802,13 @@ class treap_multiset_impl
|
||||
template<class Disposer>
|
||||
iterator erase_and_dispose(const_iterator b, const_iterator e, Disposer disposer);
|
||||
|
||||
//! @copydoc ::boost::intrusive::treap::erase_and_dispose(const_reference, Disposer)
|
||||
//! @copydoc ::boost::intrusive::treap::erase_and_dispose(const key_type &, Disposer)
|
||||
template<class Disposer>
|
||||
size_type erase_and_dispose(const_reference value, Disposer disposer);
|
||||
size_type erase_and_dispose(const key_type &key, Disposer disposer);
|
||||
|
||||
//! @copydoc ::boost::intrusive::treap::erase_and_dispose(const KeyType&,KeyValueCompare,Disposer)
|
||||
template<class KeyType, class KeyValueCompare, class Disposer>
|
||||
size_type erase_and_dispose(const KeyType& key, KeyValueCompare comp, Disposer disposer);
|
||||
//! @copydoc ::boost::intrusive::treap::erase_and_dispose(const KeyType&,KeyTypeKeyCompare,Disposer)
|
||||
template<class KeyType, class KeyTypeKeyCompare, class Disposer>
|
||||
size_type erase_and_dispose(const KeyType& key, KeyTypeKeyCompare comp, Disposer disposer);
|
||||
|
||||
//! @copydoc ::boost::intrusive::treap::clear
|
||||
void clear();
|
||||
@@ -778,88 +817,88 @@ class treap_multiset_impl
|
||||
template<class Disposer>
|
||||
void clear_and_dispose(Disposer disposer);
|
||||
|
||||
//! @copydoc ::boost::intrusive::treap::count(const_reference)const
|
||||
size_type count(const_reference value) const;
|
||||
//! @copydoc ::boost::intrusive::treap::count(const key_type &)const
|
||||
size_type count(const key_type &key) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::treap::count(const KeyType&,KeyValueCompare)const
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
size_type count(const KeyType& key, KeyValueCompare comp) const;
|
||||
//! @copydoc ::boost::intrusive::treap::count(const KeyType&,KeyTypeKeyCompare)const
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
size_type count(const KeyType& key, KeyTypeKeyCompare comp) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::treap::lower_bound(const_reference)
|
||||
iterator lower_bound(const_reference value);
|
||||
//! @copydoc ::boost::intrusive::treap::lower_bound(const key_type &)
|
||||
iterator lower_bound(const key_type &key);
|
||||
|
||||
//! @copydoc ::boost::intrusive::treap::lower_bound(const KeyType&,KeyValueCompare)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
iterator lower_bound(const KeyType& key, KeyValueCompare comp);
|
||||
//! @copydoc ::boost::intrusive::treap::lower_bound(const KeyType&,KeyTypeKeyCompare)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
iterator lower_bound(const KeyType& key, KeyTypeKeyCompare comp);
|
||||
|
||||
//! @copydoc ::boost::intrusive::treap::lower_bound(const_reference)const
|
||||
const_iterator lower_bound(const_reference value) const;
|
||||
//! @copydoc ::boost::intrusive::treap::lower_bound(const key_type &)const
|
||||
const_iterator lower_bound(const key_type &key) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::treap::lower_bound(const KeyType&,KeyValueCompare)const
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
const_iterator lower_bound(const KeyType& key, KeyValueCompare comp) const;
|
||||
//! @copydoc ::boost::intrusive::treap::lower_bound(const KeyType&,KeyTypeKeyCompare)const
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
const_iterator lower_bound(const KeyType& key, KeyTypeKeyCompare comp) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::treap::upper_bound(const_reference)
|
||||
iterator upper_bound(const_reference value);
|
||||
//! @copydoc ::boost::intrusive::treap::upper_bound(const key_type &)
|
||||
iterator upper_bound(const key_type &key);
|
||||
|
||||
//! @copydoc ::boost::intrusive::treap::upper_bound(const KeyType&,KeyValueCompare)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
iterator upper_bound(const KeyType& key, KeyValueCompare comp);
|
||||
//! @copydoc ::boost::intrusive::treap::upper_bound(const KeyType&,KeyTypeKeyCompare)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
iterator upper_bound(const KeyType& key, KeyTypeKeyCompare comp);
|
||||
|
||||
//! @copydoc ::boost::intrusive::treap::upper_bound(const_reference)const
|
||||
const_iterator upper_bound(const_reference value) const;
|
||||
//! @copydoc ::boost::intrusive::treap::upper_bound(const key_type &)const
|
||||
const_iterator upper_bound(const key_type &key) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::treap::upper_bound(const KeyType&,KeyValueCompare)const
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
const_iterator upper_bound(const KeyType& key, KeyValueCompare comp) const;
|
||||
//! @copydoc ::boost::intrusive::treap::upper_bound(const KeyType&,KeyTypeKeyCompare)const
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
const_iterator upper_bound(const KeyType& key, KeyTypeKeyCompare comp) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::treap::find(const_reference)
|
||||
iterator find(const_reference value);
|
||||
//! @copydoc ::boost::intrusive::treap::find(const key_type &)
|
||||
iterator find(const key_type &key);
|
||||
|
||||
//! @copydoc ::boost::intrusive::treap::find(const KeyType&,KeyValueCompare)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
iterator find(const KeyType& key, KeyValueCompare comp);
|
||||
//! @copydoc ::boost::intrusive::treap::find(const KeyType&,KeyTypeKeyCompare)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
iterator find(const KeyType& key, KeyTypeKeyCompare comp);
|
||||
|
||||
//! @copydoc ::boost::intrusive::treap::find(const_reference)const
|
||||
const_iterator find(const_reference value) const;
|
||||
//! @copydoc ::boost::intrusive::treap::find(const key_type &)const
|
||||
const_iterator find(const key_type &key) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::treap::find(const KeyType&,KeyValueCompare)const
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
const_iterator find(const KeyType& key, KeyValueCompare comp) const;
|
||||
//! @copydoc ::boost::intrusive::treap::find(const KeyType&,KeyTypeKeyCompare)const
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
const_iterator find(const KeyType& key, KeyTypeKeyCompare comp) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::treap::equal_range(const_reference)
|
||||
std::pair<iterator,iterator> equal_range(const_reference value);
|
||||
//! @copydoc ::boost::intrusive::treap::equal_range(const key_type &)
|
||||
std::pair<iterator,iterator> equal_range(const key_type &key);
|
||||
|
||||
//! @copydoc ::boost::intrusive::treap::equal_range(const KeyType&,KeyValueCompare)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
std::pair<iterator,iterator> equal_range(const KeyType& key, KeyValueCompare comp);
|
||||
//! @copydoc ::boost::intrusive::treap::equal_range(const KeyType&,KeyTypeKeyCompare)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
std::pair<iterator,iterator> equal_range(const KeyType& key, KeyTypeKeyCompare comp);
|
||||
|
||||
//! @copydoc ::boost::intrusive::treap::equal_range(const_reference)const
|
||||
//! @copydoc ::boost::intrusive::treap::equal_range(const key_type &)const
|
||||
std::pair<const_iterator, const_iterator>
|
||||
equal_range(const_reference value) const;
|
||||
equal_range(const key_type &key) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::treap::equal_range(const KeyType&,KeyValueCompare)const
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
//! @copydoc ::boost::intrusive::treap::equal_range(const KeyType&,KeyTypeKeyCompare)const
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
std::pair<const_iterator, const_iterator>
|
||||
equal_range(const KeyType& key, KeyValueCompare comp) const;
|
||||
equal_range(const KeyType& key, KeyTypeKeyCompare comp) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::treap::bounded_range(const_reference,const_reference,bool,bool)
|
||||
//! @copydoc ::boost::intrusive::treap::bounded_range(const key_type &,const key_type &,bool,bool)
|
||||
std::pair<iterator,iterator> bounded_range
|
||||
(const_reference lower_value, const_reference upper_value, bool left_closed, bool right_closed);
|
||||
(const key_type &lower_key, const key_type &upper_key, bool left_closed, bool right_closed);
|
||||
|
||||
//! @copydoc ::boost::intrusive::treap::bounded_range(const KeyType&,const KeyType&,KeyValueCompare,bool,bool)
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
//! @copydoc ::boost::intrusive::treap::bounded_range(const KeyType&,const KeyType&,KeyTypeKeyCompare,bool,bool)
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
std::pair<iterator,iterator> bounded_range
|
||||
(const KeyType& lower_key, const KeyType& upper_key, KeyValueCompare comp, bool left_closed, bool right_closed);
|
||||
(const KeyType& lower_key, const KeyType& upper_key, KeyTypeKeyCompare comp, bool left_closed, bool right_closed);
|
||||
|
||||
//! @copydoc ::boost::intrusive::treap::bounded_range(const_reference,const_reference,bool,bool)const
|
||||
//! @copydoc ::boost::intrusive::treap::bounded_range(const key_type &,const key_type &,bool,bool)const
|
||||
std::pair<const_iterator, const_iterator>
|
||||
bounded_range(const_reference lower_value, const_reference upper_value, bool left_closed, bool right_closed) const;
|
||||
bounded_range(const key_type &lower_key, const key_type &upper_key, bool left_closed, bool right_closed) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::treap::bounded_range(const KeyType&,const KeyType&,KeyValueCompare,bool,bool)const
|
||||
template<class KeyType, class KeyValueCompare>
|
||||
//! @copydoc ::boost::intrusive::treap::bounded_range(const KeyType&,const KeyType&,KeyTypeKeyCompare,bool,bool)const
|
||||
template<class KeyType, class KeyTypeKeyCompare>
|
||||
std::pair<const_iterator, const_iterator> bounded_range
|
||||
(const KeyType& lower_key, const KeyType& upper_key, KeyValueCompare comp, bool left_closed, bool right_closed) const;
|
||||
(const KeyType& lower_key, const KeyType& upper_key, KeyTypeKeyCompare comp, bool left_closed, bool right_closed) const;
|
||||
|
||||
//! @copydoc ::boost::intrusive::treap::s_iterator_to(reference)
|
||||
static iterator s_iterator_to(reference value);
|
||||
@@ -896,14 +935,14 @@ template<class T, class ...Options>
|
||||
#else
|
||||
template<class T, class O1 = void, class O2 = void
|
||||
, class O3 = void, class O4 = void
|
||||
, class O5 = void>
|
||||
, class O5 = void, class O6 = void>
|
||||
#endif
|
||||
struct make_treap_multiset
|
||||
{
|
||||
typedef typename pack_options
|
||||
< treap_defaults,
|
||||
#if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
|
||||
O1, O2, O3, O4, O5
|
||||
O1, O2, O3, O4, O5, O6
|
||||
#else
|
||||
Options...
|
||||
#endif
|
||||
@@ -914,6 +953,7 @@ struct make_treap_multiset
|
||||
|
||||
typedef treap_multiset_impl
|
||||
< value_traits
|
||||
, typename packed_options::key_of_value
|
||||
, typename packed_options::compare
|
||||
, typename packed_options::priority
|
||||
, typename packed_options::size_type
|
||||
@@ -927,14 +967,14 @@ struct make_treap_multiset
|
||||
#ifndef BOOST_INTRUSIVE_DOXYGEN_INVOKED
|
||||
|
||||
#if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
|
||||
template<class T, class O1, class O2, class O3, class O4, class O5>
|
||||
template<class T, class O1, class O2, class O3, class O4, class O5, class O6>
|
||||
#else
|
||||
template<class T, class ...Options>
|
||||
#endif
|
||||
class treap_multiset
|
||||
: public make_treap_multiset<T,
|
||||
#if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
|
||||
O1, O2, O3, O4, O5
|
||||
O1, O2, O3, O4, O5, O6
|
||||
#else
|
||||
Options...
|
||||
#endif
|
||||
@@ -943,7 +983,7 @@ class treap_multiset
|
||||
typedef typename make_treap_multiset
|
||||
<T,
|
||||
#if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
|
||||
O1, O2, O3, O4, O5
|
||||
O1, O2, O3, O4, O5, O6
|
||||
#else
|
||||
Options...
|
||||
#endif
|
||||
@@ -951,7 +991,7 @@ class treap_multiset
|
||||
BOOST_MOVABLE_BUT_NOT_COPYABLE(treap_multiset)
|
||||
|
||||
public:
|
||||
typedef typename Base::value_compare value_compare;
|
||||
typedef typename Base::key_compare key_compare;
|
||||
typedef typename Base::priority_compare priority_compare;
|
||||
typedef typename Base::value_traits value_traits;
|
||||
typedef typename Base::iterator iterator;
|
||||
@@ -960,7 +1000,7 @@ class treap_multiset
|
||||
//Assert if passed value traits are compatible with the type
|
||||
BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value));
|
||||
|
||||
explicit treap_multiset( const value_compare &cmp = value_compare()
|
||||
explicit treap_multiset( const key_compare &cmp = key_compare()
|
||||
, const priority_compare &pcmp = priority_compare()
|
||||
, const value_traits &v_traits = value_traits())
|
||||
: Base(cmp, pcmp, v_traits)
|
||||
@@ -968,7 +1008,7 @@ class treap_multiset
|
||||
|
||||
template<class Iterator>
|
||||
treap_multiset( Iterator b, Iterator e
|
||||
, const value_compare &cmp = value_compare()
|
||||
, const key_compare &cmp = key_compare()
|
||||
, const priority_compare &pcmp = priority_compare()
|
||||
, const value_traits &v_traits = value_traits())
|
||||
: Base(b, e, cmp, pcmp, v_traits)
|
||||
@@ -981,6 +1021,14 @@ class treap_multiset
|
||||
treap_multiset& operator=(BOOST_RV_REF(treap_multiset) x)
|
||||
{ return static_cast<treap_multiset &>(this->Base::operator=(BOOST_MOVE_BASE(Base, x))); }
|
||||
|
||||
template <class Cloner, class Disposer>
|
||||
void clone_from(const treap_multiset &src, Cloner cloner, Disposer disposer)
|
||||
{ Base::clone_from(src, cloner, disposer); }
|
||||
|
||||
template <class Cloner, class Disposer>
|
||||
void clone_from(BOOST_RV_REF(treap_multiset) src, Cloner cloner, Disposer disposer)
|
||||
{ Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer); }
|
||||
|
||||
static treap_multiset &container_from_end_iterator(iterator end_iterator)
|
||||
{ return static_cast<treap_multiset &>(Base::container_from_end_iterator(end_iterator)); }
|
||||
|
||||
|
||||
File diff suppressed because it is too large.
Load diff
Reference in new issue
Block a user