boost_mirror/intrusive
1
0
Fork 0
mirror of https://github.com/boostorg/intrusive.git synced 2025-05-11 05:07:46 +00:00
Code Issues Packages Projects Releases Wiki Activity

Reduce the usage of BOOST_INTRUSIVE_FORCEINLINE due to unwanted side effects in some compilers

Browse Source
This commit is contained in:
Ion Gaztañaga 2023-05-02 01:30:31 +02:00
parent 64b7cb317d
commit ff11320469
46 changed files with 933 additions and 936 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

44
include/boost/intrusive/avl_set.hpp
View File

@ -525,46 +525,46 @@ class avl_set
//Assert if passed value traits are compatible with the type //Assert if passed value traits are compatible with the type
BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value)); BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value));
BOOST_INTRUSIVE_FORCEINLINE avl_set() inline avl_set()
: Base() : Base()
{} {}
BOOST_INTRUSIVE_FORCEINLINE explicit avl_set( const key_compare &cmp, const value_traits &v_traits = value_traits()) inline explicit avl_set( const key_compare &cmp, const value_traits &v_traits = value_traits())
: Base(cmp, v_traits) : Base(cmp, v_traits)
{} {}
template<class Iterator> template<class Iterator>
BOOST_INTRUSIVE_FORCEINLINE avl_set( Iterator b, Iterator e inline avl_set( Iterator b, Iterator e
, const key_compare &cmp = key_compare() , const key_compare &cmp = key_compare()
, const value_traits &v_traits = value_traits()) , const value_traits &v_traits = value_traits())
: Base(b, e, cmp, v_traits) : Base(b, e, cmp, v_traits)
{} {}
BOOST_INTRUSIVE_FORCEINLINE avl_set(BOOST_RV_REF(avl_set) x) inline avl_set(BOOST_RV_REF(avl_set) x)
: Base(BOOST_MOVE_BASE(Base, x)) : Base(BOOST_MOVE_BASE(Base, x))
{} {}
BOOST_INTRUSIVE_FORCEINLINE avl_set& operator=(BOOST_RV_REF(avl_set) x) inline avl_set& operator=(BOOST_RV_REF(avl_set) x)
{ return static_cast<avl_set &>(this->Base::operator=(BOOST_MOVE_BASE(Base, x))); } { return static_cast<avl_set &>(this->Base::operator=(BOOST_MOVE_BASE(Base, x))); }
template <class Cloner, class Disposer> template <class Cloner, class Disposer>
BOOST_INTRUSIVE_FORCEINLINE void clone_from(const avl_set &src, Cloner cloner, Disposer disposer) inline void clone_from(const avl_set &src, Cloner cloner, Disposer disposer)
{ Base::clone_from(src, cloner, disposer); } { Base::clone_from(src, cloner, disposer); }
template <class Cloner, class Disposer> template <class Cloner, class Disposer>
BOOST_INTRUSIVE_FORCEINLINE void clone_from(BOOST_RV_REF(avl_set) src, Cloner cloner, Disposer disposer) inline void clone_from(BOOST_RV_REF(avl_set) src, Cloner cloner, Disposer disposer)
{ Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer); } { Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer); }
BOOST_INTRUSIVE_FORCEINLINE static avl_set &container_from_end_iterator(iterator end_iterator) BOOST_NOEXCEPT inline static avl_set &container_from_end_iterator(iterator end_iterator) BOOST_NOEXCEPT
{ return static_cast<avl_set &>(Base::container_from_end_iterator(end_iterator)); } { return static_cast<avl_set &>(Base::container_from_end_iterator(end_iterator)); }
BOOST_INTRUSIVE_FORCEINLINE static const avl_set &container_from_end_iterator(const_iterator end_iterator) BOOST_NOEXCEPT inline static const avl_set &container_from_end_iterator(const_iterator end_iterator) BOOST_NOEXCEPT
{ return static_cast<const avl_set &>(Base::container_from_end_iterator(end_iterator)); } { return static_cast<const avl_set &>(Base::container_from_end_iterator(end_iterator)); }
BOOST_INTRUSIVE_FORCEINLINE static avl_set &container_from_iterator(iterator it) BOOST_NOEXCEPT inline static avl_set &container_from_iterator(iterator it) BOOST_NOEXCEPT
{ return static_cast<avl_set &>(Base::container_from_iterator(it)); } { return static_cast<avl_set &>(Base::container_from_iterator(it)); }
BOOST_INTRUSIVE_FORCEINLINE static const avl_set &container_from_iterator(const_iterator it) BOOST_NOEXCEPT inline static const avl_set &container_from_iterator(const_iterator it) BOOST_NOEXCEPT
{ return static_cast<const avl_set &>(Base::container_from_iterator(it)); } { return static_cast<const avl_set &>(Base::container_from_iterator(it)); }
}; };
@ -1020,46 +1020,46 @@ class avl_multiset
//Assert if passed value traits are compatible with the type //Assert if passed value traits are compatible with the type
BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value)); BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value));
BOOST_INTRUSIVE_FORCEINLINE avl_multiset() inline avl_multiset()
: Base() : Base()
{} {}
BOOST_INTRUSIVE_FORCEINLINE explicit avl_multiset( const key_compare &cmp, const value_traits &v_traits = value_traits()) inline explicit avl_multiset( const key_compare &cmp, const value_traits &v_traits = value_traits())
: Base(cmp, v_traits) : Base(cmp, v_traits)
{} {}
template<class Iterator> template<class Iterator>
BOOST_INTRUSIVE_FORCEINLINE avl_multiset( Iterator b, Iterator e inline avl_multiset( Iterator b, Iterator e
, const key_compare &cmp = key_compare() , const key_compare &cmp = key_compare()
, const value_traits &v_traits = value_traits()) , const value_traits &v_traits = value_traits())
: Base(b, e, cmp, v_traits) : Base(b, e, cmp, v_traits)
{} {}
BOOST_INTRUSIVE_FORCEINLINE avl_multiset(BOOST_RV_REF(avl_multiset) x) inline avl_multiset(BOOST_RV_REF(avl_multiset) x)
: Base(BOOST_MOVE_BASE(Base, x)) : Base(BOOST_MOVE_BASE(Base, x))
{} {}
BOOST_INTRUSIVE_FORCEINLINE avl_multiset& operator=(BOOST_RV_REF(avl_multiset) x) inline avl_multiset& operator=(BOOST_RV_REF(avl_multiset) x)
{ return static_cast<avl_multiset &>(this->Base::operator=(BOOST_MOVE_BASE(Base, x))); } { return static_cast<avl_multiset &>(this->Base::operator=(BOOST_MOVE_BASE(Base, x))); }
template <class Cloner, class Disposer> template <class Cloner, class Disposer>
BOOST_INTRUSIVE_FORCEINLINE void clone_from(const avl_multiset &src, Cloner cloner, Disposer disposer) inline void clone_from(const avl_multiset &src, Cloner cloner, Disposer disposer)
{ Base::clone_from(src, cloner, disposer); } { Base::clone_from(src, cloner, disposer); }
template <class Cloner, class Disposer> template <class Cloner, class Disposer>
BOOST_INTRUSIVE_FORCEINLINE void clone_from(BOOST_RV_REF(avl_multiset) src, Cloner cloner, Disposer disposer) inline void clone_from(BOOST_RV_REF(avl_multiset) src, Cloner cloner, Disposer disposer)
{ Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer); } { Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer); }
BOOST_INTRUSIVE_FORCEINLINE static avl_multiset &container_from_end_iterator(iterator end_iterator) BOOST_NOEXCEPT inline static avl_multiset &container_from_end_iterator(iterator end_iterator) BOOST_NOEXCEPT
{ return static_cast<avl_multiset &>(Base::container_from_end_iterator(end_iterator)); } { return static_cast<avl_multiset &>(Base::container_from_end_iterator(end_iterator)); }
BOOST_INTRUSIVE_FORCEINLINE static const avl_multiset &container_from_end_iterator(const_iterator end_iterator) BOOST_NOEXCEPT inline static const avl_multiset &container_from_end_iterator(const_iterator end_iterator) BOOST_NOEXCEPT
{ return static_cast<const avl_multiset &>(Base::container_from_end_iterator(end_iterator)); } { return static_cast<const avl_multiset &>(Base::container_from_end_iterator(end_iterator)); }
BOOST_INTRUSIVE_FORCEINLINE static avl_multiset &container_from_iterator(iterator it) BOOST_NOEXCEPT inline static avl_multiset &container_from_iterator(iterator it) BOOST_NOEXCEPT
{ return static_cast<avl_multiset &>(Base::container_from_iterator(it)); } { return static_cast<avl_multiset &>(Base::container_from_iterator(it)); }
BOOST_INTRUSIVE_FORCEINLINE static const avl_multiset &container_from_iterator(const_iterator it) BOOST_NOEXCEPT inline static const avl_multiset &container_from_iterator(const_iterator it) BOOST_NOEXCEPT
{ return static_cast<const avl_multiset &>(Base::container_from_iterator(it)); } { return static_cast<const avl_multiset &>(Base::container_from_iterator(it)); }
}; };

22
include/boost/intrusive/avltree.hpp
View File

@ -535,46 +535,46 @@ class avltree
//Assert if passed value traits are compatible with the type //Assert if passed value traits are compatible with the type
BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value)); BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value));
BOOST_INTRUSIVE_FORCEINLINE avltree() inline avltree()
: Base() : Base()
{} {}
BOOST_INTRUSIVE_FORCEINLINE explicit avltree( const key_compare &cmp, const value_traits &v_traits = value_traits()) inline explicit avltree( const key_compare &cmp, const value_traits &v_traits = value_traits())
: Base(cmp, v_traits) : Base(cmp, v_traits)
{} {}
template<class Iterator> template<class Iterator>
BOOST_INTRUSIVE_FORCEINLINE avltree( bool unique, Iterator b, Iterator e inline avltree( bool unique, Iterator b, Iterator e
, const key_compare &cmp = key_compare() , const key_compare &cmp = key_compare()
, const value_traits &v_traits = value_traits()) , const value_traits &v_traits = value_traits())
: Base(unique, b, e, cmp, v_traits) : Base(unique, b, e, cmp, v_traits)
{} {}
BOOST_INTRUSIVE_FORCEINLINE avltree(BOOST_RV_REF(avltree) x) inline avltree(BOOST_RV_REF(avltree) x)
: Base(BOOST_MOVE_BASE(Base, x)) : Base(BOOST_MOVE_BASE(Base, x))
{} {}
BOOST_INTRUSIVE_FORCEINLINE avltree& operator=(BOOST_RV_REF(avltree) x) inline avltree& operator=(BOOST_RV_REF(avltree) x)
{ return static_cast<avltree &>(this->Base::operator=(BOOST_MOVE_BASE(Base, x))); } { return static_cast<avltree &>(this->Base::operator=(BOOST_MOVE_BASE(Base, x))); }
template <class Cloner, class Disposer> template <class Cloner, class Disposer>
BOOST_INTRUSIVE_FORCEINLINE void clone_from(const avltree &src, Cloner cloner, Disposer disposer) inline void clone_from(const avltree &src, Cloner cloner, Disposer disposer)
{ Base::clone_from(src, cloner, disposer); } { Base::clone_from(src, cloner, disposer); }
template <class Cloner, class Disposer> template <class Cloner, class Disposer>
BOOST_INTRUSIVE_FORCEINLINE void clone_from(BOOST_RV_REF(avltree) src, Cloner cloner, Disposer disposer) inline void clone_from(BOOST_RV_REF(avltree) src, Cloner cloner, Disposer disposer)
{ Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer); } { Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer); }
BOOST_INTRUSIVE_FORCEINLINE static avltree &container_from_end_iterator(iterator end_iterator) BOOST_NOEXCEPT inline static avltree &container_from_end_iterator(iterator end_iterator) BOOST_NOEXCEPT
{ return static_cast<avltree &>(Base::container_from_end_iterator(end_iterator)); } { return static_cast<avltree &>(Base::container_from_end_iterator(end_iterator)); }
BOOST_INTRUSIVE_FORCEINLINE static const avltree &container_from_end_iterator(const_iterator end_iterator) BOOST_NOEXCEPT inline static const avltree &container_from_end_iterator(const_iterator end_iterator) BOOST_NOEXCEPT
{ return static_cast<const avltree &>(Base::container_from_end_iterator(end_iterator)); } { return static_cast<const avltree &>(Base::container_from_end_iterator(end_iterator)); }
BOOST_INTRUSIVE_FORCEINLINE static avltree &container_from_iterator(iterator it) BOOST_NOEXCEPT inline static avltree &container_from_iterator(iterator it) BOOST_NOEXCEPT
{ return static_cast<avltree &>(Base::container_from_iterator(it)); } { return static_cast<avltree &>(Base::container_from_iterator(it)); }
BOOST_INTRUSIVE_FORCEINLINE static const avltree &container_from_iterator(const_iterator it) BOOST_NOEXCEPT inline static const avltree &container_from_iterator(const_iterator it) BOOST_NOEXCEPT
{ return static_cast<const avltree &>(Base::container_from_iterator(it)); } { return static_cast<const avltree &>(Base::container_from_iterator(it)); }
}; };

2
include/boost/intrusive/avltree_algorithms.hpp
View File

@ -42,7 +42,7 @@ struct avltree_node_cloner
typedef typename NodeTraits::node_ptr node_ptr; typedef typename NodeTraits::node_ptr node_ptr;
typedef detail::ebo_functor_holder<F> base_t; typedef detail::ebo_functor_holder<F> base_t;
BOOST_INTRUSIVE_FORCEINLINE avltree_node_cloner(F f) inline avltree_node_cloner(F f)
: base_t(f) : base_t(f)
{} {}

44
include/boost/intrusive/bs_set.hpp
View File

@ -522,46 +522,46 @@ class bs_set
//Assert if passed value traits are compatible with the type //Assert if passed value traits are compatible with the type
BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value)); BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value));
BOOST_INTRUSIVE_FORCEINLINE bs_set() inline bs_set()
: Base() : Base()
{} {}
BOOST_INTRUSIVE_FORCEINLINE explicit bs_set( const key_compare &cmp, const value_traits &v_traits = value_traits()) inline explicit bs_set( const key_compare &cmp, const value_traits &v_traits = value_traits())
: Base(cmp, v_traits) : Base(cmp, v_traits)
{} {}
template<class Iterator> template<class Iterator>
BOOST_INTRUSIVE_FORCEINLINE bs_set( Iterator b, Iterator e inline bs_set( Iterator b, Iterator e
, const key_compare &cmp = key_compare() , const key_compare &cmp = key_compare()
, const value_traits &v_traits = value_traits()) , const value_traits &v_traits = value_traits())
: Base(b, e, cmp, v_traits) : Base(b, e, cmp, v_traits)
{} {}
BOOST_INTRUSIVE_FORCEINLINE bs_set(BOOST_RV_REF(bs_set) x) inline bs_set(BOOST_RV_REF(bs_set) x)
: Base(BOOST_MOVE_BASE(Base, x)) : Base(BOOST_MOVE_BASE(Base, x))
{} {}
BOOST_INTRUSIVE_FORCEINLINE bs_set& operator=(BOOST_RV_REF(bs_set) x) inline bs_set& operator=(BOOST_RV_REF(bs_set) x)
{ return static_cast<bs_set &>(this->Base::operator=(BOOST_MOVE_BASE(Base, x))); } { return static_cast<bs_set &>(this->Base::operator=(BOOST_MOVE_BASE(Base, x))); }
template <class Cloner, class Disposer> template <class Cloner, class Disposer>
BOOST_INTRUSIVE_FORCEINLINE void clone_from(const bs_set &src, Cloner cloner, Disposer disposer) inline void clone_from(const bs_set &src, Cloner cloner, Disposer disposer)
{ Base::clone_from(src, cloner, disposer); } { Base::clone_from(src, cloner, disposer); }
template <class Cloner, class Disposer> template <class Cloner, class Disposer>
BOOST_INTRUSIVE_FORCEINLINE void clone_from(BOOST_RV_REF(bs_set) src, Cloner cloner, Disposer disposer) inline void clone_from(BOOST_RV_REF(bs_set) src, Cloner cloner, Disposer disposer)
{ Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer); } { Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer); }
BOOST_INTRUSIVE_FORCEINLINE static bs_set &container_from_end_iterator(iterator end_iterator) BOOST_NOEXCEPT inline static bs_set &container_from_end_iterator(iterator end_iterator) BOOST_NOEXCEPT
{ return static_cast<bs_set &>(Base::container_from_end_iterator(end_iterator)); } { return static_cast<bs_set &>(Base::container_from_end_iterator(end_iterator)); }
BOOST_INTRUSIVE_FORCEINLINE static const bs_set &container_from_end_iterator(const_iterator end_iterator) BOOST_NOEXCEPT inline static const bs_set &container_from_end_iterator(const_iterator end_iterator) BOOST_NOEXCEPT
{ return static_cast<const bs_set &>(Base::container_from_end_iterator(end_iterator)); } { return static_cast<const bs_set &>(Base::container_from_end_iterator(end_iterator)); }
BOOST_INTRUSIVE_FORCEINLINE static bs_set &container_from_iterator(iterator it) BOOST_NOEXCEPT inline static bs_set &container_from_iterator(iterator it) BOOST_NOEXCEPT
{ return static_cast<bs_set &>(Base::container_from_iterator(it)); } { return static_cast<bs_set &>(Base::container_from_iterator(it)); }
BOOST_INTRUSIVE_FORCEINLINE static const bs_set &container_from_iterator(const_iterator it) BOOST_NOEXCEPT inline static const bs_set &container_from_iterator(const_iterator it) BOOST_NOEXCEPT
{ return static_cast<const bs_set &>(Base::container_from_iterator(it)); } { return static_cast<const bs_set &>(Base::container_from_iterator(it)); }
}; };
@ -1016,46 +1016,46 @@ class bs_multiset
//Assert if passed value traits are compatible with the type //Assert if passed value traits are compatible with the type
BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value)); BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value));
BOOST_INTRUSIVE_FORCEINLINE bs_multiset() inline bs_multiset()
: Base() : Base()
{} {}
BOOST_INTRUSIVE_FORCEINLINE explicit bs_multiset( const key_compare &cmp, const value_traits &v_traits = value_traits()) inline explicit bs_multiset( const key_compare &cmp, const value_traits &v_traits = value_traits())
: Base(cmp, v_traits) : Base(cmp, v_traits)
{} {}
template<class Iterator> template<class Iterator>
BOOST_INTRUSIVE_FORCEINLINE bs_multiset( Iterator b, Iterator e inline bs_multiset( Iterator b, Iterator e
, const key_compare &cmp = key_compare() , const key_compare &cmp = key_compare()
, const value_traits &v_traits = value_traits()) , const value_traits &v_traits = value_traits())
: Base(b, e, cmp, v_traits) : Base(b, e, cmp, v_traits)
{} {}
BOOST_INTRUSIVE_FORCEINLINE bs_multiset(BOOST_RV_REF(bs_multiset) x) inline bs_multiset(BOOST_RV_REF(bs_multiset) x)
: Base(BOOST_MOVE_BASE(Base, x)) : Base(BOOST_MOVE_BASE(Base, x))
{} {}
BOOST_INTRUSIVE_FORCEINLINE bs_multiset& operator=(BOOST_RV_REF(bs_multiset) x) inline bs_multiset& operator=(BOOST_RV_REF(bs_multiset) x)
{ return static_cast<bs_multiset &>(this->Base::operator=(BOOST_MOVE_BASE(Base, x))); } { return static_cast<bs_multiset &>(this->Base::operator=(BOOST_MOVE_BASE(Base, x))); }
template <class Cloner, class Disposer> template <class Cloner, class Disposer>
BOOST_INTRUSIVE_FORCEINLINE void clone_from(const bs_multiset &src, Cloner cloner, Disposer disposer) inline void clone_from(const bs_multiset &src, Cloner cloner, Disposer disposer)
{ Base::clone_from(src, cloner, disposer); } { Base::clone_from(src, cloner, disposer); }
template <class Cloner, class Disposer> template <class Cloner, class Disposer>
BOOST_INTRUSIVE_FORCEINLINE void clone_from(BOOST_RV_REF(bs_multiset) src, Cloner cloner, Disposer disposer) inline void clone_from(BOOST_RV_REF(bs_multiset) src, Cloner cloner, Disposer disposer)
{ Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer); } { Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer); }
BOOST_INTRUSIVE_FORCEINLINE static bs_multiset &container_from_end_iterator(iterator end_iterator) BOOST_NOEXCEPT inline static bs_multiset &container_from_end_iterator(iterator end_iterator) BOOST_NOEXCEPT
{ return static_cast<bs_multiset &>(Base::container_from_end_iterator(end_iterator)); } { return static_cast<bs_multiset &>(Base::container_from_end_iterator(end_iterator)); }
BOOST_INTRUSIVE_FORCEINLINE static const bs_multiset &container_from_end_iterator(const_iterator end_iterator) BOOST_NOEXCEPT inline static const bs_multiset &container_from_end_iterator(const_iterator end_iterator) BOOST_NOEXCEPT
{ return static_cast<const bs_multiset &>(Base::container_from_end_iterator(end_iterator)); } { return static_cast<const bs_multiset &>(Base::container_from_end_iterator(end_iterator)); }
BOOST_INTRUSIVE_FORCEINLINE static bs_multiset &container_from_iterator(iterator it) BOOST_NOEXCEPT inline static bs_multiset &container_from_iterator(iterator it) BOOST_NOEXCEPT
{ return static_cast<bs_multiset &>(Base::container_from_iterator(it)); } { return static_cast<bs_multiset &>(Base::container_from_iterator(it)); }
BOOST_INTRUSIVE_FORCEINLINE static const bs_multiset &container_from_iterator(const_iterator it) BOOST_NOEXCEPT inline static const bs_multiset &container_from_iterator(const_iterator it) BOOST_NOEXCEPT
{ return static_cast<const bs_multiset &>(Base::container_from_iterator(it)); } { return static_cast<const bs_multiset &>(Base::container_from_iterator(it)); }
}; };

118
include/boost/intrusive/bstree.hpp
View File

@ -105,7 +105,7 @@ struct bstbase3
struct holder_t : public ValueTraits struct holder_t : public ValueTraits
{ {
BOOST_INTRUSIVE_FORCEINLINE explicit holder_t(const ValueTraits &vtraits) inline explicit holder_t(const ValueTraits &vtraits)
: ValueTraits(vtraits) : ValueTraits(vtraits)
{} {}
header_holder_type root; header_holder_type root;
@ -121,73 +121,73 @@ struct bstbase3
return *base; return *base;
} }
BOOST_INTRUSIVE_FORCEINLINE bstbase3(const ValueTraits &vtraits) inline bstbase3(const ValueTraits &vtraits)
: holder(vtraits) : holder(vtraits)
{ {
node_algorithms::init_header(this->header_ptr()); node_algorithms::init_header(this->header_ptr());
} }
BOOST_INTRUSIVE_FORCEINLINE node_ptr header_ptr() inline node_ptr header_ptr()
{ return holder.root.get_node(); } { return holder.root.get_node(); }
BOOST_INTRUSIVE_FORCEINLINE const_node_ptr header_ptr() const inline const_node_ptr header_ptr() const
{ return holder.root.get_node(); } { return holder.root.get_node(); }
BOOST_INTRUSIVE_FORCEINLINE const value_traits &get_value_traits() const inline const value_traits &get_value_traits() const
{ return this->holder; } { return this->holder; }
BOOST_INTRUSIVE_FORCEINLINE value_traits &get_value_traits() inline value_traits &get_value_traits()
{ return this->holder; } { return this->holder; }
typedef typename boost::intrusive::value_traits_pointers typedef typename boost::intrusive::value_traits_pointers
<ValueTraits>::const_value_traits_ptr const_value_traits_ptr; <ValueTraits>::const_value_traits_ptr const_value_traits_ptr;
BOOST_INTRUSIVE_FORCEINLINE const_value_traits_ptr priv_value_traits_ptr() const inline const_value_traits_ptr priv_value_traits_ptr() const
{ return pointer_traits<const_value_traits_ptr>::pointer_to(this->get_value_traits()); } { return pointer_traits<const_value_traits_ptr>::pointer_to(this->get_value_traits()); }
BOOST_INTRUSIVE_FORCEINLINE iterator begin() BOOST_NOEXCEPT inline iterator begin() BOOST_NOEXCEPT
{ return iterator(node_algorithms::begin_node(this->header_ptr()), this->priv_value_traits_ptr()); } { return iterator(node_algorithms::begin_node(this->header_ptr()), this->priv_value_traits_ptr()); }
BOOST_INTRUSIVE_FORCEINLINE const_iterator begin() const BOOST_NOEXCEPT inline const_iterator begin() const BOOST_NOEXCEPT
{ return cbegin(); } { return cbegin(); }
BOOST_INTRUSIVE_FORCEINLINE const_iterator cbegin() const BOOST_NOEXCEPT inline const_iterator cbegin() const BOOST_NOEXCEPT
{ return const_iterator(node_algorithms::begin_node(this->header_ptr()), this->priv_value_traits_ptr()); } { return const_iterator(node_algorithms::begin_node(this->header_ptr()), this->priv_value_traits_ptr()); }
BOOST_INTRUSIVE_FORCEINLINE iterator end() BOOST_NOEXCEPT inline iterator end() BOOST_NOEXCEPT
{ return iterator(node_algorithms::end_node(this->header_ptr()), this->priv_value_traits_ptr()); } { return iterator(node_algorithms::end_node(this->header_ptr()), this->priv_value_traits_ptr()); }
BOOST_INTRUSIVE_FORCEINLINE const_iterator end() const BOOST_NOEXCEPT inline const_iterator end() const BOOST_NOEXCEPT
{ return cend(); } { return cend(); }
BOOST_INTRUSIVE_FORCEINLINE const_iterator cend() const BOOST_NOEXCEPT inline const_iterator cend() const BOOST_NOEXCEPT
{ return const_iterator(node_algorithms::end_node(this->header_ptr()), this->priv_value_traits_ptr()); } { return const_iterator(node_algorithms::end_node(this->header_ptr()), this->priv_value_traits_ptr()); }
BOOST_INTRUSIVE_FORCEINLINE iterator root() inline iterator root()
{ return iterator(node_algorithms::root_node(this->header_ptr()), this->priv_value_traits_ptr()); } { return iterator(node_algorithms::root_node(this->header_ptr()), this->priv_value_traits_ptr()); }
BOOST_INTRUSIVE_FORCEINLINE const_iterator root() const inline const_iterator root() const
{ return croot(); } { return croot(); }
BOOST_INTRUSIVE_FORCEINLINE const_iterator croot() const inline const_iterator croot() const
{ return const_iterator(node_algorithms::root_node(this->header_ptr()), this->priv_value_traits_ptr()); } { return const_iterator(node_algorithms::root_node(this->header_ptr()), this->priv_value_traits_ptr()); }
BOOST_INTRUSIVE_FORCEINLINE reverse_iterator rbegin() inline reverse_iterator rbegin()
{ return reverse_iterator(end()); } { return reverse_iterator(end()); }
BOOST_INTRUSIVE_FORCEINLINE const_reverse_iterator rbegin() const inline const_reverse_iterator rbegin() const
{ return const_reverse_iterator(end()); } { return const_reverse_iterator(end()); }
BOOST_INTRUSIVE_FORCEINLINE const_reverse_iterator crbegin() const inline const_reverse_iterator crbegin() const
{ return const_reverse_iterator(end()); } { return const_reverse_iterator(end()); }
BOOST_INTRUSIVE_FORCEINLINE reverse_iterator rend() inline reverse_iterator rend()
{ return reverse_iterator(begin()); } { return reverse_iterator(begin()); }
BOOST_INTRUSIVE_FORCEINLINE const_reverse_iterator rend() const inline const_reverse_iterator rend() const
{ return const_reverse_iterator(begin()); } { return const_reverse_iterator(begin()); }
BOOST_INTRUSIVE_FORCEINLINE const_reverse_iterator crend() const inline const_reverse_iterator crend() const
{ return const_reverse_iterator(begin()); } { return const_reverse_iterator(begin()); }
void replace_node(iterator replace_this, reference with_this) void replace_node(iterator replace_this, reference with_this)
@ -199,7 +199,7 @@ struct bstbase3
node_algorithms::init(replace_this.pointed_node()); node_algorithms::init(replace_this.pointed_node());
} }
BOOST_INTRUSIVE_FORCEINLINE void rebalance() BOOST_NOEXCEPT inline void rebalance() BOOST_NOEXCEPT
{ node_algorithms::rebalance(this->header_ptr()); } { node_algorithms::rebalance(this->header_ptr()); }
iterator rebalance_subtree(iterator r) BOOST_NOEXCEPT iterator rebalance_subtree(iterator r) BOOST_NOEXCEPT
@ -223,7 +223,7 @@ struct bstbase3
const_iterator iterator_to(const_reference value) const BOOST_NOEXCEPT const_iterator iterator_to(const_reference value) const BOOST_NOEXCEPT
{ return const_iterator (this->get_value_traits().to_node_ptr(*pointer_traits<pointer>::const_cast_from(pointer_traits<const_pointer>::pointer_to(value))), this->priv_value_traits_ptr()); } { return const_iterator (this->get_value_traits().to_node_ptr(*pointer_traits<pointer>::const_cast_from(pointer_traits<const_pointer>::pointer_to(value))), this->priv_value_traits_ptr()); }
BOOST_INTRUSIVE_FORCEINLINE static void init_node(reference value) inline static void init_node(reference value)
{ node_algorithms::init(value_traits::to_node_ptr(value)); } { node_algorithms::init(value_traits::to_node_ptr(value)); }
}; };
@ -314,17 +314,17 @@ struct bstbase2
typedef BOOST_INTRUSIVE_IMPDEF(typename pointer_traits<const_pointer>::difference_type) difference_type; typedef BOOST_INTRUSIVE_IMPDEF(typename pointer_traits<const_pointer>::difference_type) difference_type;
typedef typename node_algorithms::insert_commit_data insert_commit_data; typedef typename node_algorithms::insert_commit_data insert_commit_data;
BOOST_INTRUSIVE_FORCEINLINE value_compare value_comp() const inline value_compare value_comp() const
{ return this->get_comp(); } { return this->get_comp(); }
BOOST_INTRUSIVE_FORCEINLINE key_compare key_comp() const inline key_compare key_comp() const
{ return this->get_comp().key_comp(); } { return this->get_comp().key_comp(); }
//lower_bound //lower_bound
BOOST_INTRUSIVE_FORCEINLINE iterator lower_bound(const key_type &key) inline iterator lower_bound(const key_type &key)
{ return this->lower_bound(key, this->key_comp()); } { return this->lower_bound(key, this->key_comp()); }
BOOST_INTRUSIVE_FORCEINLINE const_iterator lower_bound(const key_type &key) const inline const_iterator lower_bound(const key_type &key) const
{ return this->lower_bound(key, this->key_comp()); } { return this->lower_bound(key, this->key_comp()); }
template<class KeyType, class KeyTypeKeyCompare> template<class KeyType, class KeyTypeKeyCompare>
@ -342,7 +342,7 @@ struct bstbase2
} }
//upper_bound //upper_bound
BOOST_INTRUSIVE_FORCEINLINE iterator upper_bound(const key_type &key) inline iterator upper_bound(const key_type &key)
{ return this->upper_bound(key, this->key_comp()); } { return this->upper_bound(key, this->key_comp()); }
template<class KeyType, class KeyTypeKeyCompare> template<class KeyType, class KeyTypeKeyCompare>
@ -352,7 +352,7 @@ struct bstbase2
(this->header_ptr(), key, this->key_node_comp(comp)), this->priv_value_traits_ptr()); (this->header_ptr(), key, this->key_node_comp(comp)), this->priv_value_traits_ptr());
} }
BOOST_INTRUSIVE_FORCEINLINE const_iterator upper_bound(const key_type &key) const inline const_iterator upper_bound(const key_type &key) const
{ return this->upper_bound(key, this->key_comp()); } { return this->upper_bound(key, this->key_comp()); }
template<class KeyType, class KeyTypeKeyCompare> template<class KeyType, class KeyTypeKeyCompare>
@ -367,13 +367,13 @@ struct bstbase2
{ typedef detail::key_nodeptr_comp<KeyTypeKeyCompare, value_traits, key_of_value> type; }; { typedef detail::key_nodeptr_comp<KeyTypeKeyCompare, value_traits, key_of_value> type; };
template<class KeyTypeKeyCompare> template<class KeyTypeKeyCompare>
BOOST_INTRUSIVE_FORCEINLINE typename key_node_comp_ret<KeyTypeKeyCompare>::type key_node_comp(KeyTypeKeyCompare comp) const inline typename key_node_comp_ret<KeyTypeKeyCompare>::type key_node_comp(KeyTypeKeyCompare comp) const
{ {
return detail::key_nodeptr_comp<KeyTypeKeyCompare, value_traits, key_of_value>(comp, &this->get_value_traits()); return detail::key_nodeptr_comp<KeyTypeKeyCompare, value_traits, key_of_value>(comp, &this->get_value_traits());
} }
//find //find
BOOST_INTRUSIVE_FORCEINLINE iterator find(const key_type &key) inline iterator find(const key_type &key)
{ return this->find(key, this->key_comp()); } { return this->find(key, this->key_comp()); }
template<class KeyType, class KeyTypeKeyCompare> template<class KeyType, class KeyTypeKeyCompare>
@ -383,7 +383,7 @@ struct bstbase2
(node_algorithms::find(this->header_ptr(), key, this->key_node_comp(comp)), this->priv_value_traits_ptr()); (node_algorithms::find(this->header_ptr(), key, this->key_node_comp(comp)), this->priv_value_traits_ptr());
} }
BOOST_INTRUSIVE_FORCEINLINE const_iterator find(const key_type &key) const inline const_iterator find(const key_type &key) const
{ return this->find(key, this->key_comp()); } { return this->find(key, this->key_comp()); }
template<class KeyType, class KeyTypeKeyCompare> template<class KeyType, class KeyTypeKeyCompare>
@ -394,7 +394,7 @@ struct bstbase2
} }
//equal_range //equal_range
BOOST_INTRUSIVE_FORCEINLINE std::pair<iterator,iterator> equal_range(const key_type &key) inline std::pair<iterator,iterator> equal_range(const key_type &key)
{ return this->equal_range(key, this->key_comp()); } { return this->equal_range(key, this->key_comp()); }
template<class KeyType, class KeyTypeKeyCompare> template<class KeyType, class KeyTypeKeyCompare>
@ -406,7 +406,7 @@ struct bstbase2
, iterator(ret.second, this->priv_value_traits_ptr())); , iterator(ret.second, this->priv_value_traits_ptr()));
} }
BOOST_INTRUSIVE_FORCEINLINE std::pair<const_iterator, const_iterator> inline std::pair<const_iterator, const_iterator>
equal_range(const key_type &key) const equal_range(const key_type &key) const
{ return this->equal_range(key, this->key_comp()); } { return this->equal_range(key, this->key_comp()); }
@ -421,7 +421,7 @@ struct bstbase2
} }
//lower_bound_range //lower_bound_range
BOOST_INTRUSIVE_FORCEINLINE std::pair<iterator,iterator> lower_bound_range(const key_type &key) inline std::pair<iterator,iterator> lower_bound_range(const key_type &key)
{ return this->lower_bound_range(key, this->key_comp()); } { return this->lower_bound_range(key, this->key_comp()); }
template<class KeyType, class KeyTypeKeyCompare> template<class KeyType, class KeyTypeKeyCompare>
@ -433,7 +433,7 @@ struct bstbase2
, iterator(ret.second, this->priv_value_traits_ptr())); , iterator(ret.second, this->priv_value_traits_ptr()));
} }
BOOST_INTRUSIVE_FORCEINLINE std::pair<const_iterator, const_iterator> inline std::pair<const_iterator, const_iterator>
lower_bound_range(const key_type &key) const lower_bound_range(const key_type &key) const
{ return this->lower_bound_range(key, this->key_comp()); } { return this->lower_bound_range(key, this->key_comp()); }
@ -448,7 +448,7 @@ struct bstbase2
} }
//bounded_range //bounded_range
BOOST_INTRUSIVE_FORCEINLINE std::pair<iterator,iterator> bounded_range inline std::pair<iterator,iterator> bounded_range
(const key_type &lower_key, const key_type &upper_key, bool left_closed, bool right_closed) (const key_type &lower_key, const key_type &upper_key, bool left_closed, bool right_closed)
{ return this->bounded_range(lower_key, upper_key, this->key_comp(), left_closed, right_closed); } { return this->bounded_range(lower_key, upper_key, this->key_comp(), left_closed, right_closed); }
@ -463,7 +463,7 @@ struct bstbase2
, iterator(ret.second, this->priv_value_traits_ptr())); , iterator(ret.second, this->priv_value_traits_ptr()));
} }
BOOST_INTRUSIVE_FORCEINLINE std::pair<const_iterator,const_iterator> bounded_range inline std::pair<const_iterator,const_iterator> bounded_range
(const key_type &lower_key, const key_type &upper_key, bool left_closed, bool right_closed) const (const key_type &lower_key, const key_type &upper_key, bool left_closed, bool right_closed) const
{ return this->bounded_range(lower_key, upper_key, this->key_comp(), left_closed, right_closed); } { return this->bounded_range(lower_key, upper_key, this->key_comp(), left_closed, right_closed); }
@ -479,11 +479,11 @@ struct bstbase2
} }
//insert_unique_check //insert_unique_check
BOOST_INTRUSIVE_FORCEINLINE std::pair<iterator, bool> insert_unique_check inline std::pair<iterator, bool> insert_unique_check
(const key_type &key, insert_commit_data &commit_data) (const key_type &key, insert_commit_data &commit_data)
{ return this->insert_unique_check(key, this->key_comp(), commit_data); } { return this->insert_unique_check(key, this->key_comp(), commit_data); }
BOOST_INTRUSIVE_FORCEINLINE std::pair<iterator, bool> insert_unique_check inline std::pair<iterator, bool> insert_unique_check
(const_iterator hint, const key_type &key, insert_commit_data &commit_data) (const_iterator hint, const key_type &key, insert_commit_data &commit_data)
{ return this->insert_unique_check(hint, key, this->key_comp(), commit_data); } { return this->insert_unique_check(hint, key, this->key_comp(), commit_data); }
@ -528,7 +528,7 @@ struct bstbase_hack
typedef typename get_algo typedef typename get_algo
<AlgoType, node_traits>::type algo_type; <AlgoType, node_traits>::type algo_type;
BOOST_INTRUSIVE_FORCEINLINE bstbase_hack(const key_compare & comp, const ValueTraits &vtraits) inline bstbase_hack(const key_compare & comp, const ValueTraits &vtraits)
: base_type(comp, vtraits) : base_type(comp, vtraits)
{ {
this->sz_traits().set_size(size_type(0)); this->sz_traits().set_size(size_type(0));
@ -536,10 +536,10 @@ struct bstbase_hack
typedef detail::size_holder<ConstantTimeSize, SizeType> size_traits; typedef detail::size_holder<ConstantTimeSize, SizeType> size_traits;
BOOST_INTRUSIVE_FORCEINLINE size_traits &sz_traits() inline size_traits &sz_traits()
{ return static_cast<size_traits &>(*this); } { return static_cast<size_traits &>(*this); }
BOOST_INTRUSIVE_FORCEINLINE const size_traits &sz_traits() const inline const size_traits &sz_traits() const
{ return static_cast<const size_traits &>(*this); } { return static_cast<const size_traits &>(*this); }
}; };
@ -551,13 +551,13 @@ struct bstbase_hack<ValueTraits, VoidOrKeyOfValue, VoidOrKeyComp, false, SizeTyp
typedef bstbase2< ValueTraits, VoidOrKeyOfValue, VoidOrKeyComp, AlgoType, HeaderHolder> base_type; typedef bstbase2< ValueTraits, VoidOrKeyOfValue, VoidOrKeyComp, AlgoType, HeaderHolder> base_type;
typedef typename base_type::value_compare value_compare; typedef typename base_type::value_compare value_compare;
typedef typename base_type::key_compare key_compare; typedef typename base_type::key_compare key_compare;
BOOST_INTRUSIVE_FORCEINLINE bstbase_hack(const key_compare & comp, const ValueTraits &vtraits) inline bstbase_hack(const key_compare & comp, const ValueTraits &vtraits)
: base_type(comp, vtraits) : base_type(comp, vtraits)
{} {}
typedef detail::size_holder<false, SizeType> size_traits; typedef detail::size_holder<false, SizeType> size_traits;
BOOST_INTRUSIVE_FORCEINLINE size_traits sz_traits() const inline size_traits sz_traits() const
{ return size_traits(); } { return size_traits(); }
}; };
@ -579,7 +579,7 @@ struct bstbase
<AlgoType, node_traits>::type node_algorithms; <AlgoType, node_traits>::type node_algorithms;
typedef SizeType size_type; typedef SizeType size_type;
BOOST_INTRUSIVE_FORCEINLINE bstbase(const key_compare & comp, const ValueTraits &vtraits) inline bstbase(const key_compare & comp, const ValueTraits &vtraits)
: base_type(comp, vtraits) : base_type(comp, vtraits)
{} {}
@ -742,7 +742,7 @@ class bstree_impl
//! <b>Effects</b>: Equivalent to swap //! <b>Effects</b>: Equivalent to swap
//! //!
BOOST_INTRUSIVE_FORCEINLINE bstree_impl& operator=(BOOST_RV_REF(bstree_impl) x) inline bstree_impl& operator=(BOOST_RV_REF(bstree_impl) x)
{ this->swap(x); return *this; } { this->swap(x); return *this; }
#ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED #ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
@ -2186,46 +2186,46 @@ class bstree
//Assert if passed value traits are compatible with the type //Assert if passed value traits are compatible with the type
BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value)); BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value));
BOOST_INTRUSIVE_FORCEINLINE bstree() inline bstree()
: Base() : Base()
{} {}
BOOST_INTRUSIVE_FORCEINLINE explicit bstree( const key_compare &cmp, const value_traits &v_traits = value_traits()) inline explicit bstree( const key_compare &cmp, const value_traits &v_traits = value_traits())
: Base(cmp, v_traits) : Base(cmp, v_traits)
{} {}
template<class Iterator> template<class Iterator>
BOOST_INTRUSIVE_FORCEINLINE bstree( bool unique, Iterator b, Iterator e inline bstree( bool unique, Iterator b, Iterator e
, const key_compare &cmp = key_compare() , const key_compare &cmp = key_compare()
, const value_traits &v_traits = value_traits()) , const value_traits &v_traits = value_traits())
: Base(unique, b, e, cmp, v_traits) : Base(unique, b, e, cmp, v_traits)
{} {}
BOOST_INTRUSIVE_FORCEINLINE bstree(BOOST_RV_REF(bstree) x) inline bstree(BOOST_RV_REF(bstree) x)
: Base(BOOST_MOVE_BASE(Base, x)) : Base(BOOST_MOVE_BASE(Base, x))
{} {}
BOOST_INTRUSIVE_FORCEINLINE bstree& operator=(BOOST_RV_REF(bstree) x) inline bstree& operator=(BOOST_RV_REF(bstree) x)
{ return static_cast<bstree &>(this->Base::operator=(BOOST_MOVE_BASE(Base, x))); } { return static_cast<bstree &>(this->Base::operator=(BOOST_MOVE_BASE(Base, x))); }
template <class Cloner, class Disposer> template <class Cloner, class Disposer>
BOOST_INTRUSIVE_FORCEINLINE void clone_from(const bstree &src, Cloner cloner, Disposer disposer) inline void clone_from(const bstree &src, Cloner cloner, Disposer disposer)
{ Base::clone_from(src, cloner, disposer); } { Base::clone_from(src, cloner, disposer); }
template <class Cloner, class Disposer> template <class Cloner, class Disposer>
BOOST_INTRUSIVE_FORCEINLINE void clone_from(BOOST_RV_REF(bstree) src, Cloner cloner, Disposer disposer) inline void clone_from(BOOST_RV_REF(bstree) src, Cloner cloner, Disposer disposer)
{ Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer); } { Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer); }
BOOST_INTRUSIVE_FORCEINLINE static bstree &container_from_end_iterator(iterator end_iterator) BOOST_NOEXCEPT inline static bstree &container_from_end_iterator(iterator end_iterator) BOOST_NOEXCEPT
{ return static_cast<bstree &>(Base::container_from_end_iterator(end_iterator)); } { return static_cast<bstree &>(Base::container_from_end_iterator(end_iterator)); }
BOOST_INTRUSIVE_FORCEINLINE static const bstree &container_from_end_iterator(const_iterator end_iterator) BOOST_NOEXCEPT inline static const bstree &container_from_end_iterator(const_iterator end_iterator) BOOST_NOEXCEPT
{ return static_cast<const bstree &>(Base::container_from_end_iterator(end_iterator)); } { return static_cast<const bstree &>(Base::container_from_end_iterator(end_iterator)); }
BOOST_INTRUSIVE_FORCEINLINE static bstree &container_from_iterator(iterator it) BOOST_NOEXCEPT inline static bstree &container_from_iterator(iterator it) BOOST_NOEXCEPT
{ return static_cast<bstree &>(Base::container_from_iterator(it)); } { return static_cast<bstree &>(Base::container_from_iterator(it)); }
BOOST_INTRUSIVE_FORCEINLINE static const bstree &container_from_iterator(const_iterator it) BOOST_NOEXCEPT inline static const bstree &container_from_iterator(const_iterator it) BOOST_NOEXCEPT
{ return static_cast<const bstree &>(Base::container_from_iterator(it)); } { return static_cast<const bstree &>(Base::container_from_iterator(it)); }
}; };

40
include/boost/intrusive/bstree_algorithms.hpp
View File

@ -38,7 +38,7 @@ namespace intrusive {
template <class NodePtr> template <class NodePtr>
struct insert_commit_data_t struct insert_commit_data_t
{ {
BOOST_INTRUSIVE_FORCEINLINE insert_commit_data_t() inline insert_commit_data_t()
: link_left(false), node() : link_left(false), node()
{} {}
bool link_left; bool link_left;
@ -67,7 +67,7 @@ struct bstree_node_checker
struct return_type struct return_type
: public base_checker_t::return_type : public base_checker_t::return_type
{ {
BOOST_INTRUSIVE_FORCEINLINE return_type() inline return_type()
: min_key_node_ptr(const_node_ptr()), max_key_node_ptr(const_node_ptr()), node_count(0) : min_key_node_ptr(const_node_ptr()), max_key_node_ptr(const_node_ptr()), node_count(0)
{} {}
@ -76,7 +76,7 @@ struct bstree_node_checker
size_t node_count; size_t node_count;
}; };
BOOST_INTRUSIVE_FORCEINLINE bstree_node_checker(const NodePtrCompare& comp, ExtraChecker extra_checker) inline bstree_node_checker(const NodePtrCompare& comp, ExtraChecker extra_checker)
: base_checker_t(extra_checker), comp_(comp) : base_checker_t(extra_checker), comp_(comp)
{} {}
@ -186,14 +186,14 @@ class bstree_algorithms : public bstree_algorithms_base<NodeTraits>
template<class Disposer> template<class Disposer>
struct dispose_subtree_disposer struct dispose_subtree_disposer
{ {
BOOST_INTRUSIVE_FORCEINLINE dispose_subtree_disposer(Disposer &disp, node_ptr subtree) inline dispose_subtree_disposer(Disposer &disp, node_ptr subtree)
: disposer_(&disp), subtree_(subtree) : disposer_(&disp), subtree_(subtree)
{} {}
BOOST_INTRUSIVE_FORCEINLINE void release() inline void release()
{ disposer_ = 0; } { disposer_ = 0; }
BOOST_INTRUSIVE_FORCEINLINE ~dispose_subtree_disposer() inline ~dispose_subtree_disposer()
{ {
if(disposer_){ if(disposer_){
dispose_subtree(subtree_, *disposer_); dispose_subtree(subtree_, *disposer_);
@ -213,7 +213,7 @@ class bstree_algorithms : public bstree_algorithms_base<NodeTraits>
//! <b>Complexity</b>: Constant time. //! <b>Complexity</b>: Constant time.
//! //!
//! <b>Throws</b>: Nothing. //! <b>Throws</b>: Nothing.
BOOST_INTRUSIVE_FORCEINLINE static node_ptr begin_node(const_node_ptr header) BOOST_NOEXCEPT inline static node_ptr begin_node(const_node_ptr header) BOOST_NOEXCEPT
{ return node_traits::get_left(header); } { return node_traits::get_left(header); }
//! <b>Requires</b>: 'header' is the header node of a tree. //! <b>Requires</b>: 'header' is the header node of a tree.
@ -223,7 +223,7 @@ class bstree_algorithms : public bstree_algorithms_base<NodeTraits>
//! <b>Complexity</b>: Constant time. //! <b>Complexity</b>: Constant time.
//! //!
//! <b>Throws</b>: Nothing. //! <b>Throws</b>: Nothing.
BOOST_INTRUSIVE_FORCEINLINE static node_ptr end_node(const_node_ptr header) BOOST_NOEXCEPT inline static node_ptr end_node(const_node_ptr header) BOOST_NOEXCEPT
{ return detail::uncast(header); } { return detail::uncast(header); }
//! <b>Requires</b>: 'header' is the header node of a tree. //! <b>Requires</b>: 'header' is the header node of a tree.
@ -233,7 +233,7 @@ class bstree_algorithms : public bstree_algorithms_base<NodeTraits>
//! <b>Complexity</b>: Constant time. //! <b>Complexity</b>: Constant time.
//! //!
//! <b>Throws</b>: Nothing. //! <b>Throws</b>: Nothing.
BOOST_INTRUSIVE_FORCEINLINE static node_ptr root_node(const_node_ptr header) BOOST_NOEXCEPT inline static node_ptr root_node(const_node_ptr header) BOOST_NOEXCEPT
{ {
node_ptr p = node_traits::get_parent(header); node_ptr p = node_traits::get_parent(header);
return p ? p : detail::uncast(header); return p ? p : detail::uncast(header);
@ -247,7 +247,7 @@ class bstree_algorithms : public bstree_algorithms_base<NodeTraits>
//! <b>Complexity</b>: Constant time. //! <b>Complexity</b>: Constant time.
//! //!
//! <b>Throws</b>: Nothing. //! <b>Throws</b>: Nothing.
BOOST_INTRUSIVE_FORCEINLINE static bool unique(const_node_ptr n) BOOST_NOEXCEPT inline static bool unique(const_node_ptr n) BOOST_NOEXCEPT
{ return !NodeTraits::get_parent(n); } { return !NodeTraits::get_parent(n); }
#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) #if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED)
@ -456,7 +456,7 @@ class bstree_algorithms : public bstree_algorithms_base<NodeTraits>
//! new_node is not equivalent to node_to_be_replaced according to the //! new_node is not equivalent to node_to_be_replaced according to the
//! ordering rules. This function is faster than erasing and inserting //! ordering rules. This function is faster than erasing and inserting
//! the node, since no rebalancing and comparison is needed. Experimental function //! the node, since no rebalancing and comparison is needed. Experimental function
BOOST_INTRUSIVE_FORCEINLINE static void replace_node(node_ptr node_to_be_replaced, node_ptr new_node) BOOST_NOEXCEPT inline static void replace_node(node_ptr node_to_be_replaced, node_ptr new_node) BOOST_NOEXCEPT
{ {
replace_node(node_to_be_replaced, base_type::get_header(node_to_be_replaced), new_node); replace_node(node_to_be_replaced, base_type::get_header(node_to_be_replaced), new_node);
} }
@ -875,7 +875,7 @@ class bstree_algorithms : public bstree_algorithms_base<NodeTraits>
//! //!
//! <b>Throws</b>: If "comp" throws. //! <b>Throws</b>: If "comp" throws.
template<class KeyType, class KeyNodePtrCompare> template<class KeyType, class KeyNodePtrCompare>
BOOST_INTRUSIVE_FORCEINLINE static std::pair<node_ptr, node_ptr> equal_range inline static std::pair<node_ptr, node_ptr> equal_range
(const_node_ptr header, const KeyType &key, KeyNodePtrCompare comp) (const_node_ptr header, const KeyType &key, KeyNodePtrCompare comp)
{ {
return bounded_range(header, key, key, comp, true, true); return bounded_range(header, key, key, comp, true, true);
@ -919,7 +919,7 @@ class bstree_algorithms : public bstree_algorithms_base<NodeTraits>
//! //!
//! <b>Throws</b>: If "comp" throws. //! <b>Throws</b>: If "comp" throws.
template<class KeyType, class KeyNodePtrCompare> template<class KeyType, class KeyNodePtrCompare>
BOOST_INTRUSIVE_FORCEINLINE static node_ptr lower_bound inline static node_ptr lower_bound
(const_node_ptr header, const KeyType &key, KeyNodePtrCompare comp) (const_node_ptr header, const KeyType &key, KeyNodePtrCompare comp)
{ {
return lower_bound_loop(NodeTraits::get_parent(header), detail::uncast(header), key, comp); return lower_bound_loop(NodeTraits::get_parent(header), detail::uncast(header), key, comp);
@ -937,7 +937,7 @@ class bstree_algorithms : public bstree_algorithms_base<NodeTraits>
//! //!
//! <b>Throws</b>: If "comp" throws. //! <b>Throws</b>: If "comp" throws.
template<class KeyType, class KeyNodePtrCompare> template<class KeyType, class KeyNodePtrCompare>
BOOST_INTRUSIVE_FORCEINLINE static node_ptr upper_bound inline static node_ptr upper_bound
(const_node_ptr header, const KeyType &key, KeyNodePtrCompare comp) (const_node_ptr header, const KeyType &key, KeyNodePtrCompare comp)
{ {
return upper_bound_loop(NodeTraits::get_parent(header), detail::uncast(header), key, comp); return upper_bound_loop(NodeTraits::get_parent(header), detail::uncast(header), key, comp);
@ -960,7 +960,7 @@ class bstree_algorithms : public bstree_algorithms_base<NodeTraits>
//! <b>Notes</b>: This function has only sense if a "insert_unique_check" has been //! <b>Notes</b>: This function has only sense if a "insert_unique_check" has been
//! previously executed to fill "commit_data". No value should be inserted or //! previously executed to fill "commit_data". No value should be inserted or
//! erased between the "insert_check" and "insert_commit" calls. //! erased between the "insert_check" and "insert_commit" calls.
BOOST_INTRUSIVE_FORCEINLINE static void insert_unique_commit inline static void insert_unique_commit
(node_ptr header, node_ptr new_value, const insert_commit_data &commit_data) BOOST_NOEXCEPT (node_ptr header, node_ptr new_value, const insert_commit_data &commit_data) BOOST_NOEXCEPT
{ return insert_commit(header, new_value, commit_data); } { return insert_commit(header, new_value, commit_data); }
@ -1322,7 +1322,7 @@ class bstree_algorithms : public bstree_algorithms_base<NodeTraits>
//! <b>Complexity</b>: Amortized constant time. //! <b>Complexity</b>: Amortized constant time.
//! //!
//! <b>Throws</b>: Nothing. //! <b>Throws</b>: Nothing.
BOOST_INTRUSIVE_FORCEINLINE static void erase(node_ptr header, node_ptr z) BOOST_NOEXCEPT inline static void erase(node_ptr header, node_ptr z) BOOST_NOEXCEPT
{ {
data_for_rebalance ignored; data_for_rebalance ignored;
erase(header, z, ignored); erase(header, z, ignored);
@ -1341,7 +1341,7 @@ class bstree_algorithms : public bstree_algorithms_base<NodeTraits>
//! //!
//! <b>Throws</b>: If the comparison throws. //! <b>Throws</b>: If the comparison throws.
template<class NodePtrCompare> template<class NodePtrCompare>
BOOST_INTRUSIVE_FORCEINLINE static bool transfer_unique inline static bool transfer_unique
(node_ptr header1, NodePtrCompare comp, node_ptr header2, node_ptr z) (node_ptr header1, NodePtrCompare comp, node_ptr header2, node_ptr z)
{ {
data_for_rebalance ignored; data_for_rebalance ignored;
@ -1358,7 +1358,7 @@ class bstree_algorithms : public bstree_algorithms_base<NodeTraits>
//! //!
//! <b>Throws</b>: If the comparison throws. //! <b>Throws</b>: If the comparison throws.
template<class NodePtrCompare> template<class NodePtrCompare>
BOOST_INTRUSIVE_FORCEINLINE static void transfer_equal inline static void transfer_equal
(node_ptr header1, NodePtrCompare comp, node_ptr header2, node_ptr z) (node_ptr header1, NodePtrCompare comp, node_ptr header2, node_ptr z)
{ {
data_for_rebalance ignored; data_for_rebalance ignored;
@ -1635,7 +1635,7 @@ class bstree_algorithms : public bstree_algorithms_base<NodeTraits>
//! <b>Complexity</b>: Constant. //! <b>Complexity</b>: Constant.
//! //!
//! <b>Throws</b>: Nothing. //! <b>Throws</b>: Nothing.
BOOST_INTRUSIVE_FORCEINLINE static bool is_left_child(node_ptr p) BOOST_NOEXCEPT inline static bool is_left_child(node_ptr p) BOOST_NOEXCEPT
{ return NodeTraits::get_left(NodeTraits::get_parent(p)) == p; } { return NodeTraits::get_left(NodeTraits::get_parent(p)) == p; }
//! <b>Requires</b>: p is a node of a tree. //! <b>Requires</b>: p is a node of a tree.
@ -1645,7 +1645,7 @@ class bstree_algorithms : public bstree_algorithms_base<NodeTraits>
//! <b>Complexity</b>: Constant. //! <b>Complexity</b>: Constant.
//! //!
//! <b>Throws</b>: Nothing. //! <b>Throws</b>: Nothing.
BOOST_INTRUSIVE_FORCEINLINE static bool is_right_child(node_ptr p) BOOST_NOEXCEPT inline static bool is_right_child(node_ptr p) BOOST_NOEXCEPT
{ return NodeTraits::get_right(NodeTraits::get_parent(p)) == p; } { return NodeTraits::get_right(NodeTraits::get_parent(p)) == p; }
static void insert_before_check static void insert_before_check

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

@ -80,7 +80,7 @@ class circular_list_algorithms
//! <b>Complexity</b>: Constant //! <b>Complexity</b>: Constant
//! //!
//! <b>Throws</b>: Nothing. //! <b>Throws</b>: Nothing.
BOOST_INTRUSIVE_FORCEINLINE static bool inited(const_node_ptr this_node) BOOST_NOEXCEPT inline static bool inited(const_node_ptr this_node) BOOST_NOEXCEPT
{ return !NodeTraits::get_next(this_node); } { return !NodeTraits::get_next(this_node); }
//! <b>Effects</b>: Constructs an empty list, making this_node the only //! <b>Effects</b>: Constructs an empty list, making this_node the only
@ -102,7 +102,7 @@ class circular_list_algorithms
//! <b>Complexity</b>: Constant //! <b>Complexity</b>: Constant
//! //!
//! <b>Throws</b>: Nothing. //! <b>Throws</b>: Nothing.
BOOST_INTRUSIVE_FORCEINLINE static bool is_empty(const_node_ptr this_node) BOOST_NOEXCEPT inline static bool is_empty(const_node_ptr this_node) BOOST_NOEXCEPT
{ {
return NodeTraits::get_next(this_node) == this_node; return NodeTraits::get_next(this_node) == this_node;
} }

20
include/boost/intrusive/circular_slist_algorithms.hpp
View File

@ -146,7 +146,7 @@ class circular_slist_algorithms
//! <b>Complexity</b>: Constant //! <b>Complexity</b>: Constant
//! //!
//! <b>Throws</b>: Nothing. //! <b>Throws</b>: Nothing.
BOOST_INTRUSIVE_FORCEINLINE static void init_header(node_ptr this_node) BOOST_NOEXCEPT inline static void init_header(node_ptr this_node) BOOST_NOEXCEPT
{ NodeTraits::set_next(this_node, this_node); } { NodeTraits::set_next(this_node, this_node); }
//! <b>Requires</b>: 'p' is the first node of a list. //! <b>Requires</b>: 'p' is the first node of a list.
@ -156,7 +156,7 @@ class circular_slist_algorithms
//! <b>Complexity</b>: Constant time. //! <b>Complexity</b>: Constant time.
//! //!
//! <b>Throws</b>: Nothing. //! <b>Throws</b>: Nothing.
BOOST_INTRUSIVE_FORCEINLINE static node_ptr end_node(const_node_ptr p) BOOST_NOEXCEPT inline static node_ptr end_node(const_node_ptr p) BOOST_NOEXCEPT
{ return detail::uncast(p); } { return detail::uncast(p); }
//! <b>Effects</b>: Returns true if this_node_points to an empty list. //! <b>Effects</b>: Returns true if this_node_points to an empty list.
@ -164,7 +164,7 @@ class circular_slist_algorithms
//! <b>Complexity</b>: Constant //! <b>Complexity</b>: Constant
//! //!
//! <b>Throws</b>: Nothing. //! <b>Throws</b>: Nothing.
BOOST_INTRUSIVE_FORCEINLINE static bool is_empty(const_node_ptr this_node) BOOST_NOEXCEPT inline static bool is_empty(const_node_ptr this_node) BOOST_NOEXCEPT
{ return NodeTraits::get_next(this_node) == this_node; } { return NodeTraits::get_next(this_node) == this_node; }
//! <b>Effects</b>: Returns true if this_node points to a sentinel node. //! <b>Effects</b>: Returns true if this_node points to a sentinel node.
@ -172,7 +172,7 @@ class circular_slist_algorithms
//! <b>Complexity</b>: Constant //! <b>Complexity</b>: Constant
//! //!
//! <b>Throws</b>: Nothing. //! <b>Throws</b>: Nothing.
BOOST_INTRUSIVE_FORCEINLINE static bool is_sentinel(const_node_ptr this_node) BOOST_NOEXCEPT inline static bool is_sentinel(const_node_ptr this_node) BOOST_NOEXCEPT
{ return NodeTraits::get_next(this_node) == node_ptr(); } { return NodeTraits::get_next(this_node) == node_ptr(); }
//! <b>Effects</b>: Marks this node as a "sentinel" node, a special state that is different from "empty", //! <b>Effects</b>: Marks this node as a "sentinel" node, a special state that is different from "empty",
@ -181,7 +181,7 @@ class circular_slist_algorithms
//! <b>Complexity</b>: Constant //! <b>Complexity</b>: Constant
//! //!
//! <b>Throws</b>: Nothing. //! <b>Throws</b>: Nothing.
BOOST_INTRUSIVE_FORCEINLINE static void set_sentinel(node_ptr this_node) BOOST_NOEXCEPT inline static void set_sentinel(node_ptr this_node) BOOST_NOEXCEPT
{ NodeTraits::set_next(this_node, node_ptr()); } { NodeTraits::set_next(this_node, node_ptr()); }
//! <b>Requires</b>: this_node and prev_init_node must be in the same circular list. //! <b>Requires</b>: this_node and prev_init_node must be in the same circular list.
@ -193,7 +193,7 @@ class circular_slist_algorithms
//! <b>Complexity</b>: Linear to the number of elements between prev_init_node and this_node. //! <b>Complexity</b>: Linear to the number of elements between prev_init_node and this_node.
//! //!
//! <b>Throws</b>: Nothing. //! <b>Throws</b>: Nothing.
BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_previous_node(node_ptr prev_init_node, node_ptr this_node) BOOST_NOEXCEPT inline static node_ptr get_previous_node(node_ptr prev_init_node, node_ptr this_node) BOOST_NOEXCEPT
{ return base_t::get_previous_node(prev_init_node, this_node); } { return base_t::get_previous_node(prev_init_node, this_node); }
//! <b>Requires</b>: this_node must be in a circular list or be an empty circular list. //! <b>Requires</b>: this_node must be in a circular list or be an empty circular list.
@ -203,7 +203,7 @@ class circular_slist_algorithms
//! <b>Complexity</b>: Linear to the number of elements in the circular list. //! <b>Complexity</b>: Linear to the number of elements in the circular list.
//! //!
//! <b>Throws</b>: Nothing. //! <b>Throws</b>: Nothing.
BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_previous_node(node_ptr this_node) BOOST_NOEXCEPT inline static node_ptr get_previous_node(node_ptr this_node) BOOST_NOEXCEPT
{ return base_t::get_previous_node(this_node, this_node); } { return base_t::get_previous_node(this_node, this_node); }
//! <b>Requires</b>: this_node must be in a circular list or be an empty circular list. //! <b>Requires</b>: this_node must be in a circular list or be an empty circular list.
@ -213,7 +213,7 @@ class circular_slist_algorithms
//! <b>Complexity</b>: Linear to the number of elements in the circular list. //! <b>Complexity</b>: Linear to the number of elements in the circular list.
//! //!
//! <b>Throws</b>: Nothing. //! <b>Throws</b>: Nothing.
BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_previous_previous_node(node_ptr this_node) BOOST_NOEXCEPT inline static node_ptr get_previous_previous_node(node_ptr this_node) BOOST_NOEXCEPT
{ return get_previous_previous_node(this_node, this_node); } { return get_previous_previous_node(this_node, this_node); }
//! <b>Requires</b>: this_node and p must be in the same circular list. //! <b>Requires</b>: this_node and p must be in the same circular list.
@ -276,7 +276,7 @@ class circular_slist_algorithms
//! <b>Complexity</b>: Linear to the number of elements in the circular list. //! <b>Complexity</b>: Linear to the number of elements in the circular list.
//! //!
//! <b>Throws</b>: Nothing. //! <b>Throws</b>: Nothing.
BOOST_INTRUSIVE_FORCEINLINE static void link_before (node_ptr nxt_node, node_ptr this_node) BOOST_NOEXCEPT inline static void link_before (node_ptr nxt_node, node_ptr this_node) BOOST_NOEXCEPT
{ base_t::link_after(get_previous_node(nxt_node), this_node); } { base_t::link_after(get_previous_node(nxt_node), this_node); }
//! <b>Requires</b>: this_node and other_node must be nodes inserted //! <b>Requires</b>: this_node and other_node must be nodes inserted
@ -453,7 +453,7 @@ class circular_slist_algorithms
//! //!
//! <b>Throws</b>: Nothing. //! <b>Throws</b>: Nothing.
template<class Disposer> template<class Disposer>
BOOST_INTRUSIVE_FORCEINLINE static std::size_t detach_and_dispose(node_ptr p, Disposer disposer) BOOST_NOEXCEPT inline static std::size_t detach_and_dispose(node_ptr p, Disposer disposer) BOOST_NOEXCEPT
{ return base_t::unlink_after_and_dispose(p, p, disposer); } { return base_t::unlink_after_and_dispose(p, p, disposer); }
}; };

6
include/boost/intrusive/detail/any_node_and_algorithms.hpp
View File

@ -252,7 +252,7 @@ class any_algorithms
//! <b>Throws</b>: Nothing. //! <b>Throws</b>: Nothing.
//! //!
//! <b>Nodes</b>: If node is inserted in a tree, this function corrupts the tree. //! <b>Nodes</b>: If node is inserted in a tree, this function corrupts the tree.
BOOST_INTRUSIVE_FORCEINLINE static void init(node_ptr n) BOOST_NOEXCEPT inline static void init(node_ptr n) BOOST_NOEXCEPT
{ n->node_ptr_1 = node_ptr(); }; { n->node_ptr_1 = node_ptr(); };
//! <b>Effects</b>: Returns true if 'n' is in the same state as if called init(node) //! <b>Effects</b>: Returns true if 'n' is in the same state as if called init(node)
@ -260,10 +260,10 @@ class any_algorithms
//! <b>Complexity</b>: Constant. //! <b>Complexity</b>: Constant.
//! //!
//! <b>Throws</b>: Nothing. //! <b>Throws</b>: Nothing.
BOOST_INTRUSIVE_FORCEINLINE static bool inited(const_node_ptr n) inline static bool inited(const_node_ptr n)
{ return !n->node_ptr_1; }; { return !n->node_ptr_1; };
BOOST_INTRUSIVE_FORCEINLINE static bool unique(const_node_ptr n) BOOST_NOEXCEPT inline static bool unique(const_node_ptr n) BOOST_NOEXCEPT
{ return !n->node_ptr_1; } { return !n->node_ptr_1; }
static void unlink(node_ptr) static void unlink(node_ptr)

10
include/boost/intrusive/detail/common_slist_algorithms.hpp
View File

@ -52,7 +52,7 @@ class common_slist_algorithms
return p; return p;
} }
BOOST_INTRUSIVE_FORCEINLINE static void init(node_ptr this_node) BOOST_NOEXCEPT inline static void init(node_ptr this_node) BOOST_NOEXCEPT
{ NodeTraits::set_next(this_node, node_ptr()); } { NodeTraits::set_next(this_node, node_ptr()); }
static bool unique(const_node_ptr this_node) BOOST_NOEXCEPT static bool unique(const_node_ptr this_node) BOOST_NOEXCEPT
@ -61,16 +61,16 @@ class common_slist_algorithms
return !next || next == this_node; return !next || next == this_node;
} }
BOOST_INTRUSIVE_FORCEINLINE static bool inited(const_node_ptr this_node) BOOST_NOEXCEPT inline static bool inited(const_node_ptr this_node) BOOST_NOEXCEPT
{ return !NodeTraits::get_next(this_node); } { return !NodeTraits::get_next(this_node); }
BOOST_INTRUSIVE_FORCEINLINE static void unlink_after(node_ptr prev_node) BOOST_NOEXCEPT inline static void unlink_after(node_ptr prev_node) BOOST_NOEXCEPT
{ {
const_node_ptr this_node(NodeTraits::get_next(prev_node)); const_node_ptr this_node(NodeTraits::get_next(prev_node));
NodeTraits::set_next(prev_node, NodeTraits::get_next(this_node)); NodeTraits::set_next(prev_node, NodeTraits::get_next(this_node));
} }
BOOST_INTRUSIVE_FORCEINLINE static void unlink_after(node_ptr prev_node, node_ptr last_node) BOOST_NOEXCEPT inline static void unlink_after(node_ptr prev_node, node_ptr last_node) BOOST_NOEXCEPT
{ NodeTraits::set_next(prev_node, last_node); } { NodeTraits::set_next(prev_node, last_node); }
static void link_after(node_ptr prev_node, node_ptr this_node) BOOST_NOEXCEPT static void link_after(node_ptr prev_node, node_ptr this_node) BOOST_NOEXCEPT
@ -216,7 +216,7 @@ class common_slist_algorithms
//! //!
//! <b>Throws</b>: Nothing. //! <b>Throws</b>: Nothing.
template<class Disposer> template<class Disposer>
BOOST_INTRUSIVE_FORCEINLINE static void unlink_after_and_dispose(node_ptr bb, Disposer disposer) BOOST_NOEXCEPT inline static void unlink_after_and_dispose(node_ptr bb, Disposer disposer) BOOST_NOEXCEPT
{ {
node_ptr i = node_traits::get_next(bb); node_ptr i = node_traits::get_next(bb);
node_traits::set_next(bb, node_traits::get_next(i)); node_traits::set_next(bb, node_traits::get_next(i));

6
include/boost/intrusive/detail/default_header_holder.hpp
View File

@ -40,14 +40,14 @@ struct default_header_holder : public NodeTraits::node
default_header_holder() : node() {} default_header_holder() : node() {}
BOOST_INTRUSIVE_FORCEINLINE const_node_ptr get_node() const inline const_node_ptr get_node() const
{ return pointer_traits< const_node_ptr >::pointer_to(*static_cast< const node* >(this)); } { return pointer_traits< const_node_ptr >::pointer_to(*static_cast< const node* >(this)); }
BOOST_INTRUSIVE_FORCEINLINE node_ptr get_node() inline node_ptr get_node()
{ return pointer_traits< node_ptr >::pointer_to(*static_cast< node* >(this)); } { return pointer_traits< node_ptr >::pointer_to(*static_cast< node* >(this)); }
// (unsafe) downcast used to implement container-from-iterator // (unsafe) downcast used to implement container-from-iterator
BOOST_INTRUSIVE_FORCEINLINE static default_header_holder* get_holder(node_ptr p) inline static default_header_holder* get_holder(node_ptr p)
{ return static_cast< default_header_holder* >(boost::movelib::to_raw_pointer(p)); } { return static_cast< default_header_holder* >(boost::movelib::to_raw_pointer(p)); }
}; };

48
include/boost/intrusive/detail/ebo_functor_holder.hpp
View File

@ -166,57 +166,57 @@ class ebo_functor_holder
public: public:
typedef T functor_type; typedef T functor_type;
BOOST_INTRUSIVE_FORCEINLINE ebo_functor_holder() inline ebo_functor_holder()
: t_() : t_()
{} {}
BOOST_INTRUSIVE_FORCEINLINE explicit ebo_functor_holder(const T &t) inline explicit ebo_functor_holder(const T &t)
: t_(t) : t_(t)
{} {}
BOOST_INTRUSIVE_FORCEINLINE explicit ebo_functor_holder(BOOST_RV_REF(T) t) inline explicit ebo_functor_holder(BOOST_RV_REF(T) t)
: t_(::boost::move(t)) : t_(::boost::move(t))
{} {}
template<class Arg1, class Arg2> template<class Arg1, class Arg2>
BOOST_INTRUSIVE_FORCEINLINE ebo_functor_holder(BOOST_FWD_REF(Arg1) arg1, BOOST_FWD_REF(Arg2) arg2) inline ebo_functor_holder(BOOST_FWD_REF(Arg1) arg1, BOOST_FWD_REF(Arg2) arg2)
: t_(::boost::forward<Arg1>(arg1), ::boost::forward<Arg2>(arg2)) : t_(::boost::forward<Arg1>(arg1), ::boost::forward<Arg2>(arg2))
{} {}
BOOST_INTRUSIVE_FORCEINLINE ebo_functor_holder(const ebo_functor_holder &x) inline ebo_functor_holder(const ebo_functor_holder &x)
: t_(x.t_) : t_(x.t_)
{} {}
BOOST_INTRUSIVE_FORCEINLINE ebo_functor_holder(BOOST_RV_REF(ebo_functor_holder) x) inline ebo_functor_holder(BOOST_RV_REF(ebo_functor_holder) x)
: t_(x.t_) : t_(x.t_)
{} {}
BOOST_INTRUSIVE_FORCEINLINE ebo_functor_holder& operator=(BOOST_COPY_ASSIGN_REF(ebo_functor_holder) x) inline ebo_functor_holder& operator=(BOOST_COPY_ASSIGN_REF(ebo_functor_holder) x)
{ {
this->get() = x.get(); this->get() = x.get();
return *this; return *this;
} }
BOOST_INTRUSIVE_FORCEINLINE ebo_functor_holder& operator=(BOOST_RV_REF(ebo_functor_holder) x) inline ebo_functor_holder& operator=(BOOST_RV_REF(ebo_functor_holder) x)
{ {
this->get() = ::boost::move(x.get()); this->get() = ::boost::move(x.get());
return *this; return *this;
} }
BOOST_INTRUSIVE_FORCEINLINE ebo_functor_holder& operator=(const T &x) inline ebo_functor_holder& operator=(const T &x)
{ {
this->get() = x; this->get() = x;
return *this; return *this;
} }
BOOST_INTRUSIVE_FORCEINLINE ebo_functor_holder& operator=(BOOST_RV_REF(T) x) inline ebo_functor_holder& operator=(BOOST_RV_REF(T) x)
{ {
this->get() = ::boost::move(x); this->get() = ::boost::move(x);
return *this; return *this;
} }
BOOST_INTRUSIVE_FORCEINLINE T& get(){return t_;} inline T& get(){return t_;}
BOOST_INTRUSIVE_FORCEINLINE const T& get()const{return t_;} inline const T& get()const{return t_;}
private: private:
T t_; T t_;
@ -231,58 +231,58 @@ class ebo_functor_holder<T, Tag, false>
public: public:
typedef T functor_type; typedef T functor_type;
BOOST_INTRUSIVE_FORCEINLINE ebo_functor_holder() inline ebo_functor_holder()
: T() : T()
{} {}
BOOST_INTRUSIVE_FORCEINLINE explicit ebo_functor_holder(const T &t) inline explicit ebo_functor_holder(const T &t)
: T(t) : T(t)
{} {}
BOOST_INTRUSIVE_FORCEINLINE explicit ebo_functor_holder(BOOST_RV_REF(T) t) inline explicit ebo_functor_holder(BOOST_RV_REF(T) t)
: T(::boost::move(t)) : T(::boost::move(t))
{} {}
template<class Arg1, class Arg2> template<class Arg1, class Arg2>
BOOST_INTRUSIVE_FORCEINLINE ebo_functor_holder(BOOST_FWD_REF(Arg1) arg1, BOOST_FWD_REF(Arg2) arg2) inline ebo_functor_holder(BOOST_FWD_REF(Arg1) arg1, BOOST_FWD_REF(Arg2) arg2)
: T(::boost::forward<Arg1>(arg1), ::boost::forward<Arg2>(arg2)) : T(::boost::forward<Arg1>(arg1), ::boost::forward<Arg2>(arg2))
{} {}
BOOST_INTRUSIVE_FORCEINLINE ebo_functor_holder(const ebo_functor_holder &x) inline ebo_functor_holder(const ebo_functor_holder &x)
: T(static_cast<const T&>(x)) : T(static_cast<const T&>(x))
{} {}
BOOST_INTRUSIVE_FORCEINLINE ebo_functor_holder(BOOST_RV_REF(ebo_functor_holder) x) inline ebo_functor_holder(BOOST_RV_REF(ebo_functor_holder) x)
: T(BOOST_MOVE_BASE(T, x)) : T(BOOST_MOVE_BASE(T, x))
{} {}
BOOST_INTRUSIVE_FORCEINLINE ebo_functor_holder& operator=(BOOST_COPY_ASSIGN_REF(ebo_functor_holder) x) inline ebo_functor_holder& operator=(BOOST_COPY_ASSIGN_REF(ebo_functor_holder) x)
{ {
const ebo_functor_holder&r = x; const ebo_functor_holder&r = x;
this->get() = r; this->get() = r;
return *this; return *this;
} }
BOOST_INTRUSIVE_FORCEINLINE ebo_functor_holder& operator=(BOOST_RV_REF(ebo_functor_holder) x) inline ebo_functor_holder& operator=(BOOST_RV_REF(ebo_functor_holder) x)
{ {
this->get() = ::boost::move(x.get()); this->get() = ::boost::move(x.get());
return *this; return *this;
} }
BOOST_INTRUSIVE_FORCEINLINE ebo_functor_holder& operator=(const T &x) inline ebo_functor_holder& operator=(const T &x)
{ {
this->get() = x; this->get() = x;
return *this; return *this;
} }
BOOST_INTRUSIVE_FORCEINLINE ebo_functor_holder& operator=(BOOST_RV_REF(T) x) inline ebo_functor_holder& operator=(BOOST_RV_REF(T) x)
{ {
this->get() = ::boost::move(x); this->get() = ::boost::move(x);
return *this; return *this;
} }
BOOST_INTRUSIVE_FORCEINLINE T& get(){return *this;} inline T& get(){return *this;}
BOOST_INTRUSIVE_FORCEINLINE const T& get()const{return *this;} inline const T& get()const{return *this;}
}; };
} //namespace detail { } //namespace detail {

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

@ -39,7 +39,7 @@ class equal_to_value
: t_(t) : t_(t)
{} {}
BOOST_INTRUSIVE_FORCEINLINE bool operator()(ConstReference t)const inline bool operator()(ConstReference t)const
{ return t_ == t; } { return t_ == t; }
}; };

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

@ -41,7 +41,7 @@ class exception_disposer
: cont_(&cont), disp_(disp) : cont_(&cont), disp_(disp)
{} {}
BOOST_INTRUSIVE_FORCEINLINE void release() inline void release()
{ cont_ = 0; } { cont_ = 0; }
~exception_disposer() ~exception_disposer()

24
include/boost/intrusive/detail/generic_hook.hpp
View File

@ -41,7 +41,7 @@ struct link_dispatch
{}; {};
template<class Hook> template<class Hook>
BOOST_INTRUSIVE_FORCEINLINE void destructor_impl(Hook &hook, detail::link_dispatch<safe_link>) inline void destructor_impl(Hook &hook, detail::link_dispatch<safe_link>)
{ //If this assertion raises, you might have destroyed an object { //If this assertion raises, you might have destroyed an object
//while it was still inserted in a container that is alive. //while it was still inserted in a container that is alive.
//If so, remove the object from the container before destroying it. //If so, remove the object from the container before destroying it.
@ -49,11 +49,11 @@ BOOST_INTRUSIVE_FORCEINLINE void destructor_impl(Hook &hook, detail::link_dispat
} }
template<class Hook> template<class Hook>
BOOST_INTRUSIVE_FORCEINLINE void destructor_impl(Hook &hook, detail::link_dispatch<auto_unlink>) inline void destructor_impl(Hook &hook, detail::link_dispatch<auto_unlink>)
{ hook.unlink(); } { hook.unlink(); }
template<class Hook> template<class Hook>
BOOST_INTRUSIVE_FORCEINLINE void destructor_impl(Hook &, detail::link_dispatch<normal_link>) inline void destructor_impl(Hook &, detail::link_dispatch<normal_link>)
{} {}
} //namespace detail { } //namespace detail {
@ -161,52 +161,52 @@ class generic_hook
< NodeTraits < NodeTraits
, Tag, LinkMode, BaseHookType> hooktags; , Tag, LinkMode, BaseHookType> hooktags;
BOOST_INTRUSIVE_FORCEINLINE node_ptr this_ptr() BOOST_NOEXCEPT inline node_ptr this_ptr() BOOST_NOEXCEPT
{ return pointer_traits<node_ptr>::pointer_to(static_cast<node&>(*this)); } { return pointer_traits<node_ptr>::pointer_to(static_cast<node&>(*this)); }
BOOST_INTRUSIVE_FORCEINLINE const_node_ptr this_ptr() const BOOST_NOEXCEPT inline const_node_ptr this_ptr() const BOOST_NOEXCEPT
{ return pointer_traits<const_node_ptr>::pointer_to(static_cast<const node&>(*this)); } { return pointer_traits<const_node_ptr>::pointer_to(static_cast<const node&>(*this)); }
public: public:
/// @endcond /// @endcond
BOOST_INTRUSIVE_FORCEINLINE generic_hook() BOOST_NOEXCEPT inline generic_hook() BOOST_NOEXCEPT
{ {
if(hooktags::safemode_or_autounlink){ if(hooktags::safemode_or_autounlink){
node_algorithms::init(this->this_ptr()); node_algorithms::init(this->this_ptr());
} }
} }
BOOST_INTRUSIVE_FORCEINLINE generic_hook(const generic_hook& ) BOOST_NOEXCEPT inline generic_hook(const generic_hook& ) BOOST_NOEXCEPT
{ {
if(hooktags::safemode_or_autounlink){ if(hooktags::safemode_or_autounlink){
node_algorithms::init(this->this_ptr()); node_algorithms::init(this->this_ptr());
} }
} }
BOOST_INTRUSIVE_FORCEINLINE generic_hook& operator=(const generic_hook& ) BOOST_NOEXCEPT inline generic_hook& operator=(const generic_hook& ) BOOST_NOEXCEPT
{ return *this; } { return *this; }
BOOST_INTRUSIVE_FORCEINLINE ~generic_hook() inline ~generic_hook()
{ {
destructor_impl destructor_impl
(*this, detail::link_dispatch<hooktags::link_mode>()); (*this, detail::link_dispatch<hooktags::link_mode>());
} }
BOOST_INTRUSIVE_FORCEINLINE void swap_nodes(generic_hook &other) BOOST_NOEXCEPT inline void swap_nodes(generic_hook &other) BOOST_NOEXCEPT
{ {
node_algorithms::swap_nodes node_algorithms::swap_nodes
(this->this_ptr(), other.this_ptr()); (this->this_ptr(), other.this_ptr());
} }
BOOST_INTRUSIVE_FORCEINLINE bool is_linked() const BOOST_NOEXCEPT inline bool is_linked() const BOOST_NOEXCEPT
{ {
//is_linked() can be only used in safe-mode or auto-unlink //is_linked() can be only used in safe-mode or auto-unlink
BOOST_STATIC_ASSERT(( hooktags::safemode_or_autounlink )); BOOST_STATIC_ASSERT(( hooktags::safemode_or_autounlink ));
return !node_algorithms::unique(this->this_ptr()); return !node_algorithms::unique(this->this_ptr());
} }
BOOST_INTRUSIVE_FORCEINLINE void unlink() BOOST_NOEXCEPT inline void unlink() BOOST_NOEXCEPT
{ {
BOOST_STATIC_ASSERT(( (int)hooktags::link_mode == (int)auto_unlink )); BOOST_STATIC_ASSERT(( (int)hooktags::link_mode == (int)auto_unlink ));
node_ptr n(this->this_ptr()); node_ptr n(this->this_ptr());

82
include/boost/intrusive/detail/hashtable_node.hpp
View File

@ -52,25 +52,25 @@ struct bucket_impl
typedef detail::common_slist_algorithms<NodeTraits> algo_t; typedef detail::common_slist_algorithms<NodeTraits> algo_t;
public: public:
BOOST_INTRUSIVE_FORCEINLINE bucket_impl() inline bucket_impl()
{} {}
BOOST_INTRUSIVE_FORCEINLINE bucket_impl(const bucket_impl &) inline bucket_impl(const bucket_impl &)
{} {}
BOOST_INTRUSIVE_FORCEINLINE ~bucket_impl() inline ~bucket_impl()
{} {}
BOOST_INTRUSIVE_FORCEINLINE bucket_impl &operator=(const bucket_impl&) inline bucket_impl &operator=(const bucket_impl&)
{ return *this; } { return *this; }
BOOST_INTRUSIVE_FORCEINLINE node_ptr get_node_ptr() inline node_ptr get_node_ptr()
{ return pointer_traits<node_ptr>::pointer_to(*this); } { return pointer_traits<node_ptr>::pointer_to(*this); }
BOOST_INTRUSIVE_FORCEINLINE const_node_ptr get_node_ptr() const inline const_node_ptr get_node_ptr() const
{ return pointer_traits<const_node_ptr>::pointer_to(*this); } { return pointer_traits<const_node_ptr>::pointer_to(*this); }
BOOST_INTRUSIVE_FORCEINLINE node_ptr begin_ptr() inline node_ptr begin_ptr()
{ return node_traits::get_next(get_node_ptr()); } { return node_traits::get_next(get_node_ptr()); }
}; };
@ -136,7 +136,7 @@ class hashtable_iterator
, hashtable_iterator<BucketValueTraits, LinearBuckets, false> , hashtable_iterator<BucketValueTraits, LinearBuckets, false>
, nat>::type nonconst_iterator; , nat>::type nonconst_iterator;
BOOST_INTRUSIVE_FORCEINLINE static node_ptr downcast_bucket(typename bucket_type::node_traits::node_ptr p) inline static node_ptr downcast_bucket(typename bucket_type::node_traits::node_ptr p)
{ {
return pointer_traits<node_ptr>:: return pointer_traits<node_ptr>::
pointer_to(static_cast<typename node_traits::node&>(*p)); pointer_to(static_cast<typename node_traits::node&>(*p));
@ -144,61 +144,61 @@ class hashtable_iterator
public: public:
BOOST_INTRUSIVE_FORCEINLINE hashtable_iterator () inline hashtable_iterator ()
: slist_it_() //Value initialization to achieve "null iterators" (N3644) : slist_it_() //Value initialization to achieve "null iterators" (N3644)
{} {}
BOOST_INTRUSIVE_FORCEINLINE explicit hashtable_iterator(siterator ptr, const BucketValueTraits *cont) inline explicit hashtable_iterator(siterator ptr, const BucketValueTraits *cont)
: slist_it_ (ptr) : slist_it_ (ptr)
, traitsptr_ (cont ? pointer_traits<const_bucketvaltraits_ptr>::pointer_to(*cont) : const_bucketvaltraits_ptr() ) , traitsptr_ (cont ? pointer_traits<const_bucketvaltraits_ptr>::pointer_to(*cont) : const_bucketvaltraits_ptr() )
{} {}
BOOST_INTRUSIVE_FORCEINLINE hashtable_iterator(const hashtable_iterator &other) inline hashtable_iterator(const hashtable_iterator &other)
: slist_it_(other.slist_it()), traitsptr_(other.get_bucket_value_traits()) : slist_it_(other.slist_it()), traitsptr_(other.get_bucket_value_traits())
{} {}
BOOST_INTRUSIVE_FORCEINLINE hashtable_iterator(const nonconst_iterator &other) inline hashtable_iterator(const nonconst_iterator &other)
: slist_it_(other.slist_it()), traitsptr_(other.get_bucket_value_traits()) : slist_it_(other.slist_it()), traitsptr_(other.get_bucket_value_traits())
{} {}
BOOST_INTRUSIVE_FORCEINLINE const siterator &slist_it() const inline const siterator &slist_it() const
{ return slist_it_; } { return slist_it_; }
BOOST_INTRUSIVE_FORCEINLINE hashtable_iterator<BucketValueTraits, LinearBuckets, false> unconst() const inline hashtable_iterator<BucketValueTraits, LinearBuckets, false> unconst() const
{ return hashtable_iterator<BucketValueTraits, LinearBuckets, false>(this->slist_it(), this->get_bucket_value_traits()); } { return hashtable_iterator<BucketValueTraits, LinearBuckets, false>(this->slist_it(), this->get_bucket_value_traits()); }
BOOST_INTRUSIVE_FORCEINLINE hashtable_iterator& operator++() inline hashtable_iterator& operator++()
{ this->increment(); return *this; } { this->increment(); return *this; }
BOOST_INTRUSIVE_FORCEINLINE hashtable_iterator &operator=(const hashtable_iterator &other) inline hashtable_iterator &operator=(const hashtable_iterator &other)
{ slist_it_ = other.slist_it(); traitsptr_ = other.get_bucket_value_traits(); return *this; } { slist_it_ = other.slist_it(); traitsptr_ = other.get_bucket_value_traits(); return *this; }
BOOST_INTRUSIVE_FORCEINLINE hashtable_iterator operator++(int) inline hashtable_iterator operator++(int)
{ {
hashtable_iterator result (*this); hashtable_iterator result (*this);
this->increment(); this->increment();
return result; return result;
} }
BOOST_INTRUSIVE_FORCEINLINE friend bool operator== (const hashtable_iterator& i, const hashtable_iterator& i2) inline friend bool operator== (const hashtable_iterator& i, const hashtable_iterator& i2)
{ return i.slist_it_ == i2.slist_it_; } { return i.slist_it_ == i2.slist_it_; }
BOOST_INTRUSIVE_FORCEINLINE friend bool operator!= (const hashtable_iterator& i, const hashtable_iterator& i2) inline friend bool operator!= (const hashtable_iterator& i, const hashtable_iterator& i2)
{ return !(i == i2); } { return !(i == i2); }
BOOST_INTRUSIVE_FORCEINLINE reference operator*() const inline reference operator*() const
{ return *this->operator ->(); } { return *this->operator ->(); }
BOOST_INTRUSIVE_FORCEINLINE pointer operator->() const inline pointer operator->() const
{ {
return this->priv_value_traits().to_value_ptr return this->priv_value_traits().to_value_ptr
(downcast_bucket(slist_it_.pointed_node())); (downcast_bucket(slist_it_.pointed_node()));
} }
BOOST_INTRUSIVE_FORCEINLINE const_bucketvaltraits_ptr get_bucket_value_traits() const inline const_bucketvaltraits_ptr get_bucket_value_traits() const
{ return traitsptr_; } { return traitsptr_; }
BOOST_INTRUSIVE_FORCEINLINE const value_traits &priv_value_traits() const inline const value_traits &priv_value_traits() const
{ return traitsptr_->priv_value_traits(); } { return traitsptr_->priv_value_traits(); }
private: private:
@ -281,7 +281,7 @@ class hashtable_iterator<BucketValueTraits, true, IsConst>
, hashtable_iterator<BucketValueTraits, true, false> , hashtable_iterator<BucketValueTraits, true, false>
, nat>::type nonconst_iterator; , nat>::type nonconst_iterator;
BOOST_INTRUSIVE_FORCEINLINE static node_ptr downcast_bucket(slist_node_ptr p) inline static node_ptr downcast_bucket(slist_node_ptr p)
{ {
return pointer_traits<node_ptr>:: return pointer_traits<node_ptr>::
pointer_to(static_cast<typename node_traits::node&>(*p)); pointer_to(static_cast<typename node_traits::node&>(*p));
@ -289,67 +289,67 @@ class hashtable_iterator<BucketValueTraits, true, IsConst>
public: public:
BOOST_INTRUSIVE_FORCEINLINE hashtable_iterator () inline hashtable_iterator ()
: slist_it_() //Value initialization to achieve "null iterators" (N3644) : slist_it_() //Value initialization to achieve "null iterators" (N3644)
, members_() , members_()
{} {}
BOOST_INTRUSIVE_FORCEINLINE explicit hashtable_iterator(siterator ptr, bucket_ptr bp, const_value_traits_ptr traits_ptr) inline explicit hashtable_iterator(siterator ptr, bucket_ptr bp, const_value_traits_ptr traits_ptr)
: slist_it_ (ptr) : slist_it_ (ptr)
, members_ (bp, traits_ptr) , members_ (bp, traits_ptr)
{} {}
BOOST_INTRUSIVE_FORCEINLINE hashtable_iterator(const hashtable_iterator &other) inline hashtable_iterator(const hashtable_iterator &other)
: slist_it_(other.slist_it()), members_(other.get_bucket_ptr(), other.get_value_traits()) : slist_it_(other.slist_it()), members_(other.get_bucket_ptr(), other.get_value_traits())
{} {}
BOOST_INTRUSIVE_FORCEINLINE hashtable_iterator(const nonconst_iterator &other) inline hashtable_iterator(const nonconst_iterator &other)
: slist_it_(other.slist_it()), members_(other.get_bucket_ptr(), other.get_value_traits()) : slist_it_(other.slist_it()), members_(other.get_bucket_ptr(), other.get_value_traits())
{} {}
BOOST_INTRUSIVE_FORCEINLINE const siterator &slist_it() const inline const siterator &slist_it() const
{ return slist_it_; } { return slist_it_; }
BOOST_INTRUSIVE_FORCEINLINE hashtable_iterator<BucketValueTraits, true, false> unconst() const inline hashtable_iterator<BucketValueTraits, true, false> unconst() const
{ return hashtable_iterator<BucketValueTraits, true, false>(this->slist_it(), members_.nodeptr_, members_.get_ptr()); } { return hashtable_iterator<BucketValueTraits, true, false>(this->slist_it(), members_.nodeptr_, members_.get_ptr()); }
BOOST_INTRUSIVE_FORCEINLINE hashtable_iterator& operator++() inline hashtable_iterator& operator++()
{ this->increment(); return *this; } { this->increment(); return *this; }
BOOST_INTRUSIVE_FORCEINLINE hashtable_iterator &operator=(const hashtable_iterator &other) inline hashtable_iterator &operator=(const hashtable_iterator &other)
{ slist_it_ = other.slist_it(); members_ = other.members_; return *this; } { slist_it_ = other.slist_it(); members_ = other.members_; return *this; }
BOOST_INTRUSIVE_FORCEINLINE hashtable_iterator operator++(int) inline hashtable_iterator operator++(int)
{ {
hashtable_iterator result (*this); hashtable_iterator result (*this);
this->increment(); this->increment();
return result; return result;
} }
BOOST_INTRUSIVE_FORCEINLINE friend bool operator== (const hashtable_iterator& i, const hashtable_iterator& i2) inline friend bool operator== (const hashtable_iterator& i, const hashtable_iterator& i2)
{ return i.slist_it_ == i2.slist_it_; } { return i.slist_it_ == i2.slist_it_; }
BOOST_INTRUSIVE_FORCEINLINE friend bool operator!= (const hashtable_iterator& i, const hashtable_iterator& i2) inline friend bool operator!= (const hashtable_iterator& i, const hashtable_iterator& i2)
{ return i.slist_it_ != i2.slist_it_; } { return i.slist_it_ != i2.slist_it_; }
BOOST_INTRUSIVE_FORCEINLINE reference operator*() const inline reference operator*() const
{ return *this->operator ->(); } { return *this->operator ->(); }
BOOST_INTRUSIVE_FORCEINLINE pointer operator->() const inline pointer operator->() const
{ return this->operator_arrow(detail::bool_<stateful_value_traits>()); } { return this->operator_arrow(detail::bool_<stateful_value_traits>()); }
BOOST_INTRUSIVE_FORCEINLINE const_value_traits_ptr get_value_traits() const inline const_value_traits_ptr get_value_traits() const
{ return members_.get_ptr(); } { return members_.get_ptr(); }
BOOST_INTRUSIVE_FORCEINLINE bucket_ptr get_bucket_ptr() const inline bucket_ptr get_bucket_ptr() const
{ return members_.nodeptr_; } { return members_.nodeptr_; }
private: private:
BOOST_INTRUSIVE_FORCEINLINE pointer operator_arrow(detail::false_) const inline pointer operator_arrow(detail::false_) const
{ return value_traits::to_value_ptr(downcast_bucket(slist_it_.pointed_node())); } { return value_traits::to_value_ptr(downcast_bucket(slist_it_.pointed_node())); }
BOOST_INTRUSIVE_FORCEINLINE pointer operator_arrow(detail::true_) const inline pointer operator_arrow(detail::true_) const
{ return this->get_value_traits()->to_value_ptr(downcast_bucket(slist_it_.pointed_node())); } { return this->get_value_traits()->to_value_ptr(downcast_bucket(slist_it_.pointed_node())); }
void increment() void increment()

35
include/boost/intrusive/detail/hook_traits.hpp
View File

@ -28,7 +28,6 @@
#include <boost/intrusive/detail/mpl.hpp> #include <boost/intrusive/detail/mpl.hpp>
#include <boost/move/detail/to_raw_pointer.hpp> #include <boost/move/detail/to_raw_pointer.hpp>
#include <boost/intrusive/detail/node_holder.hpp> #include <boost/intrusive/detail/node_holder.hpp>
#include <boost/assert.hpp>
namespace boost { namespace boost {
namespace intrusive { namespace intrusive {
@ -47,8 +46,6 @@ struct bhtraits_base
template rebind_pointer<T>::type pointer; template rebind_pointer<T>::type pointer;
typedef typename pointer_traits<node_ptr>:: typedef typename pointer_traits<node_ptr>::
template rebind_pointer<const T>::type const_pointer; template rebind_pointer<const T>::type const_pointer;
//typedef typename pointer_traits<pointer>::reference reference;
//typedef typename pointer_traits<const_pointer>::reference const_reference;
typedef T & reference; typedef T & reference;
typedef const T & const_reference; typedef const T & const_reference;
typedef node_holder_type & node_holder_reference; typedef node_holder_type & node_holder_reference;
@ -56,35 +53,31 @@ struct bhtraits_base
typedef node& node_reference; typedef node& node_reference;
typedef const node & const_node_reference; typedef const node & const_node_reference;
BOOST_INTRUSIVE_FORCEINLINE static pointer to_value_ptr(node_ptr n) inline static pointer to_value_ptr(node_ptr n)
{ {
pointer p = pointer_traits<pointer>::pointer_to pointer p = pointer_traits<pointer>::pointer_to
(static_cast<reference>(static_cast<node_holder_reference>(*n))); (static_cast<reference>(static_cast<node_holder_reference>(*n)));
BOOST_ASSERT(!!p);
return p; return p;
} }
BOOST_INTRUSIVE_FORCEINLINE static const_pointer to_value_ptr(const_node_ptr n) inline static const_pointer to_value_ptr(const_node_ptr n)
{ {
const_pointer p = pointer_traits<const_pointer>::pointer_to const_pointer p = pointer_traits<const_pointer>::pointer_to
(static_cast<const_reference>(static_cast<const_node_holder_reference>(*n))); (static_cast<const_reference>(static_cast<const_node_holder_reference>(*n)));
BOOST_ASSERT(!!p);
return p; return p;
} }
BOOST_INTRUSIVE_FORCEINLINE static node_ptr to_node_ptr(reference value) inline static node_ptr to_node_ptr(reference value)
{ {
node_ptr p = pointer_traits<node_ptr>::pointer_to node_ptr p = pointer_traits<node_ptr>::pointer_to
(static_cast<node_reference>(static_cast<node_holder_reference>(value))); (static_cast<node_reference>(static_cast<node_holder_reference>(value)));
BOOST_ASSERT(!!p);
return p; return p;
} }
BOOST_INTRUSIVE_FORCEINLINE static const_node_ptr to_node_ptr(const_reference value) inline static const_node_ptr to_node_ptr(const_reference value)
{ {
const_node_ptr p = pointer_traits<const_node_ptr>::pointer_to const_node_ptr p = pointer_traits<const_node_ptr>::pointer_to
(static_cast<const_node_reference>(static_cast<const_node_holder_reference>(value))); (static_cast<const_node_reference>(static_cast<const_node_holder_reference>(value)));
BOOST_ASSERT(!!p);
return p; return p;
} }
}; };
@ -121,26 +114,26 @@ struct mhtraits
static const link_mode_type link_mode = Hook::hooktags::link_mode; static const link_mode_type link_mode = Hook::hooktags::link_mode;
BOOST_INTRUSIVE_FORCEINLINE static node_ptr to_node_ptr(reference value) inline static node_ptr to_node_ptr(reference value)
{ {
return pointer_traits<node_ptr>::pointer_to return pointer_traits<node_ptr>::pointer_to
(static_cast<node_reference>(static_cast<hook_reference>(value.*P))); (static_cast<node_reference>(static_cast<hook_reference>(value.*P)));
} }
BOOST_INTRUSIVE_FORCEINLINE static const_node_ptr to_node_ptr(const_reference value) inline static const_node_ptr to_node_ptr(const_reference value)
{ {
return pointer_traits<const_node_ptr>::pointer_to return pointer_traits<const_node_ptr>::pointer_to
(static_cast<const_node_reference>(static_cast<const_hook_reference>(value.*P))); (static_cast<const_node_reference>(static_cast<const_hook_reference>(value.*P)));
} }
BOOST_INTRUSIVE_FORCEINLINE static pointer to_value_ptr(node_ptr n) inline static pointer to_value_ptr(node_ptr n)
{ {
return pointer_traits<pointer>::pointer_to return pointer_traits<pointer>::pointer_to
(*detail::parent_from_member<T, Hook> (*detail::parent_from_member<T, Hook>
(static_cast<Hook*>(boost::movelib::to_raw_pointer(n)), P)); (static_cast<Hook*>(boost::movelib::to_raw_pointer(n)), P));
} }
BOOST_INTRUSIVE_FORCEINLINE static const_pointer to_value_ptr(const_node_ptr n) inline static const_pointer to_value_ptr(const_node_ptr n)
{ {
return pointer_traits<const_pointer>::pointer_to return pointer_traits<const_pointer>::pointer_to
(*detail::parent_from_member<T, Hook> (*detail::parent_from_member<T, Hook>
@ -169,23 +162,23 @@ struct fhtraits
typedef const value_type & const_reference; typedef const value_type & const_reference;
static const link_mode_type link_mode = hook_type::hooktags::link_mode; static const link_mode_type link_mode = hook_type::hooktags::link_mode;
static node_ptr to_node_ptr(reference value) inline static node_ptr to_node_ptr(reference value)
{ return static_cast<node*>(boost::movelib::to_raw_pointer(Functor::to_hook_ptr(value))); } { return static_cast<node*>(boost::movelib::to_raw_pointer(Functor::to_hook_ptr(value))); }
static const_node_ptr to_node_ptr(const_reference value) inline static const_node_ptr to_node_ptr(const_reference value)
{ return static_cast<const node*>(boost::movelib::to_raw_pointer(Functor::to_hook_ptr(value))); } { return static_cast<const node*>(boost::movelib::to_raw_pointer(Functor::to_hook_ptr(value))); }
static pointer to_value_ptr(node_ptr n) inline static pointer to_value_ptr(node_ptr n)
{ return Functor::to_value_ptr(to_hook_ptr(n)); } { return Functor::to_value_ptr(to_hook_ptr(n)); }
static const_pointer to_value_ptr(const_node_ptr n) inline static const_pointer to_value_ptr(const_node_ptr n)
{ return Functor::to_value_ptr(to_hook_ptr(n)); } { return Functor::to_value_ptr(to_hook_ptr(n)); }
private: private:
static hook_ptr to_hook_ptr(node_ptr n) inline static hook_ptr to_hook_ptr(node_ptr n)
{ return hook_ptr(&*static_cast<hook_type*>(&*n)); } { return hook_ptr(&*static_cast<hook_type*>(&*n)); }
static const_hook_ptr to_hook_ptr(const_node_ptr n) inline static const_hook_ptr to_hook_ptr(const_node_ptr n)
{ return const_hook_ptr(&*static_cast<const hook_type*>(&*n)); } { return const_hook_ptr(&*static_cast<const hook_type*>(&*n)); }
}; };

12
include/boost/intrusive/detail/iiterator.hpp
View File

@ -84,15 +84,15 @@ template<class NodePtr, class StoredPointer, bool StatefulValueTraits = true>
struct iiterator_members struct iiterator_members
{ {
BOOST_INTRUSIVE_FORCEINLINE iiterator_members() inline iiterator_members()
: nodeptr_()//Value initialization to achieve "null iterators" (N3644) : nodeptr_()//Value initialization to achieve "null iterators" (N3644)
{} {}
BOOST_INTRUSIVE_FORCEINLINE iiterator_members(const NodePtr &n_ptr, const StoredPointer &data) inline iiterator_members(const NodePtr &n_ptr, const StoredPointer &data)
: nodeptr_(n_ptr), ptr_(data) : nodeptr_(n_ptr), ptr_(data)
{} {}
BOOST_INTRUSIVE_FORCEINLINE StoredPointer get_ptr() const inline StoredPointer get_ptr() const
{ return ptr_; } { return ptr_; }
NodePtr nodeptr_; NodePtr nodeptr_;
@ -102,15 +102,15 @@ struct iiterator_members
template<class NodePtr, class StoredPointer> template<class NodePtr, class StoredPointer>
struct iiterator_members<NodePtr, StoredPointer, false> struct iiterator_members<NodePtr, StoredPointer, false>
{ {
BOOST_INTRUSIVE_FORCEINLINE iiterator_members() inline iiterator_members()
: nodeptr_()//Value initialization to achieve "null iterators" (N3644) : nodeptr_()//Value initialization to achieve "null iterators" (N3644)
{} {}
BOOST_INTRUSIVE_FORCEINLINE iiterator_members(const NodePtr &n_ptr, const StoredPointer &) inline iiterator_members(const NodePtr &n_ptr, const StoredPointer &)
: nodeptr_(n_ptr) : nodeptr_(n_ptr)
{} {}
BOOST_INTRUSIVE_FORCEINLINE StoredPointer get_ptr() const inline StoredPointer get_ptr() const
{ return StoredPointer(); } { return StoredPointer(); }
NodePtr nodeptr_; NodePtr nodeptr_;

24
include/boost/intrusive/detail/iterator.hpp
View File

@ -181,7 +181,7 @@ struct iterator_disable_if_tag_difference_type
//////////////////// ////////////////////
template<class InputIt> template<class InputIt>
BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_tag<InputIt, std::input_iterator_tag>::type inline typename iterator_enable_if_tag<InputIt, std::input_iterator_tag>::type
iterator_advance(InputIt& it, typename iter_difference<InputIt>::type n) iterator_advance(InputIt& it, typename iter_difference<InputIt>::type n)
{ {
while(n--) while(n--)
@ -197,7 +197,7 @@ typename iterator_enable_if_tag<InputIt, std::forward_iterator_tag>::type
} }
template<class InputIt> template<class InputIt>
BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_tag<InputIt, std::bidirectional_iterator_tag>::type inline typename iterator_enable_if_tag<InputIt, std::bidirectional_iterator_tag>::type
iterator_advance(InputIt& it, typename iter_difference<InputIt>::type n) iterator_advance(InputIt& it, typename iter_difference<InputIt>::type n)
{ {
for (; 0 < n; --n) for (; 0 < n; --n)
@ -207,14 +207,14 @@ BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_tag<InputIt, std::bidire
} }
template<class InputIt, class Distance> template<class InputIt, class Distance>
BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_tag<InputIt, std::random_access_iterator_tag>::type inline typename iterator_enable_if_tag<InputIt, std::random_access_iterator_tag>::type
iterator_advance(InputIt& it, Distance n) iterator_advance(InputIt& it, Distance n)
{ {
it += n; it += n;
} }
template<class InputIt, class Distance> template<class InputIt, class Distance>
BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_tag<InputIt, std::random_access_iterator_tag, InputIt>::type inline typename iterator_enable_if_tag<InputIt, std::random_access_iterator_tag, InputIt>::type
make_iterator_advance(InputIt it, Distance n) make_iterator_advance(InputIt it, Distance n)
{ {
(iterator_advance)(it, n); (iterator_advance)(it, n);
@ -222,14 +222,14 @@ BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_tag<InputIt, std::random
} }
template<class It> template<class It>
BOOST_INTRUSIVE_FORCEINLINE inline
void iterator_uadvance(It& it, typename iter_size<It>::type n) void iterator_uadvance(It& it, typename iter_size<It>::type n)
{ {
(iterator_advance)(it, (typename iterator_traits<It>::difference_type)n); (iterator_advance)(it, (typename iterator_traits<It>::difference_type)n);
} }
template<class It> template<class It>
BOOST_INTRUSIVE_FORCEINLINE inline
It make_iterator_uadvance(It it, typename iter_size<It>::type n) It make_iterator_uadvance(It it, typename iter_size<It>::type n)
{ {
(iterator_uadvance)(it, n); (iterator_uadvance)(it, n);
@ -253,7 +253,7 @@ typename iterator_disable_if_tag_difference_type
} }
template<class InputIt> template<class InputIt>
BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_tag_difference_type inline typename iterator_enable_if_tag_difference_type
<InputIt, std::random_access_iterator_tag>::type <InputIt, std::random_access_iterator_tag>::type
iterator_distance(InputIt first, InputIt last) iterator_distance(InputIt first, InputIt last)
{ {
@ -266,7 +266,7 @@ BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_tag_difference_type
//////////////////////////////////////// ////////////////////////////////////////
template<class It> template<class It>
BOOST_INTRUSIVE_FORCEINLINE typename iter_size<It>::type inline typename iter_size<It>::type
iterator_udistance(It first, It last) iterator_udistance(It first, It last)
{ {
return (typename iter_size<It>::type)(iterator_distance)(first, last); return (typename iter_size<It>::type)(iterator_distance)(first, last);
@ -277,14 +277,14 @@ BOOST_INTRUSIVE_FORCEINLINE typename iter_size<It>::type
//////////////////////////////////////// ////////////////////////////////////////
template<class InputIt> template<class InputIt>
BOOST_INTRUSIVE_FORCEINLINE InputIt iterator_next(InputIt it, typename iter_difference<InputIt>::type n) inline InputIt iterator_next(InputIt it, typename iter_difference<InputIt>::type n)
{ {
(iterator_advance)(it, n); (iterator_advance)(it, n);
return it; return it;
} }
template<class InputIt> template<class InputIt>
BOOST_INTRUSIVE_FORCEINLINE InputIt iterator_unext(InputIt it, typename iterator_traits<InputIt>::size_type n) inline InputIt iterator_unext(InputIt it, typename iterator_traits<InputIt>::size_type n)
{ {
(iterator_uadvance)(it, n); (iterator_uadvance)(it, n);
return it; return it;
@ -295,11 +295,11 @@ BOOST_INTRUSIVE_FORCEINLINE InputIt iterator_unext(InputIt it, typename iterator
//////////////////////////////////////// ////////////////////////////////////////
template<class I> template<class I>
BOOST_INTRUSIVE_FORCEINLINE typename iterator_traits<I>::pointer iterator_arrow_result(const I &i) inline typename iterator_traits<I>::pointer iterator_arrow_result(const I &i)
{ return i.operator->(); } { return i.operator->(); }
template<class T> template<class T>
BOOST_INTRUSIVE_FORCEINLINE T * iterator_arrow_result(T *p) inline T * iterator_arrow_result(T *p)
{ return p; } { return p; }
} //namespace intrusive } //namespace intrusive

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

@ -78,40 +78,40 @@ public:
static const bool value = same_type || is_convertible<P1, const_node_ptr>::value; static const bool value = same_type || is_convertible<P1, const_node_ptr>::value;
}; };
BOOST_INTRUSIVE_FORCEINLINE base_t base() const inline base_t base() const
{ return static_cast<const base_t&>(*this); } { return static_cast<const base_t&>(*this); }
BOOST_INTRUSIVE_FORCEINLINE key_nodeptr_comp(KeyTypeKeyCompare kcomp, const ValueTraits *traits) inline key_nodeptr_comp(KeyTypeKeyCompare kcomp, const ValueTraits *traits)
: base_t(kcomp), traits_(traits) : base_t(kcomp), traits_(traits)
{} {}
//pred(pnode) //pred(pnode)
template<class T1> template<class T1>
BOOST_INTRUSIVE_FORCEINLINE bool operator()(const T1 &t1, typename enable_if_c< is_same_or_nodeptr_convertible<T1>::value, sfinae_type* >::type = 0) const inline bool operator()(const T1 &t1, typename enable_if_c< is_same_or_nodeptr_convertible<T1>::value, sfinae_type* >::type = 0) const
{ return base().get()(key_of_value()(*traits_->to_value_ptr(t1))); } { return base().get()(key_of_value()(*traits_->to_value_ptr(t1))); }
//operator() 2 arg //operator() 2 arg
//pred(pnode, pnode) //pred(pnode, pnode)
template<class T1, class T2> template<class T1, class T2>
BOOST_INTRUSIVE_FORCEINLINE bool operator() inline bool operator()
(const T1 &t1, const T2 &t2, typename enable_if_c< is_same_or_nodeptr_convertible<T1>::value && is_same_or_nodeptr_convertible<T2>::value, sfinae_type* >::type = 0) const (const T1 &t1, const T2 &t2, typename enable_if_c< is_same_or_nodeptr_convertible<T1>::value && is_same_or_nodeptr_convertible<T2>::value, sfinae_type* >::type = 0) const
{ return base()(*traits_->to_value_ptr(t1), *traits_->to_value_ptr(t2)); } { return base()(*traits_->to_value_ptr(t1), *traits_->to_value_ptr(t2)); }
//pred(pnode, key) //pred(pnode, key)
template<class T1, class T2> template<class T1, class T2>
BOOST_INTRUSIVE_FORCEINLINE bool operator() inline bool operator()
(const T1 &t1, const T2 &t2, typename enable_if_c< is_same_or_nodeptr_convertible<T1>::value && !is_same_or_nodeptr_convertible<T2>::value, sfinae_type* >::type = 0) const (const T1 &t1, const T2 &t2, typename enable_if_c< is_same_or_nodeptr_convertible<T1>::value && !is_same_or_nodeptr_convertible<T2>::value, sfinae_type* >::type = 0) const
{ return base()(*traits_->to_value_ptr(t1), t2); } { return base()(*traits_->to_value_ptr(t1), t2); }
//pred(key, pnode) //pred(key, pnode)
template<class T1, class T2> template<class T1, class T2>
BOOST_INTRUSIVE_FORCEINLINE bool operator() inline bool operator()
(const T1 &t1, const T2 &t2, typename enable_if_c< !is_same_or_nodeptr_convertible<T1>::value && is_same_or_nodeptr_convertible<T2>::value, sfinae_type* >::type = 0) const (const T1 &t1, const T2 &t2, typename enable_if_c< !is_same_or_nodeptr_convertible<T1>::value && is_same_or_nodeptr_convertible<T2>::value, sfinae_type* >::type = 0) const
{ return base()(t1, *traits_->to_value_ptr(t2)); } { return base()(t1, *traits_->to_value_ptr(t2)); }
//pred(key, key) //pred(key, key)
template<class T1, class T2> template<class T1, class T2>
BOOST_INTRUSIVE_FORCEINLINE bool operator() inline bool operator()
(const T1 &t1, const T2 &t2, typename enable_if_c< !is_same_or_nodeptr_convertible<T1>::value && !is_same_or_nodeptr_convertible<T2>::value, sfinae_type* >::type = 0) const (const T1 &t1, const T2 &t2, typename enable_if_c< !is_same_or_nodeptr_convertible<T1>::value && !is_same_or_nodeptr_convertible<T2>::value, sfinae_type* >::type = 0) const
{ return base()(t1, t2); } { return base()(t1, t2); }

38
include/boost/intrusive/detail/list_iterator.hpp
View File

@ -60,81 +60,81 @@ class list_iterator
typedef typename types_t::iterator_type::reference reference; typedef typename types_t::iterator_type::reference reference;
typedef typename types_t::iterator_type::iterator_category iterator_category; typedef typename types_t::iterator_type::iterator_category iterator_category;
BOOST_INTRUSIVE_FORCEINLINE list_iterator() inline list_iterator()
{} {}
BOOST_INTRUSIVE_FORCEINLINE explicit list_iterator(node_ptr nodeptr, const_value_traits_ptr traits_ptr) inline explicit list_iterator(node_ptr nodeptr, const_value_traits_ptr traits_ptr)
: members_(nodeptr, traits_ptr) : members_(nodeptr, traits_ptr)
{} {}
BOOST_INTRUSIVE_FORCEINLINE list_iterator(const list_iterator &other) inline list_iterator(const list_iterator &other)
: members_(other.pointed_node(), other.get_value_traits()) : members_(other.pointed_node(), other.get_value_traits())
{} {}
BOOST_INTRUSIVE_FORCEINLINE list_iterator(const nonconst_iterator &other) inline list_iterator(const nonconst_iterator &other)
: members_(other.pointed_node(), other.get_value_traits()) : members_(other.pointed_node(), other.get_value_traits())
{} {}
BOOST_INTRUSIVE_FORCEINLINE list_iterator &operator=(const list_iterator &other) inline list_iterator &operator=(const list_iterator &other)
{ members_.nodeptr_ = other.members_.nodeptr_; return *this; } { members_.nodeptr_ = other.members_.nodeptr_; return *this; }
BOOST_INTRUSIVE_FORCEINLINE node_ptr pointed_node() const inline node_ptr pointed_node() const
{ return members_.nodeptr_; } { return members_.nodeptr_; }
BOOST_INTRUSIVE_FORCEINLINE list_iterator &operator=(node_ptr nodeptr) inline list_iterator &operator=(node_ptr nodeptr)
{ members_.nodeptr_ = nodeptr; return *this; } { members_.nodeptr_ = nodeptr; return *this; }
BOOST_INTRUSIVE_FORCEINLINE const_value_traits_ptr get_value_traits() const inline const_value_traits_ptr get_value_traits() const
{ return members_.get_ptr(); } { return members_.get_ptr(); }
public: public:
BOOST_INTRUSIVE_FORCEINLINE list_iterator& operator++() inline list_iterator& operator++()
{ {
node_ptr p = node_traits::get_next(members_.nodeptr_); node_ptr p = node_traits::get_next(members_.nodeptr_);
members_.nodeptr_ = p; members_.nodeptr_ = p;
return static_cast<list_iterator&> (*this); return static_cast<list_iterator&> (*this);
} }
BOOST_INTRUSIVE_FORCEINLINE list_iterator operator++(int) inline list_iterator operator++(int)
{ {
list_iterator result (*this); list_iterator result (*this);
members_.nodeptr_ = node_traits::get_next(members_.nodeptr_); members_.nodeptr_ = node_traits::get_next(members_.nodeptr_);
return result; return result;
} }
BOOST_INTRUSIVE_FORCEINLINE list_iterator& operator--() inline list_iterator& operator--()
{ {
members_.nodeptr_ = node_traits::get_previous(members_.nodeptr_); members_.nodeptr_ = node_traits::get_previous(members_.nodeptr_);
return static_cast<list_iterator&> (*this); return static_cast<list_iterator&> (*this);
} }
BOOST_INTRUSIVE_FORCEINLINE list_iterator operator--(int) inline list_iterator operator--(int)
{ {
list_iterator result (*this); list_iterator result (*this);
members_.nodeptr_ = node_traits::get_previous(members_.nodeptr_); members_.nodeptr_ = node_traits::get_previous(members_.nodeptr_);
return result; return result;
} }
BOOST_INTRUSIVE_FORCEINLINE friend bool operator== (const list_iterator& l, const list_iterator& r) inline friend bool operator== (const list_iterator& l, const list_iterator& r)
{ return l.pointed_node() == r.pointed_node(); } { return l.pointed_node() == r.pointed_node(); }
BOOST_INTRUSIVE_FORCEINLINE friend bool operator!= (const list_iterator& l, const list_iterator& r) inline friend bool operator!= (const list_iterator& l, const list_iterator& r)
{ return !(l == r); } { return !(l == r); }
BOOST_INTRUSIVE_FORCEINLINE reference operator*() const inline reference operator*() const
{ return *operator->(); } { return *operator->(); }
BOOST_INTRUSIVE_FORCEINLINE pointer operator->() const inline pointer operator->() const
{ return this->operator_arrow(detail::bool_<stateful_value_traits>()); } { return this->operator_arrow(detail::bool_<stateful_value_traits>()); }
BOOST_INTRUSIVE_FORCEINLINE list_iterator<ValueTraits, false> unconst() const inline list_iterator<ValueTraits, false> unconst() const
{ return list_iterator<ValueTraits, false>(this->pointed_node(), this->get_value_traits()); } { return list_iterator<ValueTraits, false>(this->pointed_node(), this->get_value_traits()); }
private: private:
BOOST_INTRUSIVE_FORCEINLINE pointer operator_arrow(detail::false_) const inline pointer operator_arrow(detail::false_) const
{ return ValueTraits::to_value_ptr(members_.nodeptr_); } { return ValueTraits::to_value_ptr(members_.nodeptr_); }
BOOST_INTRUSIVE_FORCEINLINE pointer operator_arrow(detail::true_) const inline pointer operator_arrow(detail::true_) const
{ return this->get_value_traits()->to_value_ptr(members_.nodeptr_); } { return this->get_value_traits()->to_value_ptr(members_.nodeptr_); }
iiterator_members<node_ptr, const_value_traits_ptr, stateful_value_traits> members_; iiterator_members<node_ptr, const_value_traits_ptr, stateful_value_traits> members_;

6
include/boost/intrusive/detail/node_cloner_disposer.hpp
View File

@ -59,7 +59,7 @@ struct node_cloner
{} {}
// tree-based containers use this method, which is proxy-reference friendly // tree-based containers use this method, which is proxy-reference friendly
BOOST_INTRUSIVE_FORCEINLINE node_ptr operator()(node_ptr p) inline node_ptr operator()(node_ptr p)
{ {
reference_type v = *traits_->to_value_ptr(p); reference_type v = *traits_->to_value_ptr(p);
node_ptr n = traits_->to_node_ptr(*base_t::get()(v)); node_ptr n = traits_->to_node_ptr(*base_t::get()(v));
@ -85,11 +85,11 @@ struct node_disposer
static const bool safemode_or_autounlink = static const bool safemode_or_autounlink =
is_safe_autounlink<value_traits::link_mode>::value; is_safe_autounlink<value_traits::link_mode>::value;
BOOST_INTRUSIVE_FORCEINLINE node_disposer(F f, const ValueTraits *cont) inline node_disposer(F f, const ValueTraits *cont)
: base_t(f), traits_(cont) : base_t(f), traits_(cont)
{} {}
BOOST_INTRUSIVE_FORCEINLINE void operator()(node_ptr p) inline void operator()(node_ptr p)
{ {
BOOST_IF_CONSTEXPR(safemode_or_autounlink) BOOST_IF_CONSTEXPR(safemode_or_autounlink)
node_algorithms::init(p); node_algorithms::init(p);

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

@ -41,7 +41,7 @@ class init_disposer
typedef typename NodeAlgorithms::node_ptr node_ptr; typedef typename NodeAlgorithms::node_ptr node_ptr;
public: public:
BOOST_INTRUSIVE_FORCEINLINE void operator()(node_ptr p) inline void operator()(node_ptr p)
{ NodeAlgorithms::init(p); } { NodeAlgorithms::init(p); }
}; };

28
include/boost/intrusive/detail/size_holder.hpp
View File

@ -33,25 +33,25 @@ struct size_holder
static const bool constant_time_size = ConstantSize; static const bool constant_time_size = ConstantSize;
typedef SizeType size_type; typedef SizeType size_type;
BOOST_INTRUSIVE_FORCEINLINE SizeType get_size() const inline SizeType get_size() const
{ return size_; } { return size_; }
BOOST_INTRUSIVE_FORCEINLINE void set_size(SizeType size) inline void set_size(SizeType size)
{ size_ = size; } { size_ = size; }
BOOST_INTRUSIVE_FORCEINLINE void decrement() inline void decrement()
{ --size_; } { --size_; }
BOOST_INTRUSIVE_FORCEINLINE void increment() inline void increment()
{ ++size_; } { ++size_; }
BOOST_INTRUSIVE_FORCEINLINE void increase(SizeType n) inline void increase(SizeType n)
{ size_ += n; } { size_ += n; }
BOOST_INTRUSIVE_FORCEINLINE void decrease(SizeType n) inline void decrease(SizeType n)
{ size_ -= n; } { size_ -= n; }
BOOST_INTRUSIVE_FORCEINLINE void swap(size_holder &other) inline void swap(size_holder &other)
{ SizeType tmp(size_); size_ = other.size_; other.size_ = tmp; } { SizeType tmp(size_); size_ = other.size_; other.size_ = tmp; }
SizeType size_; SizeType size_;
@ -63,25 +63,25 @@ struct size_holder<false, SizeType, Tag>
static const bool constant_time_size = false; static const bool constant_time_size = false;
typedef SizeType size_type; typedef SizeType size_type;
BOOST_INTRUSIVE_FORCEINLINE size_type get_size() const inline size_type get_size() const
{ return 0; } { return 0; }
BOOST_INTRUSIVE_FORCEINLINE void set_size(size_type) inline void set_size(size_type)
{} {}
BOOST_INTRUSIVE_FORCEINLINE void decrement() inline void decrement()
{} {}
BOOST_INTRUSIVE_FORCEINLINE void increment() inline void increment()
{} {}
BOOST_INTRUSIVE_FORCEINLINE void increase(SizeType) inline void increase(SizeType)
{} {}
BOOST_INTRUSIVE_FORCEINLINE void decrease(SizeType) inline void decrease(SizeType)
{} {}
BOOST_INTRUSIVE_FORCEINLINE void swap(size_holder){} inline void swap(size_holder){}
}; };
} //namespace detail{ } //namespace detail{

38
include/boost/intrusive/detail/slist_iterator.hpp
View File

@ -63,75 +63,75 @@ class slist_iterator
typedef typename types_t::iterator_type::reference reference; typedef typename types_t::iterator_type::reference reference;
typedef typename types_t::iterator_type::iterator_category iterator_category; typedef typename types_t::iterator_type::iterator_category iterator_category;
BOOST_INTRUSIVE_FORCEINLINE slist_iterator() inline slist_iterator()
{} {}
BOOST_INTRUSIVE_FORCEINLINE slist_iterator(node_ptr nodeptr, const_value_traits_ptr traits_ptr) inline slist_iterator(node_ptr nodeptr, const_value_traits_ptr traits_ptr)
: members_(nodeptr, traits_ptr) : members_(nodeptr, traits_ptr)
{} {}
BOOST_INTRUSIVE_FORCEINLINE explicit slist_iterator(node_ptr nodeptr) inline explicit slist_iterator(node_ptr nodeptr)
: members_(nodeptr, const_value_traits_ptr()) : members_(nodeptr, const_value_traits_ptr())
{ BOOST_STATIC_ASSERT((stateful_value_traits == false)); } { BOOST_STATIC_ASSERT((stateful_value_traits == false)); }
BOOST_INTRUSIVE_FORCEINLINE slist_iterator(const slist_iterator &other) inline slist_iterator(const slist_iterator &other)
: members_(other.pointed_node(), other.get_value_traits()) : members_(other.pointed_node(), other.get_value_traits())
{} {}
BOOST_INTRUSIVE_FORCEINLINE slist_iterator(const nonconst_iterator &other) inline slist_iterator(const nonconst_iterator &other)
: members_(other.pointed_node(), other.get_value_traits()) : members_(other.pointed_node(), other.get_value_traits())
{} {}
BOOST_INTRUSIVE_FORCEINLINE slist_iterator &operator=(const slist_iterator &other) inline slist_iterator &operator=(const slist_iterator &other)
{ members_.nodeptr_ = other.members_.nodeptr_; return *this; } { members_.nodeptr_ = other.members_.nodeptr_; return *this; }
BOOST_INTRUSIVE_FORCEINLINE node_ptr pointed_node() const inline node_ptr pointed_node() const
{ return members_.nodeptr_; } { return members_.nodeptr_; }
BOOST_INTRUSIVE_FORCEINLINE slist_iterator &operator=(node_ptr n) inline slist_iterator &operator=(node_ptr n)
{ members_.nodeptr_ = n; return static_cast<slist_iterator&>(*this); } { members_.nodeptr_ = n; return static_cast<slist_iterator&>(*this); }
BOOST_INTRUSIVE_FORCEINLINE const_value_traits_ptr get_value_traits() const inline const_value_traits_ptr get_value_traits() const
{ return members_.get_ptr(); } { return members_.get_ptr(); }
BOOST_INTRUSIVE_FORCEINLINE bool operator!() const inline bool operator!() const
{ return !members_.nodeptr_; } { return !members_.nodeptr_; }
public: public:
BOOST_INTRUSIVE_FORCEINLINE slist_iterator& operator++() inline slist_iterator& operator++()
{ {
members_.nodeptr_ = node_traits::get_next(members_.nodeptr_); members_.nodeptr_ = node_traits::get_next(members_.nodeptr_);
return static_cast<slist_iterator&> (*this); return static_cast<slist_iterator&> (*this);
} }
BOOST_INTRUSIVE_FORCEINLINE slist_iterator operator++(int) inline slist_iterator operator++(int)
{ {
slist_iterator result (*this); slist_iterator result (*this);
members_.nodeptr_ = node_traits::get_next(members_.nodeptr_); members_.nodeptr_ = node_traits::get_next(members_.nodeptr_);
return result; return result;
} }
BOOST_INTRUSIVE_FORCEINLINE friend bool operator== (const slist_iterator& l, const slist_iterator& r) inline friend bool operator== (const slist_iterator& l, const slist_iterator& r)
{ return l.pointed_node() == r.pointed_node(); } { return l.pointed_node() == r.pointed_node(); }
BOOST_INTRUSIVE_FORCEINLINE friend bool operator!= (const slist_iterator& l, const slist_iterator& r) inline friend bool operator!= (const slist_iterator& l, const slist_iterator& r)
{ return l.pointed_node() != r.pointed_node(); } { return l.pointed_node() != r.pointed_node(); }
BOOST_INTRUSIVE_FORCEINLINE reference operator*() const inline reference operator*() const
{ return *operator->(); } { return *operator->(); }
BOOST_INTRUSIVE_FORCEINLINE pointer operator->() const inline pointer operator->() const
{ return this->operator_arrow(detail::bool_<stateful_value_traits>()); } { return this->operator_arrow(detail::bool_<stateful_value_traits>()); }
BOOST_INTRUSIVE_FORCEINLINE slist_iterator<ValueTraits, false> unconst() const inline slist_iterator<ValueTraits, false> unconst() const
{ return slist_iterator<ValueTraits, false>(this->pointed_node(), this->get_value_traits()); } { return slist_iterator<ValueTraits, false>(this->pointed_node(), this->get_value_traits()); }
private: private:
BOOST_INTRUSIVE_FORCEINLINE pointer operator_arrow(detail::false_) const inline pointer operator_arrow(detail::false_) const
{ return ValueTraits::to_value_ptr(members_.nodeptr_); } { return ValueTraits::to_value_ptr(members_.nodeptr_); }
BOOST_INTRUSIVE_FORCEINLINE pointer operator_arrow(detail::true_) const inline pointer operator_arrow(detail::true_) const
{ return this->get_value_traits()->to_value_ptr(members_.nodeptr_); } { return this->get_value_traits()->to_value_ptr(members_.nodeptr_); }
iiterator_members<node_ptr, const_value_traits_ptr, stateful_value_traits> members_; iiterator_members<node_ptr, const_value_traits_ptr, stateful_value_traits> members_;

44
include/boost/intrusive/detail/transform_iterator.hpp
View File

@ -33,11 +33,11 @@ namespace detail {
template <class PseudoReference> template <class PseudoReference>
struct operator_arrow_proxy struct operator_arrow_proxy
{ {
BOOST_INTRUSIVE_FORCEINLINE operator_arrow_proxy(const PseudoReference &px) inline operator_arrow_proxy(const PseudoReference &px)
: m_value(px) : m_value(px)
{} {}
BOOST_INTRUSIVE_FORCEINLINE PseudoReference* operator->() const { return &m_value; } inline PseudoReference* operator->() const { return &m_value; }
// This function is needed for MWCW and BCC, which won't call operator-> // This function is needed for MWCW and BCC, which won't call operator->
// again automatically per 13.3.1.2 para 8 // again automatically per 13.3.1.2 para 8
// operator T*() const { return &m_value; } // operator T*() const { return &m_value; }
@ -47,11 +47,11 @@ struct operator_arrow_proxy
template <class T> template <class T>
struct operator_arrow_proxy<T&> struct operator_arrow_proxy<T&>
{ {
BOOST_INTRUSIVE_FORCEINLINE operator_arrow_proxy(T &px) inline operator_arrow_proxy(T &px)
: m_value(px) : m_value(px)
{} {}
BOOST_INTRUSIVE_FORCEINLINE T* operator->() const { return &m_value; } inline T* operator->() const { return &m_value; }
// This function is needed for MWCW and BCC, which won't call operator-> // This function is needed for MWCW and BCC, which won't call operator->
// again automatically per 13.3.1.2 para 8 // again automatically per 13.3.1.2 para 8
// operator T*() const { return &m_value; } // operator T*() const { return &m_value; }
@ -76,53 +76,53 @@ class transform_iterator
: members_() : members_()
{} {}
BOOST_INTRUSIVE_FORCEINLINE Iterator get_it() const inline Iterator get_it() const
{ return members_.m_it; } { return members_.m_it; }
//Constructors //Constructors
BOOST_INTRUSIVE_FORCEINLINE transform_iterator& operator++() inline transform_iterator& operator++()
{ increment(); return *this; } { increment(); return *this; }
BOOST_INTRUSIVE_FORCEINLINE transform_iterator operator++(int) inline transform_iterator operator++(int)
{ {
transform_iterator result (*this); transform_iterator result (*this);
increment(); increment();
return result; return result;
} }
BOOST_INTRUSIVE_FORCEINLINE friend bool operator== (const transform_iterator& i, const transform_iterator& i2) inline friend bool operator== (const transform_iterator& i, const transform_iterator& i2)
{ return i.equal(i2); } { return i.equal(i2); }
BOOST_INTRUSIVE_FORCEINLINE friend bool operator!= (const transform_iterator& i, const transform_iterator& i2) inline friend bool operator!= (const transform_iterator& i, const transform_iterator& i2)
{ return !(i == i2); } { return !(i == i2); }
BOOST_INTRUSIVE_FORCEINLINE friend typename Iterator::difference_type operator- (const transform_iterator& i, const transform_iterator& i2) inline friend typename Iterator::difference_type operator- (const transform_iterator& i, const transform_iterator& i2)
{ return i2.distance_to(i); } { return i2.distance_to(i); }
//Arithmetic //Arithmetic
transform_iterator& operator+=(typename Iterator::difference_type off) transform_iterator& operator+=(typename Iterator::difference_type off)
{ this->advance(off); return *this; } { this->advance(off); return *this; }
BOOST_INTRUSIVE_FORCEINLINE transform_iterator operator+(typename Iterator::difference_type off) const inline transform_iterator operator+(typename Iterator::difference_type off) const
{ {
transform_iterator other(*this); transform_iterator other(*this);
other.advance(off); other.advance(off);
return other; return other;
} }
BOOST_INTRUSIVE_FORCEINLINE friend transform_iterator operator+(typename Iterator::difference_type off, const transform_iterator& right) inline friend transform_iterator operator+(typename Iterator::difference_type off, const transform_iterator& right)
{ return right + off; } { return right + off; }
BOOST_INTRUSIVE_FORCEINLINE transform_iterator& operator-=(typename Iterator::difference_type off) inline transform_iterator& operator-=(typename Iterator::difference_type off)
{ this->advance(-off); return *this; } { this->advance(-off); return *this; }
BOOST_INTRUSIVE_FORCEINLINE transform_iterator operator-(typename Iterator::difference_type off) const inline transform_iterator operator-(typename Iterator::difference_type off) const
{ return *this + (-off); } { return *this + (-off); }
BOOST_INTRUSIVE_FORCEINLINE typename UnaryFunction::result_type operator*() const inline typename UnaryFunction::result_type operator*() const
{ return dereference(); } { return dereference(); }
BOOST_INTRUSIVE_FORCEINLINE operator_arrow_proxy<typename UnaryFunction::result_type> inline operator_arrow_proxy<typename UnaryFunction::result_type>
operator->() const operator->() const
{ return operator_arrow_proxy<typename UnaryFunction::result_type>(dereference()); } { return operator_arrow_proxy<typename UnaryFunction::result_type>(dereference()); }
@ -130,27 +130,27 @@ class transform_iterator
struct members struct members
: UnaryFunction : UnaryFunction
{ {
BOOST_INTRUSIVE_FORCEINLINE members(const Iterator &it, const UnaryFunction &f) inline members(const Iterator &it, const UnaryFunction &f)
: UnaryFunction(f), m_it(it) : UnaryFunction(f), m_it(it)
{} {}
BOOST_INTRUSIVE_FORCEINLINE members() inline members()
{} {}
Iterator m_it; Iterator m_it;
} members_; } members_;
BOOST_INTRUSIVE_FORCEINLINE void increment() inline void increment()
{ ++members_.m_it; } { ++members_.m_it; }
BOOST_INTRUSIVE_FORCEINLINE void decrement() inline void decrement()
{ --members_.m_it; } { --members_.m_it; }
BOOST_INTRUSIVE_FORCEINLINE bool equal(const transform_iterator &other) const inline bool equal(const transform_iterator &other) const
{ return members_.m_it == other.members_.m_it; } { return members_.m_it == other.members_.m_it; }
BOOST_INTRUSIVE_FORCEINLINE bool less(const transform_iterator &other) const inline bool less(const transform_iterator &other) const
{ return other.members_.m_it < members_.m_it; } { return other.members_.m_it < members_.m_it; }
typename UnaryFunction::result_type dereference() const typename UnaryFunction::result_type dereference() const

42
include/boost/intrusive/detail/tree_iterator.hpp
View File

@ -68,32 +68,32 @@ class tree_iterator
typedef typename types_t::iterator_type::reference reference; typedef typename types_t::iterator_type::reference reference;
typedef typename types_t::iterator_type::iterator_category iterator_category; typedef typename types_t::iterator_type::iterator_category iterator_category;
BOOST_INTRUSIVE_FORCEINLINE tree_iterator() inline tree_iterator()
{} {}
BOOST_INTRUSIVE_FORCEINLINE explicit tree_iterator(node_ptr nodeptr, const_value_traits_ptr traits_ptr) inline explicit tree_iterator(node_ptr nodeptr, const_value_traits_ptr traits_ptr)
: members_(nodeptr, traits_ptr) : members_(nodeptr, traits_ptr)
{} {}
BOOST_INTRUSIVE_FORCEINLINE tree_iterator(const tree_iterator &other) inline tree_iterator(const tree_iterator &other)
: members_(other.pointed_node(), other.get_value_traits()) : members_(other.pointed_node(), other.get_value_traits())
{} {}
BOOST_INTRUSIVE_FORCEINLINE tree_iterator(const nonconst_iterator &other) inline tree_iterator(const nonconst_iterator &other)
: members_(other.pointed_node(), other.get_value_traits()) : members_(other.pointed_node(), other.get_value_traits())
{} {}
BOOST_INTRUSIVE_FORCEINLINE tree_iterator &operator=(const tree_iterator &other) inline tree_iterator &operator=(const tree_iterator &other)
{ members_.nodeptr_ = other.members_.nodeptr_; return *this; } { members_.nodeptr_ = other.members_.nodeptr_; return *this; }
BOOST_INTRUSIVE_FORCEINLINE tree_iterator &operator=(node_ptr nodeptr) inline tree_iterator &operator=(node_ptr nodeptr)
{ members_.nodeptr_ = nodeptr; return *this; } { members_.nodeptr_ = nodeptr; return *this; }
BOOST_INTRUSIVE_FORCEINLINE node_ptr pointed_node() const inline node_ptr pointed_node() const
{ return members_.nodeptr_; } { return members_.nodeptr_; }
public: public:
BOOST_INTRUSIVE_FORCEINLINE tree_iterator& operator++() inline tree_iterator& operator++()
{ {
members_.nodeptr_ = node_algorithms::next_node(members_.nodeptr_); members_.nodeptr_ = node_algorithms::next_node(members_.nodeptr_);
return *this; return *this;
@ -106,7 +106,7 @@ class tree_iterator
return result; return result;
} }
BOOST_INTRUSIVE_FORCEINLINE tree_iterator& operator--() inline tree_iterator& operator--()
{ {
members_.nodeptr_ = node_algorithms::prev_node(members_.nodeptr_); members_.nodeptr_ = node_algorithms::prev_node(members_.nodeptr_);
return *this; return *this;
@ -119,43 +119,43 @@ class tree_iterator
return result; return result;
} }
BOOST_INTRUSIVE_FORCEINLINE tree_iterator& go_left() inline tree_iterator& go_left()
{ {
members_.nodeptr_ = node_traits::get_left(members_.nodeptr_); members_.nodeptr_ = node_traits::get_left(members_.nodeptr_);
return *this; return *this;
} }
BOOST_INTRUSIVE_FORCEINLINE tree_iterator& go_right() inline tree_iterator& go_right()
{ {
members_.nodeptr_ = node_traits::get_right(members_.nodeptr_); members_.nodeptr_ = node_traits::get_right(members_.nodeptr_);
return *this; return *this;
} }
BOOST_INTRUSIVE_FORCEINLINE tree_iterator& go_parent() inline tree_iterator& go_parent()
{ {
members_.nodeptr_ = node_traits::get_parent(members_.nodeptr_); members_.nodeptr_ = node_traits::get_parent(members_.nodeptr_);
return *this; return *this;
} }
BOOST_INTRUSIVE_FORCEINLINE operator unspecified_bool_type() const inline operator unspecified_bool_type() const
{ return members_.nodeptr_ ? &tree_iterator::unspecified_bool_type_func : 0; } { return members_.nodeptr_ ? &tree_iterator::unspecified_bool_type_func : 0; }
BOOST_INTRUSIVE_FORCEINLINE bool operator! () const inline bool operator! () const
{ return !members_.nodeptr_; } { return !members_.nodeptr_; }
BOOST_INTRUSIVE_FORCEINLINE friend bool operator== (const tree_iterator& l, const tree_iterator& r) inline friend bool operator== (const tree_iterator& l, const tree_iterator& r)
{ return l.pointed_node() == r.pointed_node(); } { return l.pointed_node() == r.pointed_node(); }
BOOST_INTRUSIVE_FORCEINLINE friend bool operator!= (const tree_iterator& l, const tree_iterator& r) inline friend bool operator!= (const tree_iterator& l, const tree_iterator& r)
{ return !(l == r); } { return !(l == r); }
BOOST_INTRUSIVE_FORCEINLINE reference operator*() const inline reference operator*() const
{ return *operator->(); } { return *operator->(); }
BOOST_INTRUSIVE_FORCEINLINE pointer operator->() const inline pointer operator->() const
{ return this->operator_arrow(detail::bool_<stateful_value_traits>()); } { return this->operator_arrow(detail::bool_<stateful_value_traits>()); }
BOOST_INTRUSIVE_FORCEINLINE const_value_traits_ptr get_value_traits() const inline const_value_traits_ptr get_value_traits() const
{ return members_.get_ptr(); } { return members_.get_ptr(); }
tree_iterator end_iterator_from_it() const tree_iterator end_iterator_from_it() const
@ -167,10 +167,10 @@ class tree_iterator
{ return tree_iterator<value_traits, false>(this->pointed_node(), this->get_value_traits()); } { return tree_iterator<value_traits, false>(this->pointed_node(), this->get_value_traits()); }
private: private:
BOOST_INTRUSIVE_FORCEINLINE pointer operator_arrow(detail::false_) const inline pointer operator_arrow(detail::false_) const
{ return ValueTraits::to_value_ptr(members_.nodeptr_); } { return ValueTraits::to_value_ptr(members_.nodeptr_); }
BOOST_INTRUSIVE_FORCEINLINE pointer operator_arrow(detail::true_) const inline pointer operator_arrow(detail::true_) const
{ return this->get_value_traits()->to_value_ptr(members_.nodeptr_); } { return this->get_value_traits()->to_value_ptr(members_.nodeptr_); }
iiterator_members<node_ptr, const_value_traits_ptr, stateful_value_traits> members_; iiterator_members<node_ptr, const_value_traits_ptr, stateful_value_traits> members_;

56
include/boost/intrusive/detail/tree_value_compare.hpp
View File

@ -59,67 +59,67 @@ struct tree_value_compare
typedef boost::intrusive::detail::ebo_functor_holder<KeyCompare> base_t; typedef boost::intrusive::detail::ebo_functor_holder<KeyCompare> base_t;
BOOST_INTRUSIVE_FORCEINLINE tree_value_compare() inline tree_value_compare()
: base_t() : base_t()
{} {}
BOOST_INTRUSIVE_FORCEINLINE explicit tree_value_compare(const key_compare &kcomp) inline explicit tree_value_compare(const key_compare &kcomp)
: base_t(kcomp) : base_t(kcomp)
{} {}
BOOST_INTRUSIVE_FORCEINLINE tree_value_compare (const tree_value_compare &x) inline tree_value_compare (const tree_value_compare &x)
: base_t(x.base_t::get()) : base_t(x.base_t::get())
{} {}
BOOST_INTRUSIVE_FORCEINLINE tree_value_compare &operator=(const tree_value_compare &x) inline tree_value_compare &operator=(const tree_value_compare &x)
{ this->base_t::get() = x.base_t::get(); return *this; } { this->base_t::get() = x.base_t::get(); return *this; }
BOOST_INTRUSIVE_FORCEINLINE tree_value_compare &operator=(const key_compare &x) inline tree_value_compare &operator=(const key_compare &x)
{ this->base_t::get() = x; return *this; } { this->base_t::get() = x; return *this; }
BOOST_INTRUSIVE_FORCEINLINE const key_compare &key_comp() const inline const key_compare &key_comp() const
{ return static_cast<const key_compare &>(*this); } { return static_cast<const key_compare &>(*this); }
BOOST_INTRUSIVE_FORCEINLINE Ret operator()(const key_type &key) const inline Ret operator()(const key_type &key) const
{ return this->key_comp()(key); } { return this->key_comp()(key); }
BOOST_INTRUSIVE_FORCEINLINE Ret operator()(const value_type &value) const inline Ret operator()(const value_type &value) const
{ return this->key_comp()(KeyOfValue()(value)); } { return this->key_comp()(KeyOfValue()(value)); }
template<class U> template<class U>
BOOST_INTRUSIVE_FORCEINLINE Ret operator()( const U &nonkey inline Ret operator()( const U &nonkey
, typename disable_if_smartref_to<U, ValuePtr>::type* = 0) const , typename disable_if_smartref_to<U, ValuePtr>::type* = 0) const
{ return this->key_comp()(nonkey); } { return this->key_comp()(nonkey); }
BOOST_INTRUSIVE_FORCEINLINE Ret operator()(const key_type &key1, const key_type &key2) const inline Ret operator()(const key_type &key1, const key_type &key2) const
{ return this->key_comp()(key1, key2); } { return this->key_comp()(key1, key2); }
BOOST_INTRUSIVE_FORCEINLINE Ret operator()(const value_type &value1, const value_type &value2) const inline Ret operator()(const value_type &value1, const value_type &value2) const
{ return this->key_comp()(KeyOfValue()(value1), KeyOfValue()(value2)); } { return this->key_comp()(KeyOfValue()(value1), KeyOfValue()(value2)); }
BOOST_INTRUSIVE_FORCEINLINE Ret operator()(const key_type &key1, const value_type &value2) const inline Ret operator()(const key_type &key1, const value_type &value2) const
{ return this->key_comp()(key1, KeyOfValue()(value2)); } { return this->key_comp()(key1, KeyOfValue()(value2)); }
BOOST_INTRUSIVE_FORCEINLINE Ret operator()(const value_type &value1, const key_type &key2) const inline Ret operator()(const value_type &value1, const key_type &key2) const
{ return this->key_comp()(KeyOfValue()(value1), key2); } { return this->key_comp()(KeyOfValue()(value1), key2); }
template<class U> template<class U>
BOOST_INTRUSIVE_FORCEINLINE Ret operator()( const key_type &key1, const U &nonkey2 inline Ret operator()( const key_type &key1, const U &nonkey2
, typename disable_if_smartref_to<U, ValuePtr>::type* = 0) const , typename disable_if_smartref_to<U, ValuePtr>::type* = 0) const
{ return this->key_comp()(key1, nonkey2); } { return this->key_comp()(key1, nonkey2); }
template<class U> template<class U>
BOOST_INTRUSIVE_FORCEINLINE Ret operator()( const U &nonkey1, const key_type &key2 inline Ret operator()( const U &nonkey1, const key_type &key2
, typename disable_if_smartref_to<U, ValuePtr>::type* = 0) const , typename disable_if_smartref_to<U, ValuePtr>::type* = 0) const
{ return this->key_comp()(nonkey1, key2); } { return this->key_comp()(nonkey1, key2); }
template<class U> template<class U>
BOOST_INTRUSIVE_FORCEINLINE Ret operator()( const value_type &value1, const U &nonvalue2 inline Ret operator()( const value_type &value1, const U &nonvalue2
, typename disable_if_smartref_to<U, ValuePtr>::type* = 0) const , typename disable_if_smartref_to<U, ValuePtr>::type* = 0) const
{ return this->key_comp()(KeyOfValue()(value1), nonvalue2); } { return this->key_comp()(KeyOfValue()(value1), nonvalue2); }
template<class U> template<class U>
BOOST_INTRUSIVE_FORCEINLINE Ret operator()( const U &nonvalue1, const value_type &value2 inline Ret operator()( const U &nonvalue1, const value_type &value2
, typename disable_if_smartref_to<U, ValuePtr>::type* = 0) const , typename disable_if_smartref_to<U, ValuePtr>::type* = 0) const
{ return this->key_comp()(nonvalue1, KeyOfValue()(value2)); } { return this->key_comp()(nonvalue1, KeyOfValue()(value2)); }
}; };
@ -137,45 +137,45 @@ struct tree_value_compare<ValuePtr, KeyCompare, KeyOfValue, Ret, true>
typedef boost::intrusive::detail::ebo_functor_holder<KeyCompare> base_t; typedef boost::intrusive::detail::ebo_functor_holder<KeyCompare> base_t;
BOOST_INTRUSIVE_FORCEINLINE tree_value_compare() inline tree_value_compare()
: base_t() : base_t()
{} {}
BOOST_INTRUSIVE_FORCEINLINE explicit tree_value_compare(const key_compare &kcomp) inline explicit tree_value_compare(const key_compare &kcomp)
: base_t(kcomp) : base_t(kcomp)
{} {}
BOOST_INTRUSIVE_FORCEINLINE tree_value_compare (const tree_value_compare &x) inline tree_value_compare (const tree_value_compare &x)
: base_t(x.base_t::get()) : base_t(x.base_t::get())
{} {}
BOOST_INTRUSIVE_FORCEINLINE tree_value_compare &operator=(const tree_value_compare &x) inline tree_value_compare &operator=(const tree_value_compare &x)
{ this->base_t::get() = x.base_t::get(); return *this; } { this->base_t::get() = x.base_t::get(); return *this; }
BOOST_INTRUSIVE_FORCEINLINE tree_value_compare &operator=(const key_compare &x) inline tree_value_compare &operator=(const key_compare &x)
{ this->base_t::get() = x; return *this; } { this->base_t::get() = x; return *this; }
BOOST_INTRUSIVE_FORCEINLINE const key_compare &key_comp() const inline const key_compare &key_comp() const
{ return static_cast<const key_compare &>(*this); } { return static_cast<const key_compare &>(*this); }
BOOST_INTRUSIVE_FORCEINLINE Ret operator()(const key_type &key) const inline Ret operator()(const key_type &key) const
{ return this->key_comp()(key); } { return this->key_comp()(key); }
template<class U> template<class U>
BOOST_INTRUSIVE_FORCEINLINE Ret operator()( const U &nonkey inline Ret operator()( const U &nonkey
, typename disable_if_smartref_to<U, ValuePtr>::type* = 0) const , typename disable_if_smartref_to<U, ValuePtr>::type* = 0) const
{ return this->key_comp()(nonkey); } { return this->key_comp()(nonkey); }
BOOST_INTRUSIVE_FORCEINLINE Ret operator()(const key_type &key1, const key_type &key2) const inline Ret operator()(const key_type &key1, const key_type &key2) const
{ return this->key_comp()(key1, key2); } { return this->key_comp()(key1, key2); }
template<class U> template<class U>
BOOST_INTRUSIVE_FORCEINLINE Ret operator()( const key_type &key1, const U &nonkey2 inline Ret operator()( const key_type &key1, const U &nonkey2
, typename disable_if_smartref_to<U, ValuePtr>::type* = 0) const , typename disable_if_smartref_to<U, ValuePtr>::type* = 0) const
{ return this->key_comp()(key1, nonkey2); } { return this->key_comp()(key1, nonkey2); }
template<class U> template<class U>
BOOST_INTRUSIVE_FORCEINLINE Ret operator()(const U &nonkey1, const key_type &key2 inline Ret operator()(const U &nonkey1, const key_type &key2
, typename disable_if_smartref_to<U, ValuePtr>::type* = 0) const , typename disable_if_smartref_to<U, ValuePtr>::type* = 0) const
{ return this->key_comp()(nonkey1, key2); } { return this->key_comp()(nonkey1, key2); }
}; };

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

File diff suppressed because it is too large Load Diff

16
include/boost/intrusive/linear_slist_algorithms.hpp
View File

@ -151,7 +151,7 @@ class linear_slist_algorithms
//! <b>Complexity</b>: Constant //! <b>Complexity</b>: Constant
//! //!
//! <b>Throws</b>: Nothing. //! <b>Throws</b>: Nothing.
BOOST_INTRUSIVE_FORCEINLINE static void init_header(node_ptr this_node) BOOST_NOEXCEPT inline static void init_header(node_ptr this_node) BOOST_NOEXCEPT
{ NodeTraits::set_next(this_node, node_ptr ()); } { NodeTraits::set_next(this_node, node_ptr ()); }
//! <b>Requires</b>: 'p' is the first node of a list. //! <b>Requires</b>: 'p' is the first node of a list.
@ -161,7 +161,7 @@ class linear_slist_algorithms
//! <b>Complexity</b>: Constant time. //! <b>Complexity</b>: Constant time.
//! //!
//! <b>Throws</b>: Nothing. //! <b>Throws</b>: Nothing.
BOOST_INTRUSIVE_FORCEINLINE static node_ptr end_node(const_node_ptr) BOOST_NOEXCEPT inline static node_ptr end_node(const_node_ptr) BOOST_NOEXCEPT
{ return node_ptr(); } { return node_ptr(); }
//! <b>Effects</b>: Returns true if this_node_points to an empty list. //! <b>Effects</b>: Returns true if this_node_points to an empty list.
@ -169,7 +169,7 @@ class linear_slist_algorithms
//! <b>Complexity</b>: Constant //! <b>Complexity</b>: Constant
//! //!
//! <b>Throws</b>: Nothing. //! <b>Throws</b>: Nothing.
BOOST_INTRUSIVE_FORCEINLINE static bool is_empty(const_node_ptr this_node) BOOST_NOEXCEPT inline static bool is_empty(const_node_ptr this_node) BOOST_NOEXCEPT
{ return !NodeTraits::get_next(this_node); } { return !NodeTraits::get_next(this_node); }
//! <b>Effects</b>: Returns true if this_node points to a sentinel node. //! <b>Effects</b>: Returns true if this_node points to a sentinel node.
@ -177,7 +177,7 @@ class linear_slist_algorithms
//! <b>Complexity</b>: Constant //! <b>Complexity</b>: Constant
//! //!
//! <b>Throws</b>: Nothing. //! <b>Throws</b>: Nothing.
BOOST_INTRUSIVE_FORCEINLINE static bool is_sentinel(const_node_ptr this_node) BOOST_NOEXCEPT inline static bool is_sentinel(const_node_ptr this_node) BOOST_NOEXCEPT
{ return NodeTraits::get_next(this_node) == this_node; } { return NodeTraits::get_next(this_node) == this_node; }
//! <b>Effects</b>: Marks this node as a "sentinel" node, a special state that is different from "empty", //! <b>Effects</b>: Marks this node as a "sentinel" node, a special state that is different from "empty",
@ -186,7 +186,7 @@ class linear_slist_algorithms
//! <b>Complexity</b>: Constant //! <b>Complexity</b>: Constant
//! //!
//! <b>Throws</b>: Nothing. //! <b>Throws</b>: Nothing.
BOOST_INTRUSIVE_FORCEINLINE static void set_sentinel(node_ptr this_node) BOOST_NOEXCEPT inline static void set_sentinel(node_ptr this_node) BOOST_NOEXCEPT
{ NodeTraits::set_next(this_node, this_node); } { NodeTraits::set_next(this_node, this_node); }
//! <b>Requires</b>: this_node and prev_init_node must be in the same linear list. //! <b>Requires</b>: this_node and prev_init_node must be in the same linear list.
@ -198,7 +198,7 @@ class linear_slist_algorithms
//! <b>Complexity</b>: Linear to the number of elements between prev_init_node and this_node. //! <b>Complexity</b>: Linear to the number of elements between prev_init_node and this_node.
//! //!
//! <b>Throws</b>: Nothing. //! <b>Throws</b>: Nothing.
BOOST_INTRUSIVE_FORCEINLINE static node_ptr inline static node_ptr
get_previous_node(node_ptr prev_init_node, node_ptr this_node) BOOST_NOEXCEPT get_previous_node(node_ptr prev_init_node, node_ptr this_node) BOOST_NOEXCEPT
{ return base_t::get_previous_node(prev_init_node, this_node); } { return base_t::get_previous_node(prev_init_node, this_node); }
@ -230,7 +230,7 @@ class linear_slist_algorithms
//! <b>Complexity</b>: Constant //! <b>Complexity</b>: Constant
//! //!
//! <b>Throws</b>: Nothing. //! <b>Throws</b>: Nothing.
BOOST_INTRUSIVE_FORCEINLINE static void swap_trailing_nodes(node_ptr this_node, node_ptr other_node) BOOST_NOEXCEPT inline static void swap_trailing_nodes(node_ptr this_node, node_ptr other_node) BOOST_NOEXCEPT
{ {
node_ptr this_nxt = NodeTraits::get_next(this_node); node_ptr this_nxt = NodeTraits::get_next(this_node);
node_ptr other_nxt = NodeTraits::get_next(other_node); node_ptr other_nxt = NodeTraits::get_next(other_node);
@ -400,7 +400,7 @@ class linear_slist_algorithms
//! //!
//! <b>Throws</b>: Nothing. //! <b>Throws</b>: Nothing.
template<class Disposer> template<class Disposer>
BOOST_INTRUSIVE_FORCEINLINE static std::size_t detach_and_dispose(node_ptr p, Disposer disposer) BOOST_NOEXCEPT inline static std::size_t detach_and_dispose(node_ptr p, Disposer disposer) BOOST_NOEXCEPT
{ return base_t::unlink_after_and_dispose(p, node_ptr(), disposer); } { return base_t::unlink_after_and_dispose(p, node_ptr(), disposer); }
}; };

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

@ -127,10 +127,10 @@ class list_impl
((int)value_traits::link_mode == (int)auto_unlink) ((int)value_traits::link_mode == (int)auto_unlink)
)); ));
BOOST_INTRUSIVE_FORCEINLINE node_ptr get_root_node() inline node_ptr get_root_node()
{ return data_.root_plus_size_.m_header.get_node(); } { return data_.root_plus_size_.m_header.get_node(); }
BOOST_INTRUSIVE_FORCEINLINE const_node_ptr get_root_node() const inline const_node_ptr get_root_node() const
{ return data_.root_plus_size_.m_header.get_node(); } { return data_.root_plus_size_.m_header.get_node(); }
struct root_plus_size : public size_traits struct root_plus_size : public size_traits
@ -141,29 +141,29 @@ class list_impl
struct data_t : public value_traits struct data_t : public value_traits
{ {
typedef typename list_impl::value_traits value_traits; typedef typename list_impl::value_traits value_traits;
BOOST_INTRUSIVE_FORCEINLINE explicit data_t(const value_traits &val_traits) inline explicit data_t(const value_traits &val_traits)
: value_traits(val_traits) : value_traits(val_traits)
{} {}
root_plus_size root_plus_size_; root_plus_size root_plus_size_;
} data_; } data_;
BOOST_INTRUSIVE_FORCEINLINE size_traits &priv_size_traits() BOOST_NOEXCEPT inline size_traits &priv_size_traits() BOOST_NOEXCEPT
{ return data_.root_plus_size_; } { return data_.root_plus_size_; }
BOOST_INTRUSIVE_FORCEINLINE const size_traits &priv_size_traits() const BOOST_NOEXCEPT inline const size_traits &priv_size_traits() const BOOST_NOEXCEPT
{ return data_.root_plus_size_; } { return data_.root_plus_size_; }
BOOST_INTRUSIVE_FORCEINLINE const value_traits &priv_value_traits() const BOOST_NOEXCEPT inline const value_traits &priv_value_traits() const BOOST_NOEXCEPT
{ return data_; } { return data_; }
BOOST_INTRUSIVE_FORCEINLINE value_traits &priv_value_traits() BOOST_NOEXCEPT inline value_traits &priv_value_traits() BOOST_NOEXCEPT
{ return data_; } { return data_; }
typedef typename boost::intrusive::value_traits_pointers typedef typename boost::intrusive::value_traits_pointers
<ValueTraits>::const_value_traits_ptr const_value_traits_ptr; <ValueTraits>::const_value_traits_ptr const_value_traits_ptr;
BOOST_INTRUSIVE_FORCEINLINE const_value_traits_ptr priv_value_traits_ptr() const BOOST_NOEXCEPT inline const_value_traits_ptr priv_value_traits_ptr() const BOOST_NOEXCEPT
{ return pointer_traits<const_value_traits_ptr>::pointer_to(this->priv_value_traits()); } { return pointer_traits<const_value_traits_ptr>::pointer_to(this->priv_value_traits()); }
/// @endcond /// @endcond
@ -364,7 +364,7 @@ class list_impl
//! <b>Throws</b>: Nothing. //! <b>Throws</b>: Nothing.
//! //!
//! <b>Complexity</b>: Constant. //! <b>Complexity</b>: Constant.
BOOST_INTRUSIVE_FORCEINLINE reference front() BOOST_NOEXCEPT inline reference front() BOOST_NOEXCEPT
{ return *priv_value_traits().to_value_ptr(node_traits::get_next(this->get_root_node())); } { return *priv_value_traits().to_value_ptr(node_traits::get_next(this->get_root_node())); }
//! <b>Effects</b>: Returns a const_reference to the first element of the list. //! <b>Effects</b>: Returns a const_reference to the first element of the list.
@ -372,7 +372,7 @@ class list_impl
//! <b>Throws</b>: Nothing. //! <b>Throws</b>: Nothing.
//! //!
//! <b>Complexity</b>: Constant. //! <b>Complexity</b>: Constant.
BOOST_INTRUSIVE_FORCEINLINE const_reference front() const BOOST_NOEXCEPT inline const_reference front() const BOOST_NOEXCEPT
{ return *priv_value_traits().to_value_ptr(node_traits::get_next(this->get_root_node())); } { return *priv_value_traits().to_value_ptr(node_traits::get_next(this->get_root_node())); }
//! <b>Effects</b>: Returns a reference to the last element of the list. //! <b>Effects</b>: Returns a reference to the last element of the list.
@ -380,7 +380,7 @@ class list_impl
//! <b>Throws</b>: Nothing. //! <b>Throws</b>: Nothing.
//! //!
//! <b>Complexity</b>: Constant. //! <b>Complexity</b>: Constant.
BOOST_INTRUSIVE_FORCEINLINE reference back() BOOST_NOEXCEPT inline reference back() BOOST_NOEXCEPT
{ return *priv_value_traits().to_value_ptr(node_traits::get_previous(this->get_root_node())); } { return *priv_value_traits().to_value_ptr(node_traits::get_previous(this->get_root_node())); }
//! <b>Effects</b>: Returns a const_reference to the last element of the list. //! <b>Effects</b>: Returns a const_reference to the last element of the list.
@ -388,7 +388,7 @@ class list_impl
//! <b>Throws</b>: Nothing. //! <b>Throws</b>: Nothing.
//! //!
//! <b>Complexity</b>: Constant. //! <b>Complexity</b>: Constant.
BOOST_INTRUSIVE_FORCEINLINE const_reference back() const BOOST_NOEXCEPT inline const_reference back() const BOOST_NOEXCEPT
{ return *priv_value_traits().to_value_ptr(detail::uncast(node_traits::get_previous(this->get_root_node()))); } { return *priv_value_traits().to_value_ptr(detail::uncast(node_traits::get_previous(this->get_root_node()))); }
//! <b>Effects</b>: Returns an iterator to the first element contained in the list. //! <b>Effects</b>: Returns an iterator to the first element contained in the list.
@ -396,7 +396,7 @@ class list_impl
//! <b>Throws</b>: Nothing. //! <b>Throws</b>: Nothing.
//! //!
//! <b>Complexity</b>: Constant. //! <b>Complexity</b>: Constant.
BOOST_INTRUSIVE_FORCEINLINE iterator begin() BOOST_NOEXCEPT inline iterator begin() BOOST_NOEXCEPT
{ return iterator(node_traits::get_next(this->get_root_node()), this->priv_value_traits_ptr()); } { return iterator(node_traits::get_next(this->get_root_node()), this->priv_value_traits_ptr()); }
//! <b>Effects</b>: Returns a const_iterator to the first element contained in the list. //! <b>Effects</b>: Returns a const_iterator to the first element contained in the list.
@ -404,7 +404,7 @@ class list_impl
//! <b>Throws</b>: Nothing. //! <b>Throws</b>: Nothing.
//! //!
//! <b>Complexity</b>: Constant. //! <b>Complexity</b>: Constant.
BOOST_INTRUSIVE_FORCEINLINE const_iterator begin() const BOOST_NOEXCEPT inline const_iterator begin() const BOOST_NOEXCEPT
{ return this->cbegin(); } { return this->cbegin(); }
//! <b>Effects</b>: Returns a const_iterator to the first element contained in the list. //! <b>Effects</b>: Returns a const_iterator to the first element contained in the list.
@ -412,7 +412,7 @@ class list_impl
//! <b>Throws</b>: Nothing. //! <b>Throws</b>: Nothing.
//! //!
//! <b>Complexity</b>: Constant. //! <b>Complexity</b>: Constant.
BOOST_INTRUSIVE_FORCEINLINE const_iterator cbegin() const BOOST_NOEXCEPT inline const_iterator cbegin() const BOOST_NOEXCEPT
{ return const_iterator(node_traits::get_next(this->get_root_node()), this->priv_value_traits_ptr()); } { return const_iterator(node_traits::get_next(this->get_root_node()), this->priv_value_traits_ptr()); }
//! <b>Effects</b>: Returns an iterator to the end of the list. //! <b>Effects</b>: Returns an iterator to the end of the list.
@ -420,7 +420,7 @@ class list_impl
//! <b>Throws</b>: Nothing. //! <b>Throws</b>: Nothing.
//! //!
//! <b>Complexity</b>: Constant. //! <b>Complexity</b>: Constant.
BOOST_INTRUSIVE_FORCEINLINE iterator end() BOOST_NOEXCEPT inline iterator end() BOOST_NOEXCEPT
{ return iterator(this->get_root_node(), this->priv_value_traits_ptr()); } { return iterator(this->get_root_node(), this->priv_value_traits_ptr()); }
//! <b>Effects</b>: Returns a const_iterator to the end of the list. //! <b>Effects</b>: Returns a const_iterator to the end of the list.
@ -428,7 +428,7 @@ class list_impl
//! <b>Throws</b>: Nothing. //! <b>Throws</b>: Nothing.
//! //!
//! <b>Complexity</b>: Constant. //! <b>Complexity</b>: Constant.
BOOST_INTRUSIVE_FORCEINLINE const_iterator end() const BOOST_NOEXCEPT inline const_iterator end() const BOOST_NOEXCEPT
{ return this->cend(); } { return this->cend(); }
//! <b>Effects</b>: Returns a constant iterator to the end of the list. //! <b>Effects</b>: Returns a constant iterator to the end of the list.
@ -436,7 +436,7 @@ class list_impl
//! <b>Throws</b>: Nothing. //! <b>Throws</b>: Nothing.
//! //!
//! <b>Complexity</b>: Constant. //! <b>Complexity</b>: Constant.
BOOST_INTRUSIVE_FORCEINLINE const_iterator cend() const BOOST_NOEXCEPT inline const_iterator cend() const BOOST_NOEXCEPT
{ return const_iterator(detail::uncast(this->get_root_node()), this->priv_value_traits_ptr()); } { return const_iterator(detail::uncast(this->get_root_node()), this->priv_value_traits_ptr()); }
//! <b>Effects</b>: Returns a reverse_iterator pointing to the beginning //! <b>Effects</b>: Returns a reverse_iterator pointing to the beginning
@ -445,7 +445,7 @@ class list_impl
//! <b>Throws</b>: Nothing. //! <b>Throws</b>: Nothing.
//! //!
//! <b>Complexity</b>: Constant. //! <b>Complexity</b>: Constant.
BOOST_INTRUSIVE_FORCEINLINE reverse_iterator rbegin() BOOST_NOEXCEPT inline reverse_iterator rbegin() BOOST_NOEXCEPT
{ return reverse_iterator(this->end()); } { return reverse_iterator(this->end()); }
//! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning
@ -454,7 +454,7 @@ class list_impl
//! <b>Throws</b>: Nothing. //! <b>Throws</b>: Nothing.
//! //!
//! <b>Complexity</b>: Constant. //! <b>Complexity</b>: Constant.
BOOST_INTRUSIVE_FORCEINLINE const_reverse_iterator rbegin() const BOOST_NOEXCEPT inline const_reverse_iterator rbegin() const BOOST_NOEXCEPT
{ return this->crbegin(); } { return this->crbegin(); }
//! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning
@ -463,7 +463,7 @@ class list_impl
//! <b>Throws</b>: Nothing. //! <b>Throws</b>: Nothing.
//! //!
//! <b>Complexity</b>: Constant. //! <b>Complexity</b>: Constant.
BOOST_INTRUSIVE_FORCEINLINE const_reverse_iterator crbegin() const BOOST_NOEXCEPT inline const_reverse_iterator crbegin() const BOOST_NOEXCEPT
{ return const_reverse_iterator(end()); } { return const_reverse_iterator(end()); }
//! <b>Effects</b>: Returns a reverse_iterator pointing to the end //! <b>Effects</b>: Returns a reverse_iterator pointing to the end
@ -472,7 +472,7 @@ class list_impl
//! <b>Throws</b>: Nothing. //! <b>Throws</b>: Nothing.
//! //!
//! <b>Complexity</b>: Constant. //! <b>Complexity</b>: Constant.
BOOST_INTRUSIVE_FORCEINLINE reverse_iterator rend() BOOST_NOEXCEPT inline reverse_iterator rend() BOOST_NOEXCEPT
{ return reverse_iterator(begin()); } { return reverse_iterator(begin()); }
//! <b>Effects</b>: Returns a const_reverse_iterator pointing to the end //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the end
@ -481,7 +481,7 @@ class list_impl
//! <b>Throws</b>: Nothing. //! <b>Throws</b>: Nothing.
//! //!
//! <b>Complexity</b>: Constant. //! <b>Complexity</b>: Constant.
BOOST_INTRUSIVE_FORCEINLINE const_reverse_iterator rend() const BOOST_NOEXCEPT inline const_reverse_iterator rend() const BOOST_NOEXCEPT
{ return this->crend(); } { return this->crend(); }
//! <b>Effects</b>: Returns a const_reverse_iterator pointing to the end //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the end
@ -490,7 +490,7 @@ class list_impl
//! <b>Throws</b>: Nothing. //! <b>Throws</b>: Nothing.
//! //!
//! <b>Complexity</b>: Constant. //! <b>Complexity</b>: Constant.
BOOST_INTRUSIVE_FORCEINLINE const_reverse_iterator crend() const BOOST_NOEXCEPT inline const_reverse_iterator crend() const BOOST_NOEXCEPT
{ return const_reverse_iterator(this->begin()); } { return const_reverse_iterator(this->begin()); }
//! <b>Precondition</b>: end_iterator must be a valid end iterator //! <b>Precondition</b>: end_iterator must be a valid end iterator
@ -501,7 +501,7 @@ class list_impl
//! <b>Throws</b>: Nothing. //! <b>Throws</b>: Nothing.
//! //!
//! <b>Complexity</b>: Constant. //! <b>Complexity</b>: Constant.
BOOST_INTRUSIVE_FORCEINLINE static list_impl &container_from_end_iterator(iterator end_iterator) BOOST_NOEXCEPT inline static list_impl &container_from_end_iterator(iterator end_iterator) BOOST_NOEXCEPT
{ return list_impl::priv_container_from_end_iterator(end_iterator); } { return list_impl::priv_container_from_end_iterator(end_iterator); }
//! <b>Precondition</b>: end_iterator must be a valid end const_iterator //! <b>Precondition</b>: end_iterator must be a valid end const_iterator
@ -512,7 +512,7 @@ class list_impl
//! <b>Throws</b>: Nothing. //! <b>Throws</b>: Nothing.
//! //!
//! <b>Complexity</b>: Constant. //! <b>Complexity</b>: Constant.
BOOST_INTRUSIVE_FORCEINLINE static const list_impl &container_from_end_iterator(const_iterator end_iterator) BOOST_NOEXCEPT inline static const list_impl &container_from_end_iterator(const_iterator end_iterator) BOOST_NOEXCEPT
{ return list_impl::priv_container_from_end_iterator(end_iterator); } { return list_impl::priv_container_from_end_iterator(end_iterator); }
//! <b>Effects</b>: Returns the number of the elements contained in the list. //! <b>Effects</b>: Returns the number of the elements contained in the list.
@ -523,7 +523,7 @@ class list_impl
//! if constant-time size option is disabled. Constant time otherwise. //! if constant-time size option is disabled. Constant time otherwise.
//! //!
//! <b>Note</b>: Does not affect the validity of iterators and references. //! <b>Note</b>: Does not affect the validity of iterators and references.
BOOST_INTRUSIVE_FORCEINLINE size_type size() const BOOST_NOEXCEPT inline size_type size() const BOOST_NOEXCEPT
{ {
BOOST_IF_CONSTEXPR(constant_time_size) BOOST_IF_CONSTEXPR(constant_time_size)
return this->priv_size_traits().get_size(); return this->priv_size_traits().get_size();
@ -538,7 +538,7 @@ class list_impl
//! <b>Complexity</b>: Constant. //! <b>Complexity</b>: Constant.
//! //!
//! <b>Note</b>: Does not affect the validity of iterators and references. //! <b>Note</b>: Does not affect the validity of iterators and references.
BOOST_INTRUSIVE_FORCEINLINE bool empty() const BOOST_NOEXCEPT inline bool empty() const BOOST_NOEXCEPT
{ return node_algorithms::unique(this->get_root_node()); } { return node_algorithms::unique(this->get_root_node()); }
//! <b>Effects</b>: Swaps the elements of x and *this. //! <b>Effects</b>: Swaps the elements of x and *this.
@ -563,7 +563,7 @@ class list_impl
//! <b>Complexity</b>: Linear to the number of shifts. //! <b>Complexity</b>: Linear to the number of shifts.
//! //!
//! <b>Note</b>: Does not affect the validity of iterators and references. //! <b>Note</b>: Does not affect the validity of iterators and references.
BOOST_INTRUSIVE_FORCEINLINE void shift_backwards(size_type n = 1) BOOST_NOEXCEPT inline void shift_backwards(size_type n = 1) BOOST_NOEXCEPT
{ node_algorithms::move_forward(this->get_root_node(), n); } { node_algorithms::move_forward(this->get_root_node(), n); }
//! <b>Effects</b>: Moves forward all the elements, so that the second //! <b>Effects</b>: Moves forward all the elements, so that the second
@ -575,7 +575,7 @@ class list_impl
//! <b>Complexity</b>: Linear to the number of shifts. //! <b>Complexity</b>: Linear to the number of shifts.
//! //!
//! <b>Note</b>: Does not affect the validity of iterators and references. //! <b>Note</b>: Does not affect the validity of iterators and references.
BOOST_INTRUSIVE_FORCEINLINE void shift_forward(size_type n = 1) BOOST_NOEXCEPT inline void shift_forward(size_type n = 1) BOOST_NOEXCEPT
{ node_algorithms::move_backwards(this->get_root_node(), n); } { node_algorithms::move_backwards(this->get_root_node(), n); }
//! <b>Effects</b>: Erases the element pointed by i of the list. //! <b>Effects</b>: Erases the element pointed by i of the list.
@ -590,7 +590,7 @@ class list_impl
//! //!
//! <b>Note</b>: Invalidates the iterators (but not the references) to the //! <b>Note</b>: Invalidates the iterators (but not the references) to the
//! erased element. //! erased element.
BOOST_INTRUSIVE_FORCEINLINE iterator erase(const_iterator i) BOOST_NOEXCEPT inline iterator erase(const_iterator i) BOOST_NOEXCEPT
{ return this->erase_and_dispose(i, detail::null_disposer()); } { return this->erase_and_dispose(i, detail::null_disposer()); }
//! <b>Requires</b>: b and e must be valid iterators to elements in *this. //! <b>Requires</b>: b and e must be valid iterators to elements in *this.
@ -608,7 +608,7 @@ class list_impl
//! //!
//! <b>Note</b>: Invalidates the iterators (but not the references) to the //! <b>Note</b>: Invalidates the iterators (but not the references) to the
//! erased elements. //! erased elements.
BOOST_INTRUSIVE_FORCEINLINE iterator erase(const_iterator b, const_iterator e) BOOST_NOEXCEPT inline iterator erase(const_iterator b, const_iterator e) BOOST_NOEXCEPT
{ {
BOOST_IF_CONSTEXPR(safemode_or_autounlink || constant_time_size){ BOOST_IF_CONSTEXPR(safemode_or_autounlink || constant_time_size){
return this->erase_and_dispose(b, e, detail::null_disposer()); return this->erase_and_dispose(b, e, detail::null_disposer());
@ -1371,22 +1371,22 @@ class list_impl
return ::boost::intrusive::algo_equal(x.cbegin(), x.cend(), y.cbegin(), y.cend()); return ::boost::intrusive::algo_equal(x.cbegin(), x.cend(), y.cbegin(), y.cend());
} }
BOOST_INTRUSIVE_FORCEINLINE friend bool operator!=(const list_impl &x, const list_impl &y) inline friend bool operator!=(const list_impl &x, const list_impl &y)
{ return !(x == y); } { return !(x == y); }
BOOST_INTRUSIVE_FORCEINLINE friend bool operator<(const list_impl &x, const list_impl &y) inline friend bool operator<(const list_impl &x, const list_impl &y)
{ return ::boost::intrusive::algo_lexicographical_compare(x.begin(), x.end(), y.begin(), y.end()); } { return ::boost::intrusive::algo_lexicographical_compare(x.begin(), x.end(), y.begin(), y.end()); }
BOOST_INTRUSIVE_FORCEINLINE friend bool operator>(const list_impl &x, const list_impl &y) inline friend bool operator>(const list_impl &x, const list_impl &y)
{ return y < x; } { return y < x; }
BOOST_INTRUSIVE_FORCEINLINE friend bool operator<=(const list_impl &x, const list_impl &y) inline friend bool operator<=(const list_impl &x, const list_impl &y)
{ return !(y < x); } { return !(y < x); }
BOOST_INTRUSIVE_FORCEINLINE friend bool operator>=(const list_impl &x, const list_impl &y) inline friend bool operator>=(const list_impl &x, const list_impl &y)
{ return !(x < y); } { return !(x < y); }
BOOST_INTRUSIVE_FORCEINLINE friend void swap(list_impl &x, list_impl &y) BOOST_NOEXCEPT inline friend void swap(list_impl &x, list_impl &y) BOOST_NOEXCEPT
{ x.swap(y); } { x.swap(y); }
/// @cond /// @cond
@ -1474,38 +1474,38 @@ class list
typedef typename Base::iterator iterator; typedef typename Base::iterator iterator;
typedef typename Base::const_iterator const_iterator; typedef typename Base::const_iterator const_iterator;
BOOST_INTRUSIVE_FORCEINLINE list() inline list()
: Base() : Base()
{} {}
BOOST_INTRUSIVE_FORCEINLINE explicit list(const value_traits &v_traits) inline explicit list(const value_traits &v_traits)
: Base(v_traits) : Base(v_traits)
{} {}
template<class Iterator> template<class Iterator>
BOOST_INTRUSIVE_FORCEINLINE list(Iterator b, Iterator e, const value_traits &v_traits = value_traits()) inline list(Iterator b, Iterator e, const value_traits &v_traits = value_traits())
: Base(b, e, v_traits) : Base(b, e, v_traits)
{} {}
BOOST_INTRUSIVE_FORCEINLINE list(BOOST_RV_REF(list) x) inline list(BOOST_RV_REF(list) x)
: Base(BOOST_MOVE_BASE(Base, x)) : Base(BOOST_MOVE_BASE(Base, x))
{} {}
BOOST_INTRUSIVE_FORCEINLINE list& operator=(BOOST_RV_REF(list) x) inline list& operator=(BOOST_RV_REF(list) x)
{ return static_cast<list &>(this->Base::operator=(BOOST_MOVE_BASE(Base, x))); } { return static_cast<list &>(this->Base::operator=(BOOST_MOVE_BASE(Base, x))); }
template <class Cloner, class Disposer> template <class Cloner, class Disposer>
BOOST_INTRUSIVE_FORCEINLINE void clone_from(const list &src, Cloner cloner, Disposer disposer) inline void clone_from(const list &src, Cloner cloner, Disposer disposer)
{ Base::clone_from(src, cloner, disposer); } { Base::clone_from(src, cloner, disposer); }
template <class Cloner, class Disposer> template <class Cloner, class Disposer>
BOOST_INTRUSIVE_FORCEINLINE void clone_from(BOOST_RV_REF(list) src, Cloner cloner, Disposer disposer) inline void clone_from(BOOST_RV_REF(list) src, Cloner cloner, Disposer disposer)
{ Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer); } { Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer); }
BOOST_INTRUSIVE_FORCEINLINE static list &container_from_end_iterator(iterator end_iterator) BOOST_NOEXCEPT inline static list &container_from_end_iterator(iterator end_iterator) BOOST_NOEXCEPT
{ return static_cast<list &>(Base::container_from_end_iterator(end_iterator)); } { return static_cast<list &>(Base::container_from_end_iterator(end_iterator)); }
BOOST_INTRUSIVE_FORCEINLINE static const list &container_from_end_iterator(const_iterator end_iterator) BOOST_NOEXCEPT inline static const list &container_from_end_iterator(const_iterator end_iterator) BOOST_NOEXCEPT
{ return static_cast<const list &>(Base::container_from_end_iterator(end_iterator)); } { return static_cast<const list &>(Base::container_from_end_iterator(end_iterator)); }
}; };

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

@ -130,7 +130,7 @@ struct pointer_traits
//! //!
//! <b>Note</b>: For non-conforming compilers only the existence of a member function called //! <b>Note</b>: For non-conforming compilers only the existence of a member function called
//! <code>pointer_to</code> is checked. //! <code>pointer_to</code> is checked.
BOOST_INTRUSIVE_FORCEINLINE static pointer pointer_to(reference r) BOOST_NOEXCEPT inline static pointer pointer_to(reference r) BOOST_NOEXCEPT
{ {
//Non-standard extension, it does not require Ptr::pointer_to. If not present //Non-standard extension, it does not require Ptr::pointer_to. If not present
//tries to converts &r to pointer. //tries to converts &r to pointer.
@ -150,7 +150,7 @@ struct pointer_traits
//! <b>Note</b>: For non-conforming compilers only the existence of a member function called //! <b>Note</b>: For non-conforming compilers only the existence of a member function called
//! <code>static_cast_from</code> is checked. //! <code>static_cast_from</code> is checked.
template<class UPtr> template<class UPtr>
BOOST_INTRUSIVE_FORCEINLINE static pointer static_cast_from(const UPtr &uptr) BOOST_NOEXCEPT inline static pointer static_cast_from(const UPtr &uptr) BOOST_NOEXCEPT
{ {
typedef const UPtr &RefArg; typedef const UPtr &RefArg;
const bool value = boost::intrusive::detail:: const bool value = boost::intrusive::detail::
@ -171,7 +171,7 @@ struct pointer_traits
//! <b>Note</b>: For non-conforming compilers only the existence of a member function called //! <b>Note</b>: For non-conforming compilers only the existence of a member function called
//! <code>const_cast_from</code> is checked. //! <code>const_cast_from</code> is checked.
template<class UPtr> template<class UPtr>
BOOST_INTRUSIVE_FORCEINLINE static pointer const_cast_from(const UPtr &uptr) BOOST_NOEXCEPT inline static pointer const_cast_from(const UPtr &uptr) BOOST_NOEXCEPT
{ {
typedef const UPtr &RefArg; typedef const UPtr &RefArg;
const bool value = boost::intrusive::detail:: const bool value = boost::intrusive::detail::
@ -192,7 +192,7 @@ struct pointer_traits
//! <b>Note</b>: For non-conforming compilers only the existence of a member function called //! <b>Note</b>: For non-conforming compilers only the existence of a member function called
//! <code>dynamic_cast_from</code> is checked. //! <code>dynamic_cast_from</code> is checked.
template<class UPtr> template<class UPtr>
BOOST_INTRUSIVE_FORCEINLINE static pointer dynamic_cast_from(const UPtr &uptr) BOOST_NOEXCEPT inline static pointer dynamic_cast_from(const UPtr &uptr) BOOST_NOEXCEPT
{ {
typedef const UPtr &RefArg; typedef const UPtr &RefArg;
const bool value = boost::intrusive::detail:: const bool value = boost::intrusive::detail::
@ -208,46 +208,46 @@ struct pointer_traits
private: private:
//priv_to_raw_pointer //priv_to_raw_pointer
template <class T> template <class T>
BOOST_INTRUSIVE_FORCEINLINE static T* to_raw_pointer(T* p) BOOST_NOEXCEPT inline static T* to_raw_pointer(T* p) BOOST_NOEXCEPT
{ return p; } { return p; }
template <class Pointer> template <class Pointer>
BOOST_INTRUSIVE_FORCEINLINE static typename pointer_traits<Pointer>::element_type* inline static typename pointer_traits<Pointer>::element_type*
to_raw_pointer(const Pointer &p) BOOST_NOEXCEPT to_raw_pointer(const Pointer &p) BOOST_NOEXCEPT
{ return pointer_traits::to_raw_pointer(p.operator->()); } { return pointer_traits::to_raw_pointer(p.operator->()); }
//priv_pointer_to //priv_pointer_to
BOOST_INTRUSIVE_FORCEINLINE static pointer priv_pointer_to(boost::intrusive::detail::true_, reference r) BOOST_NOEXCEPT inline static pointer priv_pointer_to(boost::intrusive::detail::true_, reference r) BOOST_NOEXCEPT
{ return Ptr::pointer_to(r); } { return Ptr::pointer_to(r); }
BOOST_INTRUSIVE_FORCEINLINE static pointer priv_pointer_to(boost::intrusive::detail::false_, reference r) BOOST_NOEXCEPT inline static pointer priv_pointer_to(boost::intrusive::detail::false_, reference r) BOOST_NOEXCEPT
{ return pointer(boost::intrusive::detail::addressof(r)); } { return pointer(boost::intrusive::detail::addressof(r)); }
//priv_static_cast_from //priv_static_cast_from
template<class UPtr> template<class UPtr>
BOOST_INTRUSIVE_FORCEINLINE static pointer priv_static_cast_from(boost::intrusive::detail::true_, const UPtr &uptr) BOOST_NOEXCEPT inline static pointer priv_static_cast_from(boost::intrusive::detail::true_, const UPtr &uptr) BOOST_NOEXCEPT
{ return Ptr::static_cast_from(uptr); } { return Ptr::static_cast_from(uptr); }
template<class UPtr> template<class UPtr>
BOOST_INTRUSIVE_FORCEINLINE static pointer priv_static_cast_from(boost::intrusive::detail::false_, const UPtr &uptr) BOOST_NOEXCEPT inline static pointer priv_static_cast_from(boost::intrusive::detail::false_, const UPtr &uptr) BOOST_NOEXCEPT
{ return uptr ? pointer_to(*static_cast<element_type*>(to_raw_pointer(uptr))) : pointer(); } { return uptr ? pointer_to(*static_cast<element_type*>(to_raw_pointer(uptr))) : pointer(); }
//priv_const_cast_from //priv_const_cast_from
template<class UPtr> template<class UPtr>
BOOST_INTRUSIVE_FORCEINLINE static pointer priv_const_cast_from(boost::intrusive::detail::true_, const UPtr &uptr) BOOST_NOEXCEPT inline static pointer priv_const_cast_from(boost::intrusive::detail::true_, const UPtr &uptr) BOOST_NOEXCEPT
{ return Ptr::const_cast_from(uptr); } { return Ptr::const_cast_from(uptr); }
template<class UPtr> template<class UPtr>
BOOST_INTRUSIVE_FORCEINLINE static pointer priv_const_cast_from(boost::intrusive::detail::false_, const UPtr &uptr) BOOST_NOEXCEPT inline static pointer priv_const_cast_from(boost::intrusive::detail::false_, const UPtr &uptr) BOOST_NOEXCEPT
{ return uptr ? pointer_to(const_cast<element_type&>(*uptr)) : pointer(); } { return uptr ? pointer_to(const_cast<element_type&>(*uptr)) : pointer(); }
//priv_dynamic_cast_from //priv_dynamic_cast_from
template<class UPtr> template<class UPtr>
BOOST_INTRUSIVE_FORCEINLINE static pointer priv_dynamic_cast_from(boost::intrusive::detail::true_, const UPtr &uptr) BOOST_NOEXCEPT inline static pointer priv_dynamic_cast_from(boost::intrusive::detail::true_, const UPtr &uptr) BOOST_NOEXCEPT
{ return Ptr::dynamic_cast_from(uptr); } { return Ptr::dynamic_cast_from(uptr); }
template<class UPtr> template<class UPtr>
BOOST_INTRUSIVE_FORCEINLINE static pointer priv_dynamic_cast_from(boost::intrusive::detail::false_, const UPtr &uptr) BOOST_NOEXCEPT inline static pointer priv_dynamic_cast_from(boost::intrusive::detail::false_, const UPtr &uptr) BOOST_NOEXCEPT
{ return uptr ? pointer_to(dynamic_cast<element_type&>(*uptr)) : pointer(); } { return uptr ? pointer_to(dynamic_cast<element_type&>(*uptr)) : pointer(); }
///@endcond ///@endcond
}; };
@ -296,25 +296,25 @@ struct pointer_traits<T*>
//! <b>Returns</b>: addressof(r) //! <b>Returns</b>: addressof(r)
//! //!
BOOST_INTRUSIVE_FORCEINLINE static pointer pointer_to(reference r) BOOST_NOEXCEPT inline static pointer pointer_to(reference r) BOOST_NOEXCEPT
{ return boost::intrusive::detail::addressof(r); } { return boost::intrusive::detail::addressof(r); }
//! <b>Returns</b>: static_cast<pointer>(uptr) //! <b>Returns</b>: static_cast<pointer>(uptr)
//! //!
template<class U> template<class U>
BOOST_INTRUSIVE_FORCEINLINE static pointer static_cast_from(U *uptr) BOOST_NOEXCEPT inline static pointer static_cast_from(U *uptr) BOOST_NOEXCEPT
{ return static_cast<pointer>(uptr); } { return static_cast<pointer>(uptr); }
//! <b>Returns</b>: const_cast<pointer>(uptr) //! <b>Returns</b>: const_cast<pointer>(uptr)
//! //!
template<class U> template<class U>
BOOST_INTRUSIVE_FORCEINLINE static pointer const_cast_from(U *uptr) BOOST_NOEXCEPT inline static pointer const_cast_from(U *uptr) BOOST_NOEXCEPT
{ return const_cast<pointer>(uptr); } { return const_cast<pointer>(uptr); }
//! <b>Returns</b>: dynamic_cast<pointer>(uptr) //! <b>Returns</b>: dynamic_cast<pointer>(uptr)
//! //!
template<class U> template<class U>
BOOST_INTRUSIVE_FORCEINLINE static pointer dynamic_cast_from(U *uptr) BOOST_NOEXCEPT inline static pointer dynamic_cast_from(U *uptr) BOOST_NOEXCEPT
{ return dynamic_cast<pointer>(uptr); } { return dynamic_cast<pointer>(uptr); }
}; };

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

@ -31,7 +31,7 @@ namespace intrusive {
namespace adldft { namespace adldft {
template<class T, class U> template<class T, class U>
BOOST_INTRUSIVE_FORCEINLINE bool priority_order(const T &t, const U &u) inline bool priority_order(const T &t, const U &u)
{ return t < u; } { return t < u; }
} //namespace adldft { } //namespace adldft {
@ -46,7 +46,7 @@ struct priority_compare
typedef T second_argument_type; typedef T second_argument_type;
typedef bool result_type; typedef bool result_type;
BOOST_INTRUSIVE_FORCEINLINE bool operator()(const T &val, const T &val2) const inline bool operator()(const T &val, const T &val2) const
{ {
using adldft::priority_order; using adldft::priority_order;
return priority_order(val, val2); return priority_order(val, val2);
@ -57,7 +57,7 @@ template <>
struct priority_compare<void> struct priority_compare<void>
{ {
template<class T, class U> template<class T, class U>
BOOST_INTRUSIVE_FORCEINLINE bool operator()(const T &t, const U &u) const inline bool operator()(const T &t, const U &u) const
{ {
using adldft::priority_order; using adldft::priority_order;
return priority_order(t, u); return priority_order(t, u);

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

@ -538,46 +538,46 @@ class rbtree
//Assert if passed value traits are compatible with the type //Assert if passed value traits are compatible with the type
BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value)); BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value));
BOOST_INTRUSIVE_FORCEINLINE rbtree() inline rbtree()
: Base() : Base()
{} {}
BOOST_INTRUSIVE_FORCEINLINE explicit rbtree( const key_compare &cmp, const value_traits &v_traits = value_traits()) inline explicit rbtree( const key_compare &cmp, const value_traits &v_traits = value_traits())
: Base(cmp, v_traits) : Base(cmp, v_traits)
{} {}
template<class Iterator> template<class Iterator>
BOOST_INTRUSIVE_FORCEINLINE rbtree( bool unique, Iterator b, Iterator e inline rbtree( bool unique, Iterator b, Iterator e
, const key_compare &cmp = key_compare() , const key_compare &cmp = key_compare()
, const value_traits &v_traits = value_traits()) , const value_traits &v_traits = value_traits())
: Base(unique, b, e, cmp, v_traits) : Base(unique, b, e, cmp, v_traits)
{} {}
BOOST_INTRUSIVE_FORCEINLINE rbtree(BOOST_RV_REF(rbtree) x) inline rbtree(BOOST_RV_REF(rbtree) x)
: Base(BOOST_MOVE_BASE(Base, x)) : Base(BOOST_MOVE_BASE(Base, x))
{} {}
BOOST_INTRUSIVE_FORCEINLINE rbtree& operator=(BOOST_RV_REF(rbtree) x) inline rbtree& operator=(BOOST_RV_REF(rbtree) x)
{ return static_cast<rbtree &>(this->Base::operator=(BOOST_MOVE_BASE(Base, x))); } { return static_cast<rbtree &>(this->Base::operator=(BOOST_MOVE_BASE(Base, x))); }
template <class Cloner, class Disposer> template <class Cloner, class Disposer>
BOOST_INTRUSIVE_FORCEINLINE void clone_from(const rbtree &src, Cloner cloner, Disposer disposer) inline void clone_from(const rbtree &src, Cloner cloner, Disposer disposer)
{ Base::clone_from(src, cloner, disposer); } { Base::clone_from(src, cloner, disposer); }
template <class Cloner, class Disposer> template <class Cloner, class Disposer>
BOOST_INTRUSIVE_FORCEINLINE void clone_from(BOOST_RV_REF(rbtree) src, Cloner cloner, Disposer disposer) inline void clone_from(BOOST_RV_REF(rbtree) src, Cloner cloner, Disposer disposer)
{ Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer); } { Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer); }
BOOST_INTRUSIVE_FORCEINLINE static rbtree &container_from_end_iterator(iterator end_iterator) BOOST_NOEXCEPT inline static rbtree &container_from_end_iterator(iterator end_iterator) BOOST_NOEXCEPT
{ return static_cast<rbtree &>(Base::container_from_end_iterator(end_iterator)); } { return static_cast<rbtree &>(Base::container_from_end_iterator(end_iterator)); }
BOOST_INTRUSIVE_FORCEINLINE static const rbtree &container_from_end_iterator(const_iterator end_iterator) BOOST_NOEXCEPT inline static const rbtree &container_from_end_iterator(const_iterator end_iterator) BOOST_NOEXCEPT
{ return static_cast<const rbtree &>(Base::container_from_end_iterator(end_iterator)); } { return static_cast<const rbtree &>(Base::container_from_end_iterator(end_iterator)); }
BOOST_INTRUSIVE_FORCEINLINE static rbtree &container_from_iterator(iterator it) BOOST_NOEXCEPT inline static rbtree &container_from_iterator(iterator it) BOOST_NOEXCEPT
{ return static_cast<rbtree &>(Base::container_from_iterator(it)); } { return static_cast<rbtree &>(Base::container_from_iterator(it)); }
BOOST_INTRUSIVE_FORCEINLINE static const rbtree &container_from_iterator(const_iterator it) BOOST_NOEXCEPT inline static const rbtree &container_from_iterator(const_iterator it) BOOST_NOEXCEPT
{ return static_cast<const rbtree &>(Base::container_from_iterator(it)); } { return static_cast<const rbtree &>(Base::container_from_iterator(it)); }
}; };

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

@ -525,46 +525,46 @@ class set
//Assert if passed value traits are compatible with the type //Assert if passed value traits are compatible with the type
BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value)); BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value));
BOOST_INTRUSIVE_FORCEINLINE set() inline set()
: Base() : Base()
{} {}
BOOST_INTRUSIVE_FORCEINLINE explicit set( const key_compare &cmp, const value_traits &v_traits = value_traits()) inline explicit set( const key_compare &cmp, const value_traits &v_traits = value_traits())
: Base(cmp, v_traits) : Base(cmp, v_traits)
{} {}
template<class Iterator> template<class Iterator>
BOOST_INTRUSIVE_FORCEINLINE set( Iterator b, Iterator e inline set( Iterator b, Iterator e
, const key_compare &cmp = key_compare() , const key_compare &cmp = key_compare()
, const value_traits &v_traits = value_traits()) , const value_traits &v_traits = value_traits())
: Base(b, e, cmp, v_traits) : Base(b, e, cmp, v_traits)
{} {}
BOOST_INTRUSIVE_FORCEINLINE set(BOOST_RV_REF(set) x) inline set(BOOST_RV_REF(set) x)
: Base(BOOST_MOVE_BASE(Base, x)) : Base(BOOST_MOVE_BASE(Base, x))
{} {}
BOOST_INTRUSIVE_FORCEINLINE set& operator=(BOOST_RV_REF(set) x) inline set& operator=(BOOST_RV_REF(set) x)
{ return static_cast<set &>(this->Base::operator=(BOOST_MOVE_BASE(Base, x))); } { return static_cast<set &>(this->Base::operator=(BOOST_MOVE_BASE(Base, x))); }
template <class Cloner, class Disposer> template <class Cloner, class Disposer>
BOOST_INTRUSIVE_FORCEINLINE void clone_from(const set &src, Cloner cloner, Disposer disposer) inline void clone_from(const set &src, Cloner cloner, Disposer disposer)
{ Base::clone_from(src, cloner, disposer); } { Base::clone_from(src, cloner, disposer); }
template <class Cloner, class Disposer> template <class Cloner, class Disposer>
BOOST_INTRUSIVE_FORCEINLINE void clone_from(BOOST_RV_REF(set) src, Cloner cloner, Disposer disposer) inline void clone_from(BOOST_RV_REF(set) src, Cloner cloner, Disposer disposer)
{ Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer); } { Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer); }
BOOST_INTRUSIVE_FORCEINLINE static set &container_from_end_iterator(iterator end_iterator) BOOST_NOEXCEPT inline static set &container_from_end_iterator(iterator end_iterator) BOOST_NOEXCEPT
{ return static_cast<set &>(Base::container_from_end_iterator(end_iterator)); } { return static_cast<set &>(Base::container_from_end_iterator(end_iterator)); }
BOOST_INTRUSIVE_FORCEINLINE static const set &container_from_end_iterator(const_iterator end_iterator) BOOST_NOEXCEPT inline static const set &container_from_end_iterator(const_iterator end_iterator) BOOST_NOEXCEPT
{ return static_cast<const set &>(Base::container_from_end_iterator(end_iterator)); } { return static_cast<const set &>(Base::container_from_end_iterator(end_iterator)); }
BOOST_INTRUSIVE_FORCEINLINE static set &container_from_iterator(iterator it) BOOST_NOEXCEPT inline static set &container_from_iterator(iterator it) BOOST_NOEXCEPT
{ return static_cast<set &>(Base::container_from_iterator(it)); } { return static_cast<set &>(Base::container_from_iterator(it)); }
BOOST_INTRUSIVE_FORCEINLINE static const set &container_from_iterator(const_iterator it) BOOST_NOEXCEPT inline static const set &container_from_iterator(const_iterator it) BOOST_NOEXCEPT
{ return static_cast<const set &>(Base::container_from_iterator(it)); } { return static_cast<const set &>(Base::container_from_iterator(it)); }
}; };
@ -1020,46 +1020,46 @@ class multiset
//Assert if passed value traits are compatible with the type //Assert if passed value traits are compatible with the type
BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value)); BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value));
BOOST_INTRUSIVE_FORCEINLINE multiset() inline multiset()
: Base() : Base()
{} {}
BOOST_INTRUSIVE_FORCEINLINE explicit multiset( const key_compare &cmp, const value_traits &v_traits = value_traits()) inline explicit multiset( const key_compare &cmp, const value_traits &v_traits = value_traits())
: Base(cmp, v_traits) : Base(cmp, v_traits)
{} {}
template<class Iterator> template<class Iterator>
BOOST_INTRUSIVE_FORCEINLINE multiset( Iterator b, Iterator e inline multiset( Iterator b, Iterator e
, const key_compare &cmp = key_compare() , const key_compare &cmp = key_compare()
, const value_traits &v_traits = value_traits()) , const value_traits &v_traits = value_traits())
: Base(b, e, cmp, v_traits) : Base(b, e, cmp, v_traits)
{} {}
BOOST_INTRUSIVE_FORCEINLINE multiset(BOOST_RV_REF(multiset) x) inline multiset(BOOST_RV_REF(multiset) x)
: Base(BOOST_MOVE_BASE(Base, x)) : Base(BOOST_MOVE_BASE(Base, x))
{} {}
BOOST_INTRUSIVE_FORCEINLINE multiset& operator=(BOOST_RV_REF(multiset) x) inline multiset& operator=(BOOST_RV_REF(multiset) x)
{ return static_cast<multiset &>(this->Base::operator=(BOOST_MOVE_BASE(Base, x))); } { return static_cast<multiset &>(this->Base::operator=(BOOST_MOVE_BASE(Base, x))); }
template <class Cloner, class Disposer> template <class Cloner, class Disposer>
BOOST_INTRUSIVE_FORCEINLINE void clone_from(const multiset &src, Cloner cloner, Disposer disposer) inline void clone_from(const multiset &src, Cloner cloner, Disposer disposer)
{ Base::clone_from(src, cloner, disposer); } { Base::clone_from(src, cloner, disposer); }
template <class Cloner, class Disposer> template <class Cloner, class Disposer>
BOOST_INTRUSIVE_FORCEINLINE void clone_from(BOOST_RV_REF(multiset) src, Cloner cloner, Disposer disposer) inline void clone_from(BOOST_RV_REF(multiset) src, Cloner cloner, Disposer disposer)
{ Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer); } { Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer); }
BOOST_INTRUSIVE_FORCEINLINE static multiset &container_from_end_iterator(iterator end_iterator) BOOST_NOEXCEPT inline static multiset &container_from_end_iterator(iterator end_iterator) BOOST_NOEXCEPT
{ return static_cast<multiset &>(Base::container_from_end_iterator(end_iterator)); } { return static_cast<multiset &>(Base::container_from_end_iterator(end_iterator)); }
BOOST_INTRUSIVE_FORCEINLINE static const multiset &container_from_end_iterator(const_iterator end_iterator) BOOST_NOEXCEPT inline static const multiset &container_from_end_iterator(const_iterator end_iterator) BOOST_NOEXCEPT
{ return static_cast<const multiset &>(Base::container_from_end_iterator(end_iterator)); } { return static_cast<const multiset &>(Base::container_from_end_iterator(end_iterator)); }
BOOST_INTRUSIVE_FORCEINLINE static multiset &container_from_iterator(iterator it) BOOST_NOEXCEPT inline static multiset &container_from_iterator(iterator it) BOOST_NOEXCEPT
{ return static_cast<multiset &>(Base::container_from_iterator(it)); } { return static_cast<multiset &>(Base::container_from_iterator(it)); }
BOOST_INTRUSIVE_FORCEINLINE static const multiset &container_from_iterator(const_iterator it) BOOST_NOEXCEPT inline static const multiset &container_from_iterator(const_iterator it) BOOST_NOEXCEPT
{ return static_cast<const multiset &>(Base::container_from_iterator(it)); } { return static_cast<const multiset &>(Base::container_from_iterator(it)); }
}; };

44
include/boost/intrusive/sg_set.hpp
View File

@ -534,46 +534,46 @@ class sg_set
//Assert if passed value traits are compatible with the type //Assert if passed value traits are compatible with the type
BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value)); BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value));
BOOST_INTRUSIVE_FORCEINLINE sg_set() inline sg_set()
: Base() : Base()
{} {}
BOOST_INTRUSIVE_FORCEINLINE explicit sg_set( const key_compare &cmp, const value_traits &v_traits = value_traits()) inline explicit sg_set( const key_compare &cmp, const value_traits &v_traits = value_traits())
: Base(cmp, v_traits) : Base(cmp, v_traits)
{} {}
template<class Iterator> template<class Iterator>
BOOST_INTRUSIVE_FORCEINLINE sg_set( Iterator b, Iterator e inline sg_set( Iterator b, Iterator e
, const key_compare &cmp = key_compare() , const key_compare &cmp = key_compare()
, const value_traits &v_traits = value_traits()) , const value_traits &v_traits = value_traits())
: Base(b, e, cmp, v_traits) : Base(b, e, cmp, v_traits)
{} {}
BOOST_INTRUSIVE_FORCEINLINE sg_set(BOOST_RV_REF(sg_set) x) inline sg_set(BOOST_RV_REF(sg_set) x)
: Base(BOOST_MOVE_BASE(Base, x)) : Base(BOOST_MOVE_BASE(Base, x))
{} {}
BOOST_INTRUSIVE_FORCEINLINE sg_set& operator=(BOOST_RV_REF(sg_set) x) inline sg_set& operator=(BOOST_RV_REF(sg_set) x)
{ return static_cast<sg_set &>(this->Base::operator=(BOOST_MOVE_BASE(Base, x))); } { return static_cast<sg_set &>(this->Base::operator=(BOOST_MOVE_BASE(Base, x))); }
template <class Cloner, class Disposer> template <class Cloner, class Disposer>
BOOST_INTRUSIVE_FORCEINLINE void clone_from(const sg_set &src, Cloner cloner, Disposer disposer) inline void clone_from(const sg_set &src, Cloner cloner, Disposer disposer)
{ Base::clone_from(src, cloner, disposer); } { Base::clone_from(src, cloner, disposer); }
template <class Cloner, class Disposer> template <class Cloner, class Disposer>
BOOST_INTRUSIVE_FORCEINLINE void clone_from(BOOST_RV_REF(sg_set) src, Cloner cloner, Disposer disposer) inline void clone_from(BOOST_RV_REF(sg_set) src, Cloner cloner, Disposer disposer)
{ Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer); } { Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer); }
BOOST_INTRUSIVE_FORCEINLINE static sg_set &container_from_end_iterator(iterator end_iterator) BOOST_NOEXCEPT inline static sg_set &container_from_end_iterator(iterator end_iterator) BOOST_NOEXCEPT
{ return static_cast<sg_set &>(Base::container_from_end_iterator(end_iterator)); } { return static_cast<sg_set &>(Base::container_from_end_iterator(end_iterator)); }
BOOST_INTRUSIVE_FORCEINLINE static const sg_set &container_from_end_iterator(const_iterator end_iterator) BOOST_NOEXCEPT inline static const sg_set &container_from_end_iterator(const_iterator end_iterator) BOOST_NOEXCEPT
{ return static_cast<const sg_set &>(Base::container_from_end_iterator(end_iterator)); } { return static_cast<const sg_set &>(Base::container_from_end_iterator(end_iterator)); }
BOOST_INTRUSIVE_FORCEINLINE static sg_set &container_from_iterator(iterator it) BOOST_NOEXCEPT inline static sg_set &container_from_iterator(iterator it) BOOST_NOEXCEPT
{ return static_cast<sg_set &>(Base::container_from_iterator(it)); } { return static_cast<sg_set &>(Base::container_from_iterator(it)); }
BOOST_INTRUSIVE_FORCEINLINE static const sg_set &container_from_iterator(const_iterator it) BOOST_NOEXCEPT inline static const sg_set &container_from_iterator(const_iterator it) BOOST_NOEXCEPT
{ return static_cast<const sg_set &>(Base::container_from_iterator(it)); } { return static_cast<const sg_set &>(Base::container_from_iterator(it)); }
}; };
@ -1041,46 +1041,46 @@ class sg_multiset
//Assert if passed value traits are compatible with the type //Assert if passed value traits are compatible with the type
BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value)); BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value));
BOOST_INTRUSIVE_FORCEINLINE sg_multiset() inline sg_multiset()
: Base() : Base()
{} {}
BOOST_INTRUSIVE_FORCEINLINE explicit sg_multiset( const key_compare &cmp, const value_traits &v_traits = value_traits()) inline explicit sg_multiset( const key_compare &cmp, const value_traits &v_traits = value_traits())
: Base(cmp, v_traits) : Base(cmp, v_traits)
{} {}
template<class Iterator> template<class Iterator>
BOOST_INTRUSIVE_FORCEINLINE sg_multiset( Iterator b, Iterator e inline sg_multiset( Iterator b, Iterator e
, const key_compare &cmp = key_compare() , const key_compare &cmp = key_compare()
, const value_traits &v_traits = value_traits()) , const value_traits &v_traits = value_traits())
: Base(b, e, cmp, v_traits) : Base(b, e, cmp, v_traits)
{} {}
BOOST_INTRUSIVE_FORCEINLINE sg_multiset(BOOST_RV_REF(sg_multiset) x) inline sg_multiset(BOOST_RV_REF(sg_multiset) x)
: Base(BOOST_MOVE_BASE(Base, x)) : Base(BOOST_MOVE_BASE(Base, x))
{} {}
BOOST_INTRUSIVE_FORCEINLINE sg_multiset& operator=(BOOST_RV_REF(sg_multiset) x) inline sg_multiset& operator=(BOOST_RV_REF(sg_multiset) x)
{ return static_cast<sg_multiset &>(this->Base::operator=(BOOST_MOVE_BASE(Base, x))); } { return static_cast<sg_multiset &>(this->Base::operator=(BOOST_MOVE_BASE(Base, x))); }
template <class Cloner, class Disposer> template <class Cloner, class Disposer>
BOOST_INTRUSIVE_FORCEINLINE void clone_from(const sg_multiset &src, Cloner cloner, Disposer disposer) inline void clone_from(const sg_multiset &src, Cloner cloner, Disposer disposer)
{ Base::clone_from(src, cloner, disposer); } { Base::clone_from(src, cloner, disposer); }
template <class Cloner, class Disposer> template <class Cloner, class Disposer>
BOOST_INTRUSIVE_FORCEINLINE void clone_from(BOOST_RV_REF(sg_multiset) src, Cloner cloner, Disposer disposer) inline void clone_from(BOOST_RV_REF(sg_multiset) src, Cloner cloner, Disposer disposer)
{ Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer); } { Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer); }
BOOST_INTRUSIVE_FORCEINLINE static sg_multiset &container_from_end_iterator(iterator end_iterator) BOOST_NOEXCEPT inline static sg_multiset &container_from_end_iterator(iterator end_iterator) BOOST_NOEXCEPT
{ return static_cast<sg_multiset &>(Base::container_from_end_iterator(end_iterator)); } { return static_cast<sg_multiset &>(Base::container_from_end_iterator(end_iterator)); }
BOOST_INTRUSIVE_FORCEINLINE static const sg_multiset &container_from_end_iterator(const_iterator end_iterator) BOOST_NOEXCEPT inline static const sg_multiset &container_from_end_iterator(const_iterator end_iterator) BOOST_NOEXCEPT
{ return static_cast<const sg_multiset &>(Base::container_from_end_iterator(end_iterator)); } { return static_cast<const sg_multiset &>(Base::container_from_end_iterator(end_iterator)); }
BOOST_INTRUSIVE_FORCEINLINE static sg_multiset &container_from_iterator(iterator it) BOOST_NOEXCEPT inline static sg_multiset &container_from_iterator(iterator it) BOOST_NOEXCEPT
{ return static_cast<sg_multiset &>(Base::container_from_iterator(it)); } { return static_cast<sg_multiset &>(Base::container_from_iterator(it)); }
BOOST_INTRUSIVE_FORCEINLINE static const sg_multiset &container_from_iterator(const_iterator it) BOOST_NOEXCEPT inline static const sg_multiset &container_from_iterator(const_iterator it) BOOST_NOEXCEPT
{ return static_cast<const sg_multiset &>(Base::container_from_iterator(it)); } { return static_cast<const sg_multiset &>(Base::container_from_iterator(it)); }
}; };

22
include/boost/intrusive/sgtree.hpp
View File

@ -1020,46 +1020,46 @@ class sgtree
//Assert if passed value traits are compatible with the type //Assert if passed value traits are compatible with the type
BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value)); BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value));
BOOST_INTRUSIVE_FORCEINLINE sgtree() inline sgtree()
: Base() : Base()
{} {}
BOOST_INTRUSIVE_FORCEINLINE explicit sgtree(const key_compare &cmp, const value_traits &v_traits = value_traits()) inline explicit sgtree(const key_compare &cmp, const value_traits &v_traits = value_traits())
: Base(cmp, v_traits) : Base(cmp, v_traits)
{} {}
template<class Iterator> template<class Iterator>
BOOST_INTRUSIVE_FORCEINLINE sgtree( bool unique, Iterator b, Iterator e inline sgtree( bool unique, Iterator b, Iterator e
, const key_compare &cmp = key_compare() , const key_compare &cmp = key_compare()
, const value_traits &v_traits = value_traits()) , const value_traits &v_traits = value_traits())
: Base(unique, b, e, cmp, v_traits) : Base(unique, b, e, cmp, v_traits)
{} {}
BOOST_INTRUSIVE_FORCEINLINE sgtree(BOOST_RV_REF(sgtree) x) inline sgtree(BOOST_RV_REF(sgtree) x)
: Base(BOOST_MOVE_BASE(Base, x)) : Base(BOOST_MOVE_BASE(Base, x))
{} {}
BOOST_INTRUSIVE_FORCEINLINE sgtree& operator=(BOOST_RV_REF(sgtree) x) inline sgtree& operator=(BOOST_RV_REF(sgtree) x)
{ return static_cast<sgtree &>(this->Base::operator=(BOOST_MOVE_BASE(Base, x))); } { return static_cast<sgtree &>(this->Base::operator=(BOOST_MOVE_BASE(Base, x))); }
template <class Cloner, class Disposer> template <class Cloner, class Disposer>
BOOST_INTRUSIVE_FORCEINLINE void clone_from(const sgtree &src, Cloner cloner, Disposer disposer) inline void clone_from(const sgtree &src, Cloner cloner, Disposer disposer)
{ Base::clone_from(src, cloner, disposer); } { Base::clone_from(src, cloner, disposer); }
template <class Cloner, class Disposer> template <class Cloner, class Disposer>
BOOST_INTRUSIVE_FORCEINLINE void clone_from(BOOST_RV_REF(sgtree) src, Cloner cloner, Disposer disposer) inline void clone_from(BOOST_RV_REF(sgtree) src, Cloner cloner, Disposer disposer)
{ Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer); } { Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer); }
BOOST_INTRUSIVE_FORCEINLINE static sgtree &container_from_end_iterator(iterator end_iterator) BOOST_NOEXCEPT inline static sgtree &container_from_end_iterator(iterator end_iterator) BOOST_NOEXCEPT
{ return static_cast<sgtree &>(Base::container_from_end_iterator(end_iterator)); } { return static_cast<sgtree &>(Base::container_from_end_iterator(end_iterator)); }
BOOST_INTRUSIVE_FORCEINLINE static const sgtree &container_from_end_iterator(const_iterator end_iterator) BOOST_NOEXCEPT inline static const sgtree &container_from_end_iterator(const_iterator end_iterator) BOOST_NOEXCEPT
{ return static_cast<const sgtree &>(Base::container_from_end_iterator(end_iterator)); } { return static_cast<const sgtree &>(Base::container_from_end_iterator(end_iterator)); }
BOOST_INTRUSIVE_FORCEINLINE static sgtree &container_from_iterator(iterator it) BOOST_NOEXCEPT inline static sgtree &container_from_iterator(iterator it) BOOST_NOEXCEPT
{ return static_cast<sgtree &>(Base::container_from_iterator(it)); } { return static_cast<sgtree &>(Base::container_from_iterator(it)); }
BOOST_INTRUSIVE_FORCEINLINE static const sgtree &container_from_iterator(const_iterator it) BOOST_NOEXCEPT inline static const sgtree &container_from_iterator(const_iterator it) BOOST_NOEXCEPT
{ return static_cast<const sgtree &>(Base::container_from_iterator(it)); } { return static_cast<const sgtree &>(Base::container_from_iterator(it)); }
}; };

2
include/boost/intrusive/sgtree_algorithms.hpp
View File

@ -287,7 +287,7 @@ class sgtree_algorithms
//! @copydoc ::boost::intrusive::bstree_algorithms::insert_unique_commit(node_ptr,node_ptr,const insert_commit_data&) //! @copydoc ::boost::intrusive::bstree_algorithms::insert_unique_commit(node_ptr,node_ptr,const insert_commit_data&)
template<class H_Alpha> template<class H_Alpha>
BOOST_INTRUSIVE_FORCEINLINE static void insert_unique_commit inline static void insert_unique_commit
(node_ptr header, node_ptr new_value, const insert_commit_data &commit_data (node_ptr header, node_ptr new_value, const insert_commit_data &commit_data
,std::size_t tree_size, H_Alpha h_alpha, std::size_t &max_tree_size) ,std::size_t tree_size, H_Alpha h_alpha, std::size_t &max_tree_size)
{ return insert_commit(header, new_value, commit_data, tree_size, h_alpha, max_tree_size); } { return insert_commit(header, new_value, commit_data, tree_size, h_alpha, max_tree_size); }

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

@ -172,47 +172,47 @@ class slist_impl
//A list with cached last node is incompatible with auto-unlink hooks! //A list with cached last node is incompatible with auto-unlink hooks!
BOOST_STATIC_ASSERT(!(cache_last && ((int)value_traits::link_mode == (int)auto_unlink))); BOOST_STATIC_ASSERT(!(cache_last && ((int)value_traits::link_mode == (int)auto_unlink)));
BOOST_INTRUSIVE_FORCEINLINE node_ptr get_end_node() inline node_ptr get_end_node()
{ return node_algorithms::end_node(this->get_root_node()); } { return node_algorithms::end_node(this->get_root_node()); }
BOOST_INTRUSIVE_FORCEINLINE const_node_ptr get_end_node() const inline const_node_ptr get_end_node() const
{ return node_algorithms::end_node(this->get_root_node()); } { return node_algorithms::end_node(this->get_root_node()); }
BOOST_INTRUSIVE_FORCEINLINE node_ptr get_root_node() inline node_ptr get_root_node()
{ return data_.root_plus_size_.header_holder_.get_node(); } { return data_.root_plus_size_.header_holder_.get_node(); }
BOOST_INTRUSIVE_FORCEINLINE const_node_ptr get_root_node() const inline const_node_ptr get_root_node() const
{ return data_.root_plus_size_.header_holder_.get_node(); } { return data_.root_plus_size_.header_holder_.get_node(); }
BOOST_INTRUSIVE_FORCEINLINE node_ptr get_last_node() inline node_ptr get_last_node()
{ return this->get_last_node(detail::bool_<cache_last>()); } { return this->get_last_node(detail::bool_<cache_last>()); }
BOOST_INTRUSIVE_FORCEINLINE const_node_ptr get_last_node() const inline const_node_ptr get_last_node() const
{ return this->get_last_node(detail::bool_<cache_last>()); } { return this->get_last_node(detail::bool_<cache_last>()); }
BOOST_INTRUSIVE_FORCEINLINE void set_last_node(node_ptr n) inline void set_last_node(node_ptr n)
{ return this->set_last_node(n, detail::bool_<cache_last>()); } { return this->set_last_node(n, detail::bool_<cache_last>()); }
BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_last_node(detail::bool_<false>) inline static node_ptr get_last_node(detail::bool_<false>)
{ {
//This function shall not be used if cache_last is not true //This function shall not be used if cache_last is not true
BOOST_INTRUSIVE_INVARIANT_ASSERT(cache_last); BOOST_INTRUSIVE_INVARIANT_ASSERT(cache_last);
return node_ptr(); return node_ptr();
} }
BOOST_INTRUSIVE_FORCEINLINE static void set_last_node(node_ptr , detail::bool_<false>) inline static void set_last_node(node_ptr , detail::bool_<false>)
{ {
//This function shall not be used if cache_last is not true //This function shall not be used if cache_last is not true
BOOST_INTRUSIVE_INVARIANT_ASSERT(cache_last); BOOST_INTRUSIVE_INVARIANT_ASSERT(cache_last);
} }
BOOST_INTRUSIVE_FORCEINLINE node_ptr get_last_node(detail::bool_<true>) inline node_ptr get_last_node(detail::bool_<true>)
{ return node_ptr(data_.root_plus_size_.last_); } { return node_ptr(data_.root_plus_size_.last_); }
BOOST_INTRUSIVE_FORCEINLINE const_node_ptr get_last_node(detail::bool_<true>) const inline const_node_ptr get_last_node(detail::bool_<true>) const
{ return const_node_ptr(data_.root_plus_size_.last_); } { return const_node_ptr(data_.root_plus_size_.last_); }
BOOST_INTRUSIVE_FORCEINLINE void set_last_node(node_ptr n, detail::bool_<true>) inline void set_last_node(node_ptr n, detail::bool_<true>)
{ data_.root_plus_size_.last_ = n; } { data_.root_plus_size_.last_ = n; }
void set_default_constructed_state() void set_default_constructed_state()
@ -241,22 +241,22 @@ class slist_impl
root_plus_size root_plus_size_; root_plus_size root_plus_size_;
} data_; } data_;
BOOST_INTRUSIVE_FORCEINLINE size_traits &priv_size_traits() inline size_traits &priv_size_traits()
{ return data_.root_plus_size_; } { return data_.root_plus_size_; }
BOOST_INTRUSIVE_FORCEINLINE const size_traits &priv_size_traits() const inline const size_traits &priv_size_traits() const
{ return data_.root_plus_size_; } { return data_.root_plus_size_; }
BOOST_INTRUSIVE_FORCEINLINE const value_traits &priv_value_traits() const inline const value_traits &priv_value_traits() const
{ return data_; } { return data_; }
BOOST_INTRUSIVE_FORCEINLINE value_traits &priv_value_traits() inline value_traits &priv_value_traits()
{ return data_; } { return data_; }
typedef typename boost::intrusive::value_traits_pointers typedef typename boost::intrusive::value_traits_pointers
<ValueTraits>::const_value_traits_ptr const_value_traits_ptr; <ValueTraits>::const_value_traits_ptr const_value_traits_ptr;
BOOST_INTRUSIVE_FORCEINLINE const_value_traits_ptr priv_value_traits_ptr() const inline const_value_traits_ptr priv_value_traits_ptr() const
{ return pointer_traits<const_value_traits_ptr>::pointer_to(this->priv_value_traits()); } { return pointer_traits<const_value_traits_ptr>::pointer_to(this->priv_value_traits()); }
/// @endcond /// @endcond
@ -501,7 +501,7 @@ class slist_impl
//! <b>Throws</b>: Nothing. //! <b>Throws</b>: Nothing.
//! //!
//! <b>Complexity</b>: Constant. //! <b>Complexity</b>: Constant.
BOOST_INTRUSIVE_FORCEINLINE reference front() BOOST_NOEXCEPT inline reference front() BOOST_NOEXCEPT
{ return *this->priv_value_traits().to_value_ptr(node_traits::get_next(this->get_root_node())); } { return *this->priv_value_traits().to_value_ptr(node_traits::get_next(this->get_root_node())); }
//! <b>Effects</b>: Returns a const_reference to the first element of the list. //! <b>Effects</b>: Returns a const_reference to the first element of the list.
@ -509,7 +509,7 @@ class slist_impl
//! <b>Throws</b>: Nothing. //! <b>Throws</b>: Nothing.
//! //!
//! <b>Complexity</b>: Constant. //! <b>Complexity</b>: Constant.
BOOST_INTRUSIVE_FORCEINLINE const_reference front() const BOOST_NOEXCEPT inline const_reference front() const BOOST_NOEXCEPT
{ return *this->priv_value_traits().to_value_ptr(detail::uncast(node_traits::get_next(this->get_root_node()))); } { return *this->priv_value_traits().to_value_ptr(detail::uncast(node_traits::get_next(this->get_root_node()))); }
//! <b>Effects</b>: Returns a reference to the last element of the list. //! <b>Effects</b>: Returns a reference to the last element of the list.
@ -534,7 +534,7 @@ class slist_impl
//! //!
//! <b>Note</b>: Does not affect the validity of iterators and references. //! <b>Note</b>: Does not affect the validity of iterators and references.
//! This function is only available is cache_last<> is true. //! This function is only available is cache_last<> is true.
BOOST_INTRUSIVE_FORCEINLINE const_reference back() const BOOST_NOEXCEPT inline const_reference back() const BOOST_NOEXCEPT
{ {
BOOST_STATIC_ASSERT((cache_last)); BOOST_STATIC_ASSERT((cache_last));
return *this->priv_value_traits().to_value_ptr(this->get_last_node()); return *this->priv_value_traits().to_value_ptr(this->get_last_node());
@ -545,7 +545,7 @@ class slist_impl
//! <b>Throws</b>: Nothing. //! <b>Throws</b>: Nothing.
//! //!
//! <b>Complexity</b>: Constant. //! <b>Complexity</b>: Constant.
BOOST_INTRUSIVE_FORCEINLINE iterator begin() BOOST_NOEXCEPT inline iterator begin() BOOST_NOEXCEPT
{ return iterator (node_traits::get_next(this->get_root_node()), this->priv_value_traits_ptr()); } { return iterator (node_traits::get_next(this->get_root_node()), this->priv_value_traits_ptr()); }
//! <b>Effects</b>: Returns a const_iterator to the first element contained in the list. //! <b>Effects</b>: Returns a const_iterator to the first element contained in the list.
@ -553,7 +553,7 @@ class slist_impl
//! <b>Throws</b>: Nothing. //! <b>Throws</b>: Nothing.
//! //!
//! <b>Complexity</b>: Constant. //! <b>Complexity</b>: Constant.
BOOST_INTRUSIVE_FORCEINLINE const_iterator begin() const BOOST_NOEXCEPT inline const_iterator begin() const BOOST_NOEXCEPT
{ return const_iterator (node_traits::get_next(this->get_root_node()), this->priv_value_traits_ptr()); } { return const_iterator (node_traits::get_next(this->get_root_node()), this->priv_value_traits_ptr()); }
//! <b>Effects</b>: Returns a const_iterator to the first element contained in the list. //! <b>Effects</b>: Returns a const_iterator to the first element contained in the list.
@ -561,7 +561,7 @@ class slist_impl
//! <b>Throws</b>: Nothing. //! <b>Throws</b>: Nothing.
//! //!
//! <b>Complexity</b>: Constant. //! <b>Complexity</b>: Constant.
BOOST_INTRUSIVE_FORCEINLINE const_iterator cbegin() const BOOST_NOEXCEPT inline const_iterator cbegin() const BOOST_NOEXCEPT
{ return const_iterator(node_traits::get_next(this->get_root_node()), this->priv_value_traits_ptr()); } { return const_iterator(node_traits::get_next(this->get_root_node()), this->priv_value_traits_ptr()); }
//! <b>Effects</b>: Returns an iterator to the end of the list. //! <b>Effects</b>: Returns an iterator to the end of the list.
@ -569,7 +569,7 @@ class slist_impl
//! <b>Throws</b>: Nothing. //! <b>Throws</b>: Nothing.
//! //!
//! <b>Complexity</b>: Constant. //! <b>Complexity</b>: Constant.
BOOST_INTRUSIVE_FORCEINLINE iterator end() BOOST_NOEXCEPT inline iterator end() BOOST_NOEXCEPT
{ return iterator(this->get_end_node(), this->priv_value_traits_ptr()); } { return iterator(this->get_end_node(), this->priv_value_traits_ptr()); }
//! <b>Effects</b>: Returns a const_iterator to the end of the list. //! <b>Effects</b>: Returns a const_iterator to the end of the list.
@ -577,7 +577,7 @@ class slist_impl
//! <b>Throws</b>: Nothing. //! <b>Throws</b>: Nothing.
//! //!
//! <b>Complexity</b>: Constant. //! <b>Complexity</b>: Constant.
BOOST_INTRUSIVE_FORCEINLINE const_iterator end() const BOOST_NOEXCEPT inline const_iterator end() const BOOST_NOEXCEPT
{ return const_iterator(detail::uncast(this->get_end_node()), this->priv_value_traits_ptr()); } { return const_iterator(detail::uncast(this->get_end_node()), this->priv_value_traits_ptr()); }
//! <b>Effects</b>: Returns a const_iterator to the end of the list. //! <b>Effects</b>: Returns a const_iterator to the end of the list.
@ -585,7 +585,7 @@ class slist_impl
//! <b>Throws</b>: Nothing. //! <b>Throws</b>: Nothing.
//! //!
//! <b>Complexity</b>: Constant. //! <b>Complexity</b>: Constant.
BOOST_INTRUSIVE_FORCEINLINE const_iterator cend() const BOOST_NOEXCEPT inline const_iterator cend() const BOOST_NOEXCEPT
{ return this->end(); } { return this->end(); }
//! <b>Effects</b>: Returns an iterator that points to a position //! <b>Effects</b>: Returns an iterator that points to a position
@ -594,7 +594,7 @@ class slist_impl
//! <b>Throws</b>: Nothing. //! <b>Throws</b>: Nothing.
//! //!
//! <b>Complexity</b>: Constant. //! <b>Complexity</b>: Constant.
BOOST_INTRUSIVE_FORCEINLINE iterator before_begin() BOOST_NOEXCEPT inline iterator before_begin() BOOST_NOEXCEPT
{ return iterator(this->get_root_node(), this->priv_value_traits_ptr()); } { return iterator(this->get_root_node(), this->priv_value_traits_ptr()); }
//! <b>Effects</b>: Returns an iterator that points to a position //! <b>Effects</b>: Returns an iterator that points to a position
@ -603,7 +603,7 @@ class slist_impl
//! <b>Throws</b>: Nothing. //! <b>Throws</b>: Nothing.
//! //!
//! <b>Complexity</b>: Constant. //! <b>Complexity</b>: Constant.
BOOST_INTRUSIVE_FORCEINLINE const_iterator before_begin() const BOOST_NOEXCEPT inline const_iterator before_begin() const BOOST_NOEXCEPT
{ return const_iterator(detail::uncast(this->get_root_node()), this->priv_value_traits_ptr()); } { return const_iterator(detail::uncast(this->get_root_node()), this->priv_value_traits_ptr()); }
//! <b>Effects</b>: Returns an iterator that points to a position //! <b>Effects</b>: Returns an iterator that points to a position
@ -612,7 +612,7 @@ class slist_impl
//! <b>Throws</b>: Nothing. //! <b>Throws</b>: Nothing.
//! //!
//! <b>Complexity</b>: Constant. //! <b>Complexity</b>: Constant.
BOOST_INTRUSIVE_FORCEINLINE const_iterator cbefore_begin() const BOOST_NOEXCEPT inline const_iterator cbefore_begin() const BOOST_NOEXCEPT
{ return this->before_begin(); } { return this->before_begin(); }
//! <b>Effects</b>: Returns an iterator to the last element contained in the list. //! <b>Effects</b>: Returns an iterator to the last element contained in the list.
@ -622,7 +622,7 @@ class slist_impl
//! <b>Complexity</b>: Constant. //! <b>Complexity</b>: Constant.
//! //!
//! <b>Note</b>: This function is present only if cached_last<> option is true. //! <b>Note</b>: This function is present only if cached_last<> option is true.
BOOST_INTRUSIVE_FORCEINLINE iterator last() BOOST_NOEXCEPT inline iterator last() BOOST_NOEXCEPT
{ {
//This function shall not be used if cache_last is not true //This function shall not be used if cache_last is not true
BOOST_INTRUSIVE_INVARIANT_ASSERT(cache_last); BOOST_INTRUSIVE_INVARIANT_ASSERT(cache_last);
@ -636,7 +636,7 @@ class slist_impl
//! <b>Complexity</b>: Constant. //! <b>Complexity</b>: Constant.
//! //!
//! <b>Note</b>: This function is present only if cached_last<> option is true. //! <b>Note</b>: This function is present only if cached_last<> option is true.
BOOST_INTRUSIVE_FORCEINLINE const_iterator last() const BOOST_NOEXCEPT inline const_iterator last() const BOOST_NOEXCEPT
{ {
//This function shall not be used if cache_last is not true //This function shall not be used if cache_last is not true
BOOST_INTRUSIVE_INVARIANT_ASSERT(cache_last); BOOST_INTRUSIVE_INVARIANT_ASSERT(cache_last);
@ -650,7 +650,7 @@ class slist_impl
//! <b>Complexity</b>: Constant. //! <b>Complexity</b>: Constant.
//! //!
//! <b>Note</b>: This function is present only if cached_last<> option is true. //! <b>Note</b>: This function is present only if cached_last<> option is true.
BOOST_INTRUSIVE_FORCEINLINE const_iterator clast() const BOOST_NOEXCEPT inline const_iterator clast() const BOOST_NOEXCEPT
{ return const_iterator(this->get_last_node(), this->priv_value_traits_ptr()); } { return const_iterator(this->get_last_node(), this->priv_value_traits_ptr()); }
//! <b>Precondition</b>: end_iterator must be a valid end iterator //! <b>Precondition</b>: end_iterator must be a valid end iterator
@ -661,7 +661,7 @@ class slist_impl
//! <b>Throws</b>: Nothing. //! <b>Throws</b>: Nothing.
//! //!
//! <b>Complexity</b>: Constant. //! <b>Complexity</b>: Constant.
BOOST_INTRUSIVE_FORCEINLINE static slist_impl &container_from_end_iterator(iterator end_iterator) BOOST_NOEXCEPT inline static slist_impl &container_from_end_iterator(iterator end_iterator) BOOST_NOEXCEPT
{ return slist_impl::priv_container_from_end_iterator(end_iterator); } { return slist_impl::priv_container_from_end_iterator(end_iterator); }
//! <b>Precondition</b>: end_iterator must be a valid end const_iterator //! <b>Precondition</b>: end_iterator must be a valid end const_iterator
@ -672,7 +672,7 @@ class slist_impl
//! <b>Throws</b>: Nothing. //! <b>Throws</b>: Nothing.
//! //!
//! <b>Complexity</b>: Constant. //! <b>Complexity</b>: Constant.
BOOST_INTRUSIVE_FORCEINLINE static const slist_impl &container_from_end_iterator(const_iterator end_iterator) BOOST_NOEXCEPT inline static const slist_impl &container_from_end_iterator(const_iterator end_iterator) BOOST_NOEXCEPT
{ return slist_impl::priv_container_from_end_iterator(end_iterator); } { return slist_impl::priv_container_from_end_iterator(end_iterator); }
//! <b>Effects</b>: Returns the number of the elements contained in the list. //! <b>Effects</b>: Returns the number of the elements contained in the list.
@ -683,7 +683,7 @@ class slist_impl
//! if constant_time_size is false. Constant time otherwise. //! if constant_time_size is false. Constant time otherwise.
//! //!
//! <b>Note</b>: Does not affect the validity of iterators and references. //! <b>Note</b>: Does not affect the validity of iterators and references.
BOOST_INTRUSIVE_FORCEINLINE size_type size() const BOOST_NOEXCEPT inline size_type size() const BOOST_NOEXCEPT
{ {
BOOST_IF_CONSTEXPR(constant_time_size) BOOST_IF_CONSTEXPR(constant_time_size)
return this->priv_size_traits().get_size(); return this->priv_size_traits().get_size();
@ -698,7 +698,7 @@ class slist_impl
//! <b>Complexity</b>: Constant. //! <b>Complexity</b>: Constant.
//! //!
//! <b>Note</b>: Does not affect the validity of iterators and references. //! <b>Note</b>: Does not affect the validity of iterators and references.
BOOST_INTRUSIVE_FORCEINLINE bool empty() const BOOST_NOEXCEPT inline bool empty() const BOOST_NOEXCEPT
{ return node_algorithms::is_empty(this->get_root_node()); } { return node_algorithms::is_empty(this->get_root_node()); }
//! <b>Effects</b>: Swaps the elements of x and *this. //! <b>Effects</b>: Swaps the elements of x and *this.
@ -2195,45 +2195,45 @@ class slist
typedef typename Base::size_type size_type; typedef typename Base::size_type size_type;
typedef typename Base::node_ptr node_ptr; typedef typename Base::node_ptr node_ptr;
BOOST_INTRUSIVE_FORCEINLINE slist() inline slist()
: Base() : Base()
{} {}
BOOST_INTRUSIVE_FORCEINLINE explicit slist(const value_traits &v_traits) inline explicit slist(const value_traits &v_traits)
: Base(v_traits) : Base(v_traits)
{} {}
struct incorporate_t{}; struct incorporate_t{};
BOOST_INTRUSIVE_FORCEINLINE slist( node_ptr f, node_ptr before_l inline slist( node_ptr f, node_ptr before_l
, size_type n, const value_traits &v_traits = value_traits()) , size_type n, const value_traits &v_traits = value_traits())
: Base(f, before_l, n, v_traits) : Base(f, before_l, n, v_traits)
{} {}
template<class Iterator> template<class Iterator>
BOOST_INTRUSIVE_FORCEINLINE slist(Iterator b, Iterator e, const value_traits &v_traits = value_traits()) inline slist(Iterator b, Iterator e, const value_traits &v_traits = value_traits())
: Base(b, e, v_traits) : Base(b, e, v_traits)
{} {}
BOOST_INTRUSIVE_FORCEINLINE slist(BOOST_RV_REF(slist) x) inline slist(BOOST_RV_REF(slist) x)
: Base(BOOST_MOVE_BASE(Base, x)) : Base(BOOST_MOVE_BASE(Base, x))
{} {}
BOOST_INTRUSIVE_FORCEINLINE slist& operator=(BOOST_RV_REF(slist) x) inline slist& operator=(BOOST_RV_REF(slist) x)
{ return static_cast<slist &>(this->Base::operator=(BOOST_MOVE_BASE(Base, x))); } { return static_cast<slist &>(this->Base::operator=(BOOST_MOVE_BASE(Base, x))); }
template <class Cloner, class Disposer> template <class Cloner, class Disposer>
BOOST_INTRUSIVE_FORCEINLINE void clone_from(const slist &src, Cloner cloner, Disposer disposer) inline void clone_from(const slist &src, Cloner cloner, Disposer disposer)
{ Base::clone_from(src, cloner, disposer); } { Base::clone_from(src, cloner, disposer); }
template <class Cloner, class Disposer> template <class Cloner, class Disposer>
BOOST_INTRUSIVE_FORCEINLINE void clone_from(BOOST_RV_REF(slist) src, Cloner cloner, Disposer disposer) inline void clone_from(BOOST_RV_REF(slist) src, Cloner cloner, Disposer disposer)
{ Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer); } { Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer); }
BOOST_INTRUSIVE_FORCEINLINE static slist &container_from_end_iterator(iterator end_iterator) BOOST_NOEXCEPT inline static slist &container_from_end_iterator(iterator end_iterator) BOOST_NOEXCEPT
{ return static_cast<slist &>(Base::container_from_end_iterator(end_iterator)); } { return static_cast<slist &>(Base::container_from_end_iterator(end_iterator)); }
BOOST_INTRUSIVE_FORCEINLINE static const slist &container_from_end_iterator(const_iterator end_iterator) BOOST_NOEXCEPT inline static const slist &container_from_end_iterator(const_iterator end_iterator) BOOST_NOEXCEPT
{ return static_cast<const slist &>(Base::container_from_end_iterator(end_iterator)); } { return static_cast<const slist &>(Base::container_from_end_iterator(end_iterator)); }
}; };

44
include/boost/intrusive/splay_set.hpp
View File

@ -546,46 +546,46 @@ class splay_set
//Assert if passed value traits are compatible with the type //Assert if passed value traits are compatible with the type
BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value)); BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value));
BOOST_INTRUSIVE_FORCEINLINE splay_set() inline splay_set()
: Base() : Base()
{} {}
BOOST_INTRUSIVE_FORCEINLINE explicit splay_set( const key_compare &cmp, const value_traits &v_traits = value_traits()) inline explicit splay_set( const key_compare &cmp, const value_traits &v_traits = value_traits())
: Base(cmp, v_traits) : Base(cmp, v_traits)
{} {}
template<class Iterator> template<class Iterator>
BOOST_INTRUSIVE_FORCEINLINE splay_set( Iterator b, Iterator e inline splay_set( Iterator b, Iterator e
, const key_compare &cmp = key_compare() , const key_compare &cmp = key_compare()
, const value_traits &v_traits = value_traits()) , const value_traits &v_traits = value_traits())
: Base(b, e, cmp, v_traits) : Base(b, e, cmp, v_traits)
{} {}
BOOST_INTRUSIVE_FORCEINLINE splay_set(BOOST_RV_REF(splay_set) x) inline splay_set(BOOST_RV_REF(splay_set) x)
: Base(::boost::move(static_cast<Base&>(x))) : Base(::boost::move(static_cast<Base&>(x)))
{} {}
BOOST_INTRUSIVE_FORCEINLINE splay_set& operator=(BOOST_RV_REF(splay_set) x) inline splay_set& operator=(BOOST_RV_REF(splay_set) x)
{ return static_cast<splay_set &>(this->Base::operator=(::boost::move(static_cast<Base&>(x)))); } { return static_cast<splay_set &>(this->Base::operator=(::boost::move(static_cast<Base&>(x)))); }
template <class Cloner, class Disposer> template <class Cloner, class Disposer>
BOOST_INTRUSIVE_FORCEINLINE void clone_from(const splay_set &src, Cloner cloner, Disposer disposer) inline void clone_from(const splay_set &src, Cloner cloner, Disposer disposer)
{ Base::clone_from(src, cloner, disposer); } { Base::clone_from(src, cloner, disposer); }
template <class Cloner, class Disposer> template <class Cloner, class Disposer>
BOOST_INTRUSIVE_FORCEINLINE void clone_from(BOOST_RV_REF(splay_set) src, Cloner cloner, Disposer disposer) inline void clone_from(BOOST_RV_REF(splay_set) src, Cloner cloner, Disposer disposer)
{ Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer); } { Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer); }
BOOST_INTRUSIVE_FORCEINLINE static splay_set &container_from_end_iterator(iterator end_iterator) BOOST_NOEXCEPT inline static splay_set &container_from_end_iterator(iterator end_iterator) BOOST_NOEXCEPT
{ return static_cast<splay_set &>(Base::container_from_end_iterator(end_iterator)); } { return static_cast<splay_set &>(Base::container_from_end_iterator(end_iterator)); }
BOOST_INTRUSIVE_FORCEINLINE static const splay_set &container_from_end_iterator(const_iterator end_iterator) BOOST_NOEXCEPT inline static const splay_set &container_from_end_iterator(const_iterator end_iterator) BOOST_NOEXCEPT
{ return static_cast<const splay_set &>(Base::container_from_end_iterator(end_iterator)); } { return static_cast<const splay_set &>(Base::container_from_end_iterator(end_iterator)); }
BOOST_INTRUSIVE_FORCEINLINE static splay_set &container_from_iterator(iterator it) BOOST_NOEXCEPT inline static splay_set &container_from_iterator(iterator it) BOOST_NOEXCEPT
{ return static_cast<splay_set &>(Base::container_from_iterator(it)); } { return static_cast<splay_set &>(Base::container_from_iterator(it)); }
BOOST_INTRUSIVE_FORCEINLINE static const splay_set &container_from_iterator(const_iterator it) BOOST_NOEXCEPT inline static const splay_set &container_from_iterator(const_iterator it) BOOST_NOEXCEPT
{ return static_cast<const splay_set &>(Base::container_from_iterator(it)); } { return static_cast<const splay_set &>(Base::container_from_iterator(it)); }
}; };
@ -1057,46 +1057,46 @@ class splay_multiset
//Assert if passed value traits are compatible with the type //Assert if passed value traits are compatible with the type
BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value)); BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value));
BOOST_INTRUSIVE_FORCEINLINE splay_multiset() inline splay_multiset()
: Base() : Base()
{} {}
BOOST_INTRUSIVE_FORCEINLINE explicit splay_multiset( const key_compare &cmp, const value_traits &v_traits = value_traits()) inline explicit splay_multiset( const key_compare &cmp, const value_traits &v_traits = value_traits())
: Base(cmp, v_traits) : Base(cmp, v_traits)
{} {}
template<class Iterator> template<class Iterator>
BOOST_INTRUSIVE_FORCEINLINE splay_multiset( Iterator b, Iterator e inline splay_multiset( Iterator b, Iterator e
, const key_compare &cmp = key_compare() , const key_compare &cmp = key_compare()
, const value_traits &v_traits = value_traits()) , const value_traits &v_traits = value_traits())
: Base(b, e, cmp, v_traits) : Base(b, e, cmp, v_traits)
{} {}
BOOST_INTRUSIVE_FORCEINLINE splay_multiset(BOOST_RV_REF(splay_multiset) x) inline splay_multiset(BOOST_RV_REF(splay_multiset) x)
: Base(::boost::move(static_cast<Base&>(x))) : Base(::boost::move(static_cast<Base&>(x)))
{} {}
BOOST_INTRUSIVE_FORCEINLINE splay_multiset& operator=(BOOST_RV_REF(splay_multiset) x) inline splay_multiset& operator=(BOOST_RV_REF(splay_multiset) x)
{ return static_cast<splay_multiset &>(this->Base::operator=(::boost::move(static_cast<Base&>(x)))); } { return static_cast<splay_multiset &>(this->Base::operator=(::boost::move(static_cast<Base&>(x)))); }
template <class Cloner, class Disposer> template <class Cloner, class Disposer>
BOOST_INTRUSIVE_FORCEINLINE void clone_from(const splay_multiset &src, Cloner cloner, Disposer disposer) inline void clone_from(const splay_multiset &src, Cloner cloner, Disposer disposer)
{ Base::clone_from(src, cloner, disposer); } { Base::clone_from(src, cloner, disposer); }
template <class Cloner, class Disposer> template <class Cloner, class Disposer>
BOOST_INTRUSIVE_FORCEINLINE void clone_from(BOOST_RV_REF(splay_multiset) src, Cloner cloner, Disposer disposer) inline void clone_from(BOOST_RV_REF(splay_multiset) src, Cloner cloner, Disposer disposer)
{ Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer); } { Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer); }
BOOST_INTRUSIVE_FORCEINLINE static splay_multiset &container_from_end_iterator(iterator end_iterator) BOOST_NOEXCEPT inline static splay_multiset &container_from_end_iterator(iterator end_iterator) BOOST_NOEXCEPT
{ return static_cast<splay_multiset &>(Base::container_from_end_iterator(end_iterator)); } { return static_cast<splay_multiset &>(Base::container_from_end_iterator(end_iterator)); }
BOOST_INTRUSIVE_FORCEINLINE static const splay_multiset &container_from_end_iterator(const_iterator end_iterator) BOOST_NOEXCEPT inline static const splay_multiset &container_from_end_iterator(const_iterator end_iterator) BOOST_NOEXCEPT
{ return static_cast<const splay_multiset &>(Base::container_from_end_iterator(end_iterator)); } { return static_cast<const splay_multiset &>(Base::container_from_end_iterator(end_iterator)); }
BOOST_INTRUSIVE_FORCEINLINE static splay_multiset &container_from_iterator(iterator it) BOOST_NOEXCEPT inline static splay_multiset &container_from_iterator(iterator it) BOOST_NOEXCEPT
{ return static_cast<splay_multiset &>(Base::container_from_iterator(it)); } { return static_cast<splay_multiset &>(Base::container_from_iterator(it)); }
BOOST_INTRUSIVE_FORCEINLINE static const splay_multiset &container_from_iterator(const_iterator it) BOOST_NOEXCEPT inline static const splay_multiset &container_from_iterator(const_iterator it) BOOST_NOEXCEPT
{ return static_cast<const splay_multiset &>(Base::container_from_iterator(it)); } { return static_cast<const splay_multiset &>(Base::container_from_iterator(it)); }
}; };

22
include/boost/intrusive/splaytree.hpp
View File

@ -613,46 +613,46 @@ class splaytree
//Assert if passed value traits are compatible with the type //Assert if passed value traits are compatible with the type
BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value)); BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value));
BOOST_INTRUSIVE_FORCEINLINE splaytree() inline splaytree()
: Base() : Base()
{} {}
BOOST_INTRUSIVE_FORCEINLINE explicit splaytree( const key_compare &cmp, const value_traits &v_traits = value_traits()) inline explicit splaytree( const key_compare &cmp, const value_traits &v_traits = value_traits())
: Base(cmp, v_traits) : Base(cmp, v_traits)
{} {}
template<class Iterator> template<class Iterator>
BOOST_INTRUSIVE_FORCEINLINE splaytree( bool unique, Iterator b, Iterator e inline splaytree( bool unique, Iterator b, Iterator e
, const key_compare &cmp = key_compare() , const key_compare &cmp = key_compare()
, const value_traits &v_traits = value_traits()) , const value_traits &v_traits = value_traits())
: Base(unique, b, e, cmp, v_traits) : Base(unique, b, e, cmp, v_traits)
{} {}
BOOST_INTRUSIVE_FORCEINLINE splaytree(BOOST_RV_REF(splaytree) x) inline splaytree(BOOST_RV_REF(splaytree) x)
: Base(BOOST_MOVE_BASE(Base, x)) : Base(BOOST_MOVE_BASE(Base, x))
{} {}
BOOST_INTRUSIVE_FORCEINLINE splaytree& operator=(BOOST_RV_REF(splaytree) x) inline splaytree& operator=(BOOST_RV_REF(splaytree) x)
{ return static_cast<splaytree &>(this->Base::operator=(BOOST_MOVE_BASE(Base, x))); } { return static_cast<splaytree &>(this->Base::operator=(BOOST_MOVE_BASE(Base, x))); }
template <class Cloner, class Disposer> template <class Cloner, class Disposer>
BOOST_INTRUSIVE_FORCEINLINE void clone_from(const splaytree &src, Cloner cloner, Disposer disposer) inline void clone_from(const splaytree &src, Cloner cloner, Disposer disposer)
{ Base::clone_from(src, cloner, disposer); } { Base::clone_from(src, cloner, disposer); }
template <class Cloner, class Disposer> template <class Cloner, class Disposer>
BOOST_INTRUSIVE_FORCEINLINE void clone_from(BOOST_RV_REF(splaytree) src, Cloner cloner, Disposer disposer) inline void clone_from(BOOST_RV_REF(splaytree) src, Cloner cloner, Disposer disposer)
{ Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer); } { Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer); }
BOOST_INTRUSIVE_FORCEINLINE static splaytree &container_from_end_iterator(iterator end_iterator) BOOST_NOEXCEPT inline static splaytree &container_from_end_iterator(iterator end_iterator) BOOST_NOEXCEPT
{ return static_cast<splaytree &>(Base::container_from_end_iterator(end_iterator)); } { return static_cast<splaytree &>(Base::container_from_end_iterator(end_iterator)); }
BOOST_INTRUSIVE_FORCEINLINE static const splaytree &container_from_end_iterator(const_iterator end_iterator) BOOST_NOEXCEPT inline static const splaytree &container_from_end_iterator(const_iterator end_iterator) BOOST_NOEXCEPT
{ return static_cast<const splaytree &>(Base::container_from_end_iterator(end_iterator)); } { return static_cast<const splaytree &>(Base::container_from_end_iterator(end_iterator)); }
BOOST_INTRUSIVE_FORCEINLINE static splaytree &container_from_iterator(iterator it) BOOST_NOEXCEPT inline static splaytree &container_from_iterator(iterator it) BOOST_NOEXCEPT
{ return static_cast<splaytree &>(Base::container_from_iterator(it)); } { return static_cast<splaytree &>(Base::container_from_iterator(it)); }
BOOST_INTRUSIVE_FORCEINLINE static const splaytree &container_from_iterator(const_iterator it) BOOST_NOEXCEPT inline static const splaytree &container_from_iterator(const_iterator it) BOOST_NOEXCEPT
{ return static_cast<const splaytree &>(Base::container_from_iterator(it)); } { return static_cast<const splaytree &>(Base::container_from_iterator(it)); }
}; };

34
include/boost/intrusive/treap.hpp
View File

@ -255,7 +255,7 @@ class treap_impl
//! <b>Complexity</b>: Constant. //! <b>Complexity</b>: Constant.
//! //!
//! <b>Throws</b>: Nothing. //! <b>Throws</b>: Nothing.
BOOST_INTRUSIVE_FORCEINLINE iterator top() BOOST_NOEXCEPT inline iterator top() BOOST_NOEXCEPT
{ return this->tree_type::root(); } { return this->tree_type::root(); }
//! <b>Effects</b>: Returns a const_iterator pointing to the highest priority object of the treap.. //! <b>Effects</b>: Returns a const_iterator pointing to the highest priority object of the treap..
@ -263,7 +263,7 @@ class treap_impl
//! <b>Complexity</b>: Constant. //! <b>Complexity</b>: Constant.
//! //!
//! <b>Throws</b>: Nothing. //! <b>Throws</b>: Nothing.
BOOST_INTRUSIVE_FORCEINLINE const_iterator top() const BOOST_NOEXCEPT inline const_iterator top() const BOOST_NOEXCEPT
{ return this->ctop(); } { return this->ctop(); }
//! <b>Effects</b>: Returns a const_iterator pointing to the highest priority object of the treap.. //! <b>Effects</b>: Returns a const_iterator pointing to the highest priority object of the treap..
@ -271,7 +271,7 @@ class treap_impl
//! <b>Complexity</b>: Constant. //! <b>Complexity</b>: Constant.
//! //!
//! <b>Throws</b>: Nothing. //! <b>Throws</b>: Nothing.
BOOST_INTRUSIVE_FORCEINLINE const_iterator ctop() const BOOST_NOEXCEPT inline const_iterator ctop() const BOOST_NOEXCEPT
{ return this->tree_type::root(); } { return this->tree_type::root(); }
#ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED #ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
@ -310,7 +310,7 @@ class treap_impl
//! <b>Complexity</b>: Constant. //! <b>Complexity</b>: Constant.
//! //!
//! <b>Throws</b>: Nothing. //! <b>Throws</b>: Nothing.
BOOST_INTRUSIVE_FORCEINLINE reverse_iterator rtop() BOOST_NOEXCEPT inline reverse_iterator rtop() BOOST_NOEXCEPT
{ return reverse_iterator(this->top()); } { return reverse_iterator(this->top()); }
//! <b>Effects</b>: Returns a const_reverse_iterator pointing to the highest priority objec //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the highest priority objec
@ -319,7 +319,7 @@ class treap_impl
//! <b>Complexity</b>: Constant. //! <b>Complexity</b>: Constant.
//! //!
//! <b>Throws</b>: Nothing. //! <b>Throws</b>: Nothing.
BOOST_INTRUSIVE_FORCEINLINE const_reverse_iterator rtop() const BOOST_NOEXCEPT inline const_reverse_iterator rtop() const BOOST_NOEXCEPT
{ return const_reverse_iterator(this->top()); } { return const_reverse_iterator(this->top()); }
//! <b>Effects</b>: Returns a const_reverse_iterator pointing to the highest priority object //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the highest priority object
@ -328,7 +328,7 @@ class treap_impl
//! <b>Complexity</b>: Constant. //! <b>Complexity</b>: Constant.
//! //!
//! <b>Throws</b>: Nothing. //! <b>Throws</b>: Nothing.
BOOST_INTRUSIVE_FORCEINLINE const_reverse_iterator crtop() const BOOST_NOEXCEPT inline const_reverse_iterator crtop() const BOOST_NOEXCEPT
{ return const_reverse_iterator(this->top()); } { return const_reverse_iterator(this->top()); }
#ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED #ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
@ -1315,49 +1315,49 @@ class treap
//Assert if passed value traits are compatible with the type //Assert if passed value traits are compatible with the type
BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value)); BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value));
BOOST_INTRUSIVE_FORCEINLINE treap() inline treap()
: Base() : Base()
{} {}
BOOST_INTRUSIVE_FORCEINLINE explicit treap( const key_compare &cmp inline explicit treap( const key_compare &cmp
, const priority_compare &pcmp = priority_compare() , const priority_compare &pcmp = priority_compare()
, const value_traits &v_traits = value_traits()) , const value_traits &v_traits = value_traits())
: Base(cmp, pcmp, v_traits) : Base(cmp, pcmp, v_traits)
{} {}
template<class Iterator> template<class Iterator>
BOOST_INTRUSIVE_FORCEINLINE treap( bool unique, Iterator b, Iterator e inline treap( bool unique, Iterator b, Iterator e
, const key_compare &cmp = key_compare() , const key_compare &cmp = key_compare()
, const priority_compare &pcmp = priority_compare() , const priority_compare &pcmp = priority_compare()
, const value_traits &v_traits = value_traits()) , const value_traits &v_traits = value_traits())
: Base(unique, b, e, cmp, pcmp, v_traits) : Base(unique, b, e, cmp, pcmp, v_traits)
{} {}
BOOST_INTRUSIVE_FORCEINLINE treap(BOOST_RV_REF(treap) x) inline treap(BOOST_RV_REF(treap) x)
: Base(BOOST_MOVE_BASE(Base, x)) : Base(BOOST_MOVE_BASE(Base, x))
{} {}
BOOST_INTRUSIVE_FORCEINLINE treap& operator=(BOOST_RV_REF(treap) x) inline treap& operator=(BOOST_RV_REF(treap) x)
{ return static_cast<treap&>(this->Base::operator=(BOOST_MOVE_BASE(Base, x))); } { return static_cast<treap&>(this->Base::operator=(BOOST_MOVE_BASE(Base, x))); }
template <class Cloner, class Disposer> template <class Cloner, class Disposer>
BOOST_INTRUSIVE_FORCEINLINE void clone_from(const treap &src, Cloner cloner, Disposer disposer) inline void clone_from(const treap &src, Cloner cloner, Disposer disposer)
{ Base::clone_from(src, cloner, disposer); } { Base::clone_from(src, cloner, disposer); }
template <class Cloner, class Disposer> template <class Cloner, class Disposer>
BOOST_INTRUSIVE_FORCEINLINE void clone_from(BOOST_RV_REF(treap) src, Cloner cloner, Disposer disposer) inline void clone_from(BOOST_RV_REF(treap) src, Cloner cloner, Disposer disposer)
{ Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer); } { Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer); }
BOOST_INTRUSIVE_FORCEINLINE static treap &container_from_end_iterator(iterator end_iterator) BOOST_NOEXCEPT inline static treap &container_from_end_iterator(iterator end_iterator) BOOST_NOEXCEPT
{ return static_cast<treap &>(Base::container_from_end_iterator(end_iterator)); } { return static_cast<treap &>(Base::container_from_end_iterator(end_iterator)); }
BOOST_INTRUSIVE_FORCEINLINE static const treap &container_from_end_iterator(const_iterator end_iterator) BOOST_NOEXCEPT inline static const treap &container_from_end_iterator(const_iterator end_iterator) BOOST_NOEXCEPT
{ return static_cast<const treap &>(Base::container_from_end_iterator(end_iterator)); } { return static_cast<const treap &>(Base::container_from_end_iterator(end_iterator)); }
BOOST_INTRUSIVE_FORCEINLINE static treap &container_from_iterator(iterator it) BOOST_NOEXCEPT inline static treap &container_from_iterator(iterator it) BOOST_NOEXCEPT
{ return static_cast<treap &>(Base::container_from_iterator(it)); } { return static_cast<treap &>(Base::container_from_iterator(it)); }
BOOST_INTRUSIVE_FORCEINLINE static const treap &container_from_iterator(const_iterator it) BOOST_NOEXCEPT inline static const treap &container_from_iterator(const_iterator it) BOOST_NOEXCEPT
{ return static_cast<const treap &>(Base::container_from_iterator(it)); } { return static_cast<const treap &>(Base::container_from_iterator(it)); }
}; };

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

@ -172,6 +172,10 @@ class treap_algorithms
/// @endcond /// @endcond
{ {
/// @cond /// @cond
inline insert_commit_data()
: bstree_algo::insert_commit_data(), rotations()
{}
std::size_t rotations; std::size_t rotations;
/// @endcond /// @endcond
}; };

68
include/boost/intrusive/treap_set.hpp
View File

@ -215,22 +215,22 @@ class treap_set_impl
#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) #if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED)
//! @copydoc ::boost::intrusive::treap::top() //! @copydoc ::boost::intrusive::treap::top()
BOOST_INTRUSIVE_FORCEINLINE iterator top() BOOST_NOEXCEPT; inline iterator top() BOOST_NOEXCEPT;
//! @copydoc ::boost::intrusive::treap::top()const //! @copydoc ::boost::intrusive::treap::top()const
BOOST_INTRUSIVE_FORCEINLINE const_iterator top() const BOOST_NOEXCEPT; inline const_iterator top() const BOOST_NOEXCEPT;
//! @copydoc ::boost::intrusive::treap::ctop()const //! @copydoc ::boost::intrusive::treap::ctop()const
BOOST_INTRUSIVE_FORCEINLINE const_iterator ctop() const BOOST_NOEXCEPT; inline const_iterator ctop() const BOOST_NOEXCEPT;
//! @copydoc ::boost::intrusive::treap::rtop() //! @copydoc ::boost::intrusive::treap::rtop()
BOOST_INTRUSIVE_FORCEINLINE reverse_iterator rtop() BOOST_NOEXCEPT; inline reverse_iterator rtop() BOOST_NOEXCEPT;
//! @copydoc ::boost::intrusive::treap::rtop()const //! @copydoc ::boost::intrusive::treap::rtop()const
BOOST_INTRUSIVE_FORCEINLINE const_reverse_iterator rtop() const BOOST_NOEXCEPT; inline const_reverse_iterator rtop() const BOOST_NOEXCEPT;
//! @copydoc ::boost::intrusive::treap::crtop()const //! @copydoc ::boost::intrusive::treap::crtop()const
BOOST_INTRUSIVE_FORCEINLINE const_reverse_iterator crtop() const BOOST_NOEXCEPT; inline const_reverse_iterator crtop() const BOOST_NOEXCEPT;
//! @copydoc ::boost::intrusive::treap::crtop() const //! @copydoc ::boost::intrusive::treap::crtop() const
priority_compare priority_comp() const; priority_compare priority_comp() const;
@ -542,49 +542,49 @@ class treap_set
//Assert if passed value traits are compatible with the type //Assert if passed value traits are compatible with the type
BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value)); BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value));
BOOST_INTRUSIVE_FORCEINLINE treap_set() inline treap_set()
: Base() : Base()
{} {}
BOOST_INTRUSIVE_FORCEINLINE explicit treap_set( const key_compare &cmp inline explicit treap_set( const key_compare &cmp
, const priority_compare &pcmp = priority_compare() , const priority_compare &pcmp = priority_compare()
, const value_traits &v_traits = value_traits()) , const value_traits &v_traits = value_traits())
: Base(cmp, pcmp, v_traits) : Base(cmp, pcmp, v_traits)
{} {}
template<class Iterator> template<class Iterator>
BOOST_INTRUSIVE_FORCEINLINE treap_set( Iterator b, Iterator e inline treap_set( Iterator b, Iterator e
, const key_compare &cmp = key_compare() , const key_compare &cmp = key_compare()
, const priority_compare &pcmp = priority_compare() , const priority_compare &pcmp = priority_compare()
, const value_traits &v_traits = value_traits()) , const value_traits &v_traits = value_traits())
: Base(b, e, cmp, pcmp, v_traits) : Base(b, e, cmp, pcmp, v_traits)
{} {}
BOOST_INTRUSIVE_FORCEINLINE treap_set(BOOST_RV_REF(treap_set) x) inline treap_set(BOOST_RV_REF(treap_set) x)
: Base(BOOST_MOVE_BASE(Base, x)) : Base(BOOST_MOVE_BASE(Base, x))
{} {}
BOOST_INTRUSIVE_FORCEINLINE treap_set& operator=(BOOST_RV_REF(treap_set) x) inline treap_set& operator=(BOOST_RV_REF(treap_set) x)
{ return static_cast<treap_set &>(this->Base::operator=(BOOST_MOVE_BASE(Base, x))); } { return static_cast<treap_set &>(this->Base::operator=(BOOST_MOVE_BASE(Base, x))); }
template <class Cloner, class Disposer> template <class Cloner, class Disposer>
BOOST_INTRUSIVE_FORCEINLINE void clone_from(const treap_set &src, Cloner cloner, Disposer disposer) inline void clone_from(const treap_set &src, Cloner cloner, Disposer disposer)
{ Base::clone_from(src, cloner, disposer); } { Base::clone_from(src, cloner, disposer); }
template <class Cloner, class Disposer> template <class Cloner, class Disposer>
BOOST_INTRUSIVE_FORCEINLINE void clone_from(BOOST_RV_REF(treap_set) src, Cloner cloner, Disposer disposer) inline void clone_from(BOOST_RV_REF(treap_set) src, Cloner cloner, Disposer disposer)
{ Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer); } { Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer); }
BOOST_INTRUSIVE_FORCEINLINE static treap_set &container_from_end_iterator(iterator end_iterator) BOOST_NOEXCEPT inline static treap_set &container_from_end_iterator(iterator end_iterator) BOOST_NOEXCEPT
{ return static_cast<treap_set &>(Base::container_from_end_iterator(end_iterator)); } { return static_cast<treap_set &>(Base::container_from_end_iterator(end_iterator)); }
BOOST_INTRUSIVE_FORCEINLINE static const treap_set &container_from_end_iterator(const_iterator end_iterator) BOOST_NOEXCEPT inline static const treap_set &container_from_end_iterator(const_iterator end_iterator) BOOST_NOEXCEPT
{ return static_cast<const treap_set &>(Base::container_from_end_iterator(end_iterator)); } { return static_cast<const treap_set &>(Base::container_from_end_iterator(end_iterator)); }
BOOST_INTRUSIVE_FORCEINLINE static treap_set &container_from_iterator(iterator it) BOOST_NOEXCEPT inline static treap_set &container_from_iterator(iterator it) BOOST_NOEXCEPT
{ return static_cast<treap_set &>(Base::container_from_iterator(it)); } { return static_cast<treap_set &>(Base::container_from_iterator(it)); }
BOOST_INTRUSIVE_FORCEINLINE static const treap_set &container_from_iterator(const_iterator it) BOOST_NOEXCEPT inline static const treap_set &container_from_iterator(const_iterator it) BOOST_NOEXCEPT
{ return static_cast<const treap_set &>(Base::container_from_iterator(it)); } { return static_cast<const treap_set &>(Base::container_from_iterator(it)); }
}; };
@ -774,22 +774,22 @@ class treap_multiset_impl
#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) #if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED)
//! @copydoc ::boost::intrusive::treap::top() //! @copydoc ::boost::intrusive::treap::top()
BOOST_INTRUSIVE_FORCEINLINE iterator top() BOOST_NOEXCEPT; inline iterator top() BOOST_NOEXCEPT;
//! @copydoc ::boost::intrusive::treap::top()const //! @copydoc ::boost::intrusive::treap::top()const
BOOST_INTRUSIVE_FORCEINLINE const_iterator top() const BOOST_NOEXCEPT; inline const_iterator top() const BOOST_NOEXCEPT;
//! @copydoc ::boost::intrusive::treap::ctop()const //! @copydoc ::boost::intrusive::treap::ctop()const
BOOST_INTRUSIVE_FORCEINLINE const_iterator ctop() const BOOST_NOEXCEPT; inline const_iterator ctop() const BOOST_NOEXCEPT;
//! @copydoc ::boost::intrusive::treap::rtop() //! @copydoc ::boost::intrusive::treap::rtop()
BOOST_INTRUSIVE_FORCEINLINE reverse_iterator rtop() BOOST_NOEXCEPT; inline reverse_iterator rtop() BOOST_NOEXCEPT;
//! @copydoc ::boost::intrusive::treap::rtop()const //! @copydoc ::boost::intrusive::treap::rtop()const
BOOST_INTRUSIVE_FORCEINLINE const_reverse_iterator rtop() const BOOST_NOEXCEPT; inline const_reverse_iterator rtop() const BOOST_NOEXCEPT;
//! @copydoc ::boost::intrusive::treap::crtop()const //! @copydoc ::boost::intrusive::treap::crtop()const
BOOST_INTRUSIVE_FORCEINLINE const_reverse_iterator crtop() const BOOST_NOEXCEPT; inline const_reverse_iterator crtop() const BOOST_NOEXCEPT;
//! @copydoc ::boost::intrusive::treap::crtop() const //! @copydoc ::boost::intrusive::treap::crtop() const
priority_compare priority_comp() const; priority_compare priority_comp() const;
@ -1057,49 +1057,49 @@ class treap_multiset
//Assert if passed value traits are compatible with the type //Assert if passed value traits are compatible with the type
BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value)); BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value));
BOOST_INTRUSIVE_FORCEINLINE treap_multiset() inline treap_multiset()
: Base() : Base()
{} {}
BOOST_INTRUSIVE_FORCEINLINE explicit treap_multiset( const key_compare &cmp inline explicit treap_multiset( const key_compare &cmp
, const priority_compare &pcmp = priority_compare() , const priority_compare &pcmp = priority_compare()
, const value_traits &v_traits = value_traits()) , const value_traits &v_traits = value_traits())
: Base(cmp, pcmp, v_traits) : Base(cmp, pcmp, v_traits)
{} {}
template<class Iterator> template<class Iterator>
BOOST_INTRUSIVE_FORCEINLINE treap_multiset( Iterator b, Iterator e inline treap_multiset( Iterator b, Iterator e
, const key_compare &cmp = key_compare() , const key_compare &cmp = key_compare()
, const priority_compare &pcmp = priority_compare() , const priority_compare &pcmp = priority_compare()
, const value_traits &v_traits = value_traits()) , const value_traits &v_traits = value_traits())
: Base(b, e, cmp, pcmp, v_traits) : Base(b, e, cmp, pcmp, v_traits)
{} {}
BOOST_INTRUSIVE_FORCEINLINE treap_multiset(BOOST_RV_REF(treap_multiset) x) inline treap_multiset(BOOST_RV_REF(treap_multiset) x)
: Base(BOOST_MOVE_BASE(Base, x)) : Base(BOOST_MOVE_BASE(Base, x))
{} {}
BOOST_INTRUSIVE_FORCEINLINE treap_multiset& operator=(BOOST_RV_REF(treap_multiset) x) inline treap_multiset& operator=(BOOST_RV_REF(treap_multiset) x)
{ return static_cast<treap_multiset &>(this->Base::operator=(BOOST_MOVE_BASE(Base, x))); } { return static_cast<treap_multiset &>(this->Base::operator=(BOOST_MOVE_BASE(Base, x))); }
template <class Cloner, class Disposer> template <class Cloner, class Disposer>
BOOST_INTRUSIVE_FORCEINLINE void clone_from(const treap_multiset &src, Cloner cloner, Disposer disposer) inline void clone_from(const treap_multiset &src, Cloner cloner, Disposer disposer)
{ Base::clone_from(src, cloner, disposer); } { Base::clone_from(src, cloner, disposer); }
template <class Cloner, class Disposer> template <class Cloner, class Disposer>
BOOST_INTRUSIVE_FORCEINLINE void clone_from(BOOST_RV_REF(treap_multiset) src, Cloner cloner, Disposer disposer) inline void clone_from(BOOST_RV_REF(treap_multiset) src, Cloner cloner, Disposer disposer)
{ Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer); } { Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer); }
BOOST_INTRUSIVE_FORCEINLINE static treap_multiset &container_from_end_iterator(iterator end_iterator) BOOST_NOEXCEPT inline static treap_multiset &container_from_end_iterator(iterator end_iterator) BOOST_NOEXCEPT
{ return static_cast<treap_multiset &>(Base::container_from_end_iterator(end_iterator)); } { return static_cast<treap_multiset &>(Base::container_from_end_iterator(end_iterator)); }
BOOST_INTRUSIVE_FORCEINLINE static const treap_multiset &container_from_end_iterator(const_iterator end_iterator) BOOST_NOEXCEPT inline static const treap_multiset &container_from_end_iterator(const_iterator end_iterator) BOOST_NOEXCEPT
{ return static_cast<const treap_multiset &>(Base::container_from_end_iterator(end_iterator)); } { return static_cast<const treap_multiset &>(Base::container_from_end_iterator(end_iterator)); }
BOOST_INTRUSIVE_FORCEINLINE static treap_multiset &container_from_iterator(iterator it) BOOST_NOEXCEPT inline static treap_multiset &container_from_iterator(iterator it) BOOST_NOEXCEPT
{ return static_cast<treap_multiset &>(Base::container_from_iterator(it)); } { return static_cast<treap_multiset &>(Base::container_from_iterator(it)); }
BOOST_INTRUSIVE_FORCEINLINE static const treap_multiset &container_from_iterator(const_iterator it) BOOST_NOEXCEPT inline static const treap_multiset &container_from_iterator(const_iterator it) BOOST_NOEXCEPT
{ return static_cast<const treap_multiset &>(Base::container_from_iterator(it)); } { return static_cast<const treap_multiset &>(Base::container_from_iterator(it)); }
}; };

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

@ -121,7 +121,7 @@ class unordered_set_impl
public: public:
//! @copydoc ::boost::intrusive::hashtable::hashtable(const bucket_traits &,const hasher &,const key_equal &,const value_traits &) //! @copydoc ::boost::intrusive::hashtable::hashtable(const bucket_traits &,const hasher &,const key_equal &,const value_traits &)
BOOST_INTRUSIVE_FORCEINLINE explicit unordered_set_impl( const bucket_traits &b_traits inline explicit unordered_set_impl( const bucket_traits &b_traits
, const hasher & hash_func = hasher() , const hasher & hash_func = hasher()
, const key_equal &equal_func = key_equal() , const key_equal &equal_func = key_equal()
, const value_traits &v_traits = value_traits()) , const value_traits &v_traits = value_traits())
@ -130,7 +130,7 @@ class unordered_set_impl
//! @copydoc ::boost::intrusive::hashtable::hashtable(bool,Iterator,Iterator,const bucket_traits &,const hasher &,const key_equal &,const value_traits &) //! @copydoc ::boost::intrusive::hashtable::hashtable(bool,Iterator,Iterator,const bucket_traits &,const hasher &,const key_equal &,const value_traits &)
template<class Iterator> template<class Iterator>
BOOST_INTRUSIVE_FORCEINLINE unordered_set_impl( Iterator b inline unordered_set_impl( Iterator b
, Iterator e , Iterator e
, const bucket_traits &b_traits , const bucket_traits &b_traits
, const hasher & hash_func = hasher() , const hasher & hash_func = hasher()
@ -140,12 +140,12 @@ class unordered_set_impl
{} {}
//! @copydoc ::boost::intrusive::hashtable::hashtable(hashtable&&) //! @copydoc ::boost::intrusive::hashtable::hashtable(hashtable&&)
BOOST_INTRUSIVE_FORCEINLINE unordered_set_impl(BOOST_RV_REF(unordered_set_impl) x) inline unordered_set_impl(BOOST_RV_REF(unordered_set_impl) x)
: table_type(BOOST_MOVE_BASE(table_type, x)) : table_type(BOOST_MOVE_BASE(table_type, x))
{} {}
//! @copydoc ::boost::intrusive::hashtable::operator=(hashtable&&) //! @copydoc ::boost::intrusive::hashtable::operator=(hashtable&&)
BOOST_INTRUSIVE_FORCEINLINE unordered_set_impl& operator=(BOOST_RV_REF(unordered_set_impl) x) inline unordered_set_impl& operator=(BOOST_RV_REF(unordered_set_impl) x)
{ return static_cast<unordered_set_impl&>(table_type::operator=(BOOST_MOVE_BASE(table_type, x))); } { return static_cast<unordered_set_impl&>(table_type::operator=(BOOST_MOVE_BASE(table_type, x))); }
#ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED #ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
@ -197,30 +197,30 @@ class unordered_set_impl
//! @copydoc ::boost::intrusive::hashtable::clone_from(hashtable&&,Cloner,Disposer) //! @copydoc ::boost::intrusive::hashtable::clone_from(hashtable&&,Cloner,Disposer)
template <class Cloner, class Disposer> template <class Cloner, class Disposer>
BOOST_INTRUSIVE_FORCEINLINE void clone_from(BOOST_RV_REF(unordered_set_impl) src, Cloner cloner, Disposer disposer) inline void clone_from(BOOST_RV_REF(unordered_set_impl) src, Cloner cloner, Disposer disposer)
{ table_type::clone_from(BOOST_MOVE_BASE(table_type, src), cloner, disposer); } { table_type::clone_from(BOOST_MOVE_BASE(table_type, src), cloner, disposer); }
//! @copydoc ::boost::intrusive::hashtable::insert_unique(reference) //! @copydoc ::boost::intrusive::hashtable::insert_unique(reference)
BOOST_INTRUSIVE_FORCEINLINE std::pair<iterator, bool> insert(reference value) inline std::pair<iterator, bool> insert(reference value)
{ return table_type::insert_unique(value); } { return table_type::insert_unique(value); }
//! @copydoc ::boost::intrusive::hashtable::insert_unique(Iterator,Iterator) //! @copydoc ::boost::intrusive::hashtable::insert_unique(Iterator,Iterator)
template<class Iterator> template<class Iterator>
BOOST_INTRUSIVE_FORCEINLINE void insert(Iterator b, Iterator e) inline void insert(Iterator b, Iterator e)
{ table_type::insert_unique(b, e); } { table_type::insert_unique(b, e); }
//! @copydoc ::boost::intrusive::hashtable::insert_unique_check(const key_type&,insert_commit_data&) //! @copydoc ::boost::intrusive::hashtable::insert_unique_check(const key_type&,insert_commit_data&)
BOOST_INTRUSIVE_FORCEINLINE std::pair<iterator, bool> insert_check(const key_type &key, insert_commit_data &commit_data) inline std::pair<iterator, bool> insert_check(const key_type &key, insert_commit_data &commit_data)
{ return table_type::insert_unique_check(key, commit_data); } { return table_type::insert_unique_check(key, commit_data); }
//! @copydoc ::boost::intrusive::hashtable::insert_unique_check(const KeyType&,KeyHasher,KeyEqual,insert_commit_data&) //! @copydoc ::boost::intrusive::hashtable::insert_unique_check(const KeyType&,KeyHasher,KeyEqual,insert_commit_data&)
template<class KeyType, class KeyHasher, class KeyEqual> template<class KeyType, class KeyHasher, class KeyEqual>
BOOST_INTRUSIVE_FORCEINLINE std::pair<iterator, bool> insert_check inline std::pair<iterator, bool> insert_check
(const KeyType &key, KeyHasher hash_func, KeyEqual key_value_equal, insert_commit_data &commit_data) (const KeyType &key, KeyHasher hash_func, KeyEqual key_value_equal, insert_commit_data &commit_data)
{ return table_type::insert_unique_check(key, hash_func, key_value_equal, commit_data); } { return table_type::insert_unique_check(key, hash_func, key_value_equal, commit_data); }
//! @copydoc ::boost::intrusive::hashtable::insert_unique_commit //! @copydoc ::boost::intrusive::hashtable::insert_unique_commit
BOOST_INTRUSIVE_FORCEINLINE iterator insert_commit(reference value, const insert_commit_data &commit_data) BOOST_NOEXCEPT inline iterator insert_commit(reference value, const insert_commit_data &commit_data) BOOST_NOEXCEPT
{ return table_type::insert_unique_commit(value, commit_data); } { return table_type::insert_unique_commit(value, commit_data); }
#ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED #ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
@ -501,7 +501,7 @@ class unordered_set
typedef typename Base::hasher hasher; typedef typename Base::hasher hasher;
typedef typename Base::key_equal key_equal; typedef typename Base::key_equal key_equal;
BOOST_INTRUSIVE_FORCEINLINE inline
explicit unordered_set ( const bucket_traits &b_traits explicit unordered_set ( const bucket_traits &b_traits
, const hasher & hash_func = hasher() , const hasher & hash_func = hasher()
, const key_equal &equal_func = key_equal() , const key_equal &equal_func = key_equal()
@ -510,7 +510,7 @@ class unordered_set
{} {}
template<class Iterator> template<class Iterator>
BOOST_INTRUSIVE_FORCEINLINE inline
unordered_set unordered_set
( Iterator b, Iterator e ( Iterator b, Iterator e
, const bucket_traits &b_traits , const bucket_traits &b_traits
@ -520,19 +520,19 @@ class unordered_set
: Base(b, e, b_traits, hash_func, equal_func, v_traits) : Base(b, e, b_traits, hash_func, equal_func, v_traits)
{} {}
BOOST_INTRUSIVE_FORCEINLINE unordered_set(BOOST_RV_REF(unordered_set) x) inline unordered_set(BOOST_RV_REF(unordered_set) x)
: Base(BOOST_MOVE_BASE(Base, x)) : Base(BOOST_MOVE_BASE(Base, x))
{} {}
BOOST_INTRUSIVE_FORCEINLINE unordered_set& operator=(BOOST_RV_REF(unordered_set) x) inline unordered_set& operator=(BOOST_RV_REF(unordered_set) x)
{ return static_cast<unordered_set&>(this->Base::operator=(BOOST_MOVE_BASE(Base, x))); } { return static_cast<unordered_set&>(this->Base::operator=(BOOST_MOVE_BASE(Base, x))); }
template <class Cloner, class Disposer> template <class Cloner, class Disposer>
BOOST_INTRUSIVE_FORCEINLINE void clone_from(const unordered_set &src, Cloner cloner, Disposer disposer) inline void clone_from(const unordered_set &src, Cloner cloner, Disposer disposer)
{ this->Base::clone_from(src, cloner, disposer); } { this->Base::clone_from(src, cloner, disposer); }
template <class Cloner, class Disposer> template <class Cloner, class Disposer>
BOOST_INTRUSIVE_FORCEINLINE void clone_from(BOOST_RV_REF(unordered_set) src, Cloner cloner, Disposer disposer) inline void clone_from(BOOST_RV_REF(unordered_set) src, Cloner cloner, Disposer disposer)
{ this->Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer); } { this->Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer); }
}; };
@ -622,7 +622,7 @@ class unordered_multiset_impl
public: public:
//! @copydoc ::boost::intrusive::hashtable::hashtable(const bucket_traits &,const hasher &,const key_equal &,const value_traits &) //! @copydoc ::boost::intrusive::hashtable::hashtable(const bucket_traits &,const hasher &,const key_equal &,const value_traits &)
BOOST_INTRUSIVE_FORCEINLINE explicit unordered_multiset_impl ( const bucket_traits &b_traits inline explicit unordered_multiset_impl ( const bucket_traits &b_traits
, const hasher & hash_func = hasher() , const hasher & hash_func = hasher()
, const key_equal &equal_func = key_equal() , const key_equal &equal_func = key_equal()
, const value_traits &v_traits = value_traits()) , const value_traits &v_traits = value_traits())
@ -631,7 +631,7 @@ class unordered_multiset_impl
//! @copydoc ::boost::intrusive::hashtable::hashtable(bool,Iterator,Iterator,const bucket_traits &,const hasher &,const key_equal &,const value_traits &) //! @copydoc ::boost::intrusive::hashtable::hashtable(bool,Iterator,Iterator,const bucket_traits &,const hasher &,const key_equal &,const value_traits &)
template<class Iterator> template<class Iterator>
BOOST_INTRUSIVE_FORCEINLINE unordered_multiset_impl ( Iterator b inline unordered_multiset_impl ( Iterator b
, Iterator e , Iterator e
, const bucket_traits &b_traits , const bucket_traits &b_traits
, const hasher & hash_func = hasher() , const hasher & hash_func = hasher()
@ -642,13 +642,13 @@ class unordered_multiset_impl
//! <b>Effects</b>: to-do //! <b>Effects</b>: to-do
//! //!
BOOST_INTRUSIVE_FORCEINLINE unordered_multiset_impl(BOOST_RV_REF(unordered_multiset_impl) x) inline unordered_multiset_impl(BOOST_RV_REF(unordered_multiset_impl) x)
: table_type(BOOST_MOVE_BASE(table_type, x)) : table_type(BOOST_MOVE_BASE(table_type, x))
{} {}
//! <b>Effects</b>: to-do //! <b>Effects</b>: to-do
//! //!
BOOST_INTRUSIVE_FORCEINLINE unordered_multiset_impl& operator=(BOOST_RV_REF(unordered_multiset_impl) x) inline unordered_multiset_impl& operator=(BOOST_RV_REF(unordered_multiset_impl) x)
{ return static_cast<unordered_multiset_impl&>(table_type::operator=(BOOST_MOVE_BASE(table_type, x))); } { return static_cast<unordered_multiset_impl&>(table_type::operator=(BOOST_MOVE_BASE(table_type, x))); }
#ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED #ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
@ -701,16 +701,16 @@ class unordered_multiset_impl
//! @copydoc ::boost::intrusive::hashtable::clone_from(hashtable&&,Cloner,Disposer) //! @copydoc ::boost::intrusive::hashtable::clone_from(hashtable&&,Cloner,Disposer)
template <class Cloner, class Disposer> template <class Cloner, class Disposer>
BOOST_INTRUSIVE_FORCEINLINE void clone_from(BOOST_RV_REF(unordered_multiset_impl) src, Cloner cloner, Disposer disposer) inline void clone_from(BOOST_RV_REF(unordered_multiset_impl) src, Cloner cloner, Disposer disposer)
{ table_type::clone_from(BOOST_MOVE_BASE(table_type, src), cloner, disposer); } { table_type::clone_from(BOOST_MOVE_BASE(table_type, src), cloner, disposer); }
//! @copydoc ::boost::intrusive::hashtable::insert_equal(reference) //! @copydoc ::boost::intrusive::hashtable::insert_equal(reference)
BOOST_INTRUSIVE_FORCEINLINE iterator insert(reference value) inline iterator insert(reference value)
{ return table_type::insert_equal(value); } { return table_type::insert_equal(value); }
//! @copydoc ::boost::intrusive::hashtable::insert_equal(Iterator,Iterator) //! @copydoc ::boost::intrusive::hashtable::insert_equal(Iterator,Iterator)
template<class Iterator> template<class Iterator>
BOOST_INTRUSIVE_FORCEINLINE void insert(Iterator b, Iterator e) inline void insert(Iterator b, Iterator e)
{ table_type::insert_equal(b, e); } { table_type::insert_equal(b, e); }
#ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED #ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
@ -956,7 +956,7 @@ class unordered_multiset
typedef typename Base::hasher hasher; typedef typename Base::hasher hasher;
typedef typename Base::key_equal key_equal; typedef typename Base::key_equal key_equal;
BOOST_INTRUSIVE_FORCEINLINE inline
explicit unordered_multiset( const bucket_traits &b_traits explicit unordered_multiset( const bucket_traits &b_traits
, const hasher & hash_func = hasher() , const hasher & hash_func = hasher()
, const key_equal &equal_func = key_equal() , const key_equal &equal_func = key_equal()
@ -965,7 +965,7 @@ class unordered_multiset
{} {}
template<class Iterator> template<class Iterator>
BOOST_INTRUSIVE_FORCEINLINE inline
unordered_multiset( Iterator b unordered_multiset( Iterator b
, Iterator e , Iterator e
, const bucket_traits &b_traits , const bucket_traits &b_traits
@ -975,19 +975,19 @@ class unordered_multiset
: Base(b, e, b_traits, hash_func, equal_func, v_traits) : Base(b, e, b_traits, hash_func, equal_func, v_traits)
{} {}
BOOST_INTRUSIVE_FORCEINLINE unordered_multiset(BOOST_RV_REF(unordered_multiset) x) inline unordered_multiset(BOOST_RV_REF(unordered_multiset) x)
: Base(BOOST_MOVE_BASE(Base, x)) : Base(BOOST_MOVE_BASE(Base, x))
{} {}
BOOST_INTRUSIVE_FORCEINLINE unordered_multiset& operator=(BOOST_RV_REF(unordered_multiset) x) inline unordered_multiset& operator=(BOOST_RV_REF(unordered_multiset) x)
{ return static_cast<unordered_multiset&>(this->Base::operator=(BOOST_MOVE_BASE(Base, x))); } { return static_cast<unordered_multiset&>(this->Base::operator=(BOOST_MOVE_BASE(Base, x))); }
template <class Cloner, class Disposer> template <class Cloner, class Disposer>
BOOST_INTRUSIVE_FORCEINLINE void clone_from(const unordered_multiset &src, Cloner cloner, Disposer disposer) inline void clone_from(const unordered_multiset &src, Cloner cloner, Disposer disposer)
{ this->Base::clone_from(src, cloner, disposer); } { this->Base::clone_from(src, cloner, disposer); }
template <class Cloner, class Disposer> template <class Cloner, class Disposer>
BOOST_INTRUSIVE_FORCEINLINE void clone_from(BOOST_RV_REF(unordered_multiset) src, Cloner cloner, Disposer disposer) inline void clone_from(BOOST_RV_REF(unordered_multiset) src, Cloner cloner, Disposer disposer)
{ this->Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer); } { this->Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer); }
}; };

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

@ -82,22 +82,22 @@ struct unordered_node_traits
static const bool store_hash = StoreHash; static const bool store_hash = StoreHash;
static const bool optimize_multikey = OptimizeMultiKey; static const bool optimize_multikey = OptimizeMultiKey;
BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_next(const_node_ptr n) BOOST_NOEXCEPT inline static node_ptr get_next(const_node_ptr n) BOOST_NOEXCEPT
{ return pointer_traits<node_ptr>::static_cast_from(n->next_); } { return pointer_traits<node_ptr>::static_cast_from(n->next_); }
BOOST_INTRUSIVE_FORCEINLINE static void set_next(node_ptr n, node_ptr next) BOOST_NOEXCEPT inline static void set_next(node_ptr n, node_ptr next) BOOST_NOEXCEPT
{ n->next_ = next; } { n->next_ = next; }
BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_prev_in_group(const_node_ptr n) BOOST_NOEXCEPT inline static node_ptr get_prev_in_group(const_node_ptr n) BOOST_NOEXCEPT
{ return n->prev_in_group_; } { return n->prev_in_group_; }
BOOST_INTRUSIVE_FORCEINLINE static void set_prev_in_group(node_ptr n, node_ptr prev) BOOST_NOEXCEPT inline static void set_prev_in_group(node_ptr n, node_ptr prev) BOOST_NOEXCEPT
{ n->prev_in_group_ = prev; } { n->prev_in_group_ = prev; }
BOOST_INTRUSIVE_FORCEINLINE static std::size_t get_hash(const_node_ptr n) BOOST_NOEXCEPT inline static std::size_t get_hash(const_node_ptr n) BOOST_NOEXCEPT
{ return n->hash_; } { return n->hash_; }
BOOST_INTRUSIVE_FORCEINLINE static void set_hash(node_ptr n, std::size_t h) BOOST_NOEXCEPT inline static void set_hash(node_ptr n, std::size_t h) BOOST_NOEXCEPT
{ n->hash_ = h; } { n->hash_ = h; }
}; };
@ -108,10 +108,10 @@ struct unordered_group_adapter
typedef typename NodeTraits::node_ptr node_ptr; typedef typename NodeTraits::node_ptr node_ptr;
typedef typename NodeTraits::const_node_ptr const_node_ptr; typedef typename NodeTraits::const_node_ptr const_node_ptr;
BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_next(const_node_ptr n) inline static node_ptr get_next(const_node_ptr n)
{ return NodeTraits::get_prev_in_group(n); } { return NodeTraits::get_prev_in_group(n); }
BOOST_INTRUSIVE_FORCEINLINE static void set_next(node_ptr n, node_ptr next) inline static void set_next(node_ptr n, node_ptr next)
{ NodeTraits::set_prev_in_group(n, next); } { NodeTraits::set_prev_in_group(n, next); }
}; };
@ -127,19 +127,19 @@ struct unordered_algorithms
typedef typename NodeTraits::node_ptr node_ptr; typedef typename NodeTraits::node_ptr node_ptr;
typedef typename NodeTraits::const_node_ptr const_node_ptr; typedef typename NodeTraits::const_node_ptr const_node_ptr;
BOOST_INTRUSIVE_FORCEINLINE static void init(typename base_type::node_ptr n) BOOST_NOEXCEPT inline static void init(typename base_type::node_ptr n) BOOST_NOEXCEPT
{ {
base_type::init(n); base_type::init(n);
group_algorithms::init(n); group_algorithms::init(n);
} }
BOOST_INTRUSIVE_FORCEINLINE static void init_header(typename base_type::node_ptr n) BOOST_NOEXCEPT inline static void init_header(typename base_type::node_ptr n) BOOST_NOEXCEPT
{ {
base_type::init_header(n); base_type::init_header(n);
group_algorithms::init_header(n); group_algorithms::init_header(n);
} }
BOOST_INTRUSIVE_FORCEINLINE static void unlink(typename base_type::node_ptr n) BOOST_NOEXCEPT inline static void unlink(typename base_type::node_ptr n) BOOST_NOEXCEPT
{ {
base_type::unlink(n); base_type::unlink(n);
group_algorithms::unlink(n); group_algorithms::unlink(n);