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

Declare more BOOST_INTRUSIVE_FORCEINLINE functions in tree and list containers.

Browse Source
This commit is contained in:
Ion Gaztañaga
2019-02-11 10:49:55 +01:00
parent 9d6bba4a68
commit 911774278a
17 changed files with 219 additions and 219 deletions
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
BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value));
avl_set()
BOOST_INTRUSIVE_FORCEINLINE avl_set()
: Base()
{}
explicit avl_set( const key_compare &cmp, const value_traits &v_traits = value_traits())
BOOST_INTRUSIVE_FORCEINLINE explicit avl_set( const key_compare &cmp, const value_traits &v_traits = value_traits())
: Base(cmp, v_traits)
{}
template<class Iterator>
avl_set( Iterator b, Iterator e
BOOST_INTRUSIVE_FORCEINLINE avl_set( Iterator b, Iterator e
, const key_compare &cmp = key_compare()
, const value_traits &v_traits = value_traits())
: Base(b, e, cmp, v_traits)
{}
avl_set(BOOST_RV_REF(avl_set) x)
BOOST_INTRUSIVE_FORCEINLINE avl_set(BOOST_RV_REF(avl_set) x)
: Base(BOOST_MOVE_BASE(Base, x))
{}
avl_set& operator=(BOOST_RV_REF(avl_set) x)
BOOST_INTRUSIVE_FORCEINLINE avl_set& operator=(BOOST_RV_REF(avl_set) x)
{ return static_cast<avl_set &>(this->Base::operator=(BOOST_MOVE_BASE(Base, x))); }
template <class Cloner, class Disposer>
void clone_from(const avl_set &src, Cloner cloner, Disposer disposer)
BOOST_INTRUSIVE_FORCEINLINE void clone_from(const avl_set &src, Cloner cloner, Disposer disposer)
{ Base::clone_from(src, cloner, disposer); }
template <class Cloner, class Disposer>
void clone_from(BOOST_RV_REF(avl_set) src, Cloner cloner, Disposer disposer)
BOOST_INTRUSIVE_FORCEINLINE void clone_from(BOOST_RV_REF(avl_set) src, Cloner cloner, Disposer disposer)
{ Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer); }
static avl_set &container_from_end_iterator(iterator end_iterator)
BOOST_INTRUSIVE_FORCEINLINE static avl_set &container_from_end_iterator(iterator end_iterator)
{ return static_cast<avl_set &>(Base::container_from_end_iterator(end_iterator)); }
static const avl_set &container_from_end_iterator(const_iterator end_iterator)
BOOST_INTRUSIVE_FORCEINLINE static const avl_set &container_from_end_iterator(const_iterator end_iterator)
{ return static_cast<const avl_set &>(Base::container_from_end_iterator(end_iterator)); }
static avl_set &container_from_iterator(iterator it)
BOOST_INTRUSIVE_FORCEINLINE static avl_set &container_from_iterator(iterator it)
{ return static_cast<avl_set &>(Base::container_from_iterator(it)); }
static const avl_set &container_from_iterator(const_iterator it)
BOOST_INTRUSIVE_FORCEINLINE static const avl_set &container_from_iterator(const_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
BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value));
avl_multiset()
BOOST_INTRUSIVE_FORCEINLINE avl_multiset()
: Base()
{}
explicit avl_multiset( const key_compare &cmp, const value_traits &v_traits = value_traits())
BOOST_INTRUSIVE_FORCEINLINE explicit avl_multiset( const key_compare &cmp, const value_traits &v_traits = value_traits())
: Base(cmp, v_traits)
{}
template<class Iterator>
avl_multiset( Iterator b, Iterator e
BOOST_INTRUSIVE_FORCEINLINE avl_multiset( Iterator b, Iterator e
, const key_compare &cmp = key_compare()
, const value_traits &v_traits = value_traits())
: Base(b, e, cmp, v_traits)
{}
avl_multiset(BOOST_RV_REF(avl_multiset) x)
BOOST_INTRUSIVE_FORCEINLINE avl_multiset(BOOST_RV_REF(avl_multiset) x)
: Base(BOOST_MOVE_BASE(Base, x))
{}
avl_multiset& operator=(BOOST_RV_REF(avl_multiset) x)
BOOST_INTRUSIVE_FORCEINLINE avl_multiset& operator=(BOOST_RV_REF(avl_multiset) x)
{ return static_cast<avl_multiset &>(this->Base::operator=(BOOST_MOVE_BASE(Base, x))); }
template <class Cloner, class Disposer>
void clone_from(const avl_multiset &src, Cloner cloner, Disposer disposer)
BOOST_INTRUSIVE_FORCEINLINE void clone_from(const avl_multiset &src, Cloner cloner, Disposer disposer)
{ Base::clone_from(src, cloner, disposer); }
template <class Cloner, class Disposer>
void clone_from(BOOST_RV_REF(avl_multiset) src, Cloner cloner, Disposer disposer)
BOOST_INTRUSIVE_FORCEINLINE void clone_from(BOOST_RV_REF(avl_multiset) src, Cloner cloner, Disposer disposer)
{ Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer); }
static avl_multiset &container_from_end_iterator(iterator end_iterator)
BOOST_INTRUSIVE_FORCEINLINE static avl_multiset &container_from_end_iterator(iterator end_iterator)
{ return static_cast<avl_multiset &>(Base::container_from_end_iterator(end_iterator)); }
static const avl_multiset &container_from_end_iterator(const_iterator end_iterator)
BOOST_INTRUSIVE_FORCEINLINE static const avl_multiset &container_from_end_iterator(const_iterator end_iterator)
{ return static_cast<const avl_multiset &>(Base::container_from_end_iterator(end_iterator)); }
static avl_multiset &container_from_iterator(iterator it)
BOOST_INTRUSIVE_FORCEINLINE static avl_multiset &container_from_iterator(iterator it)
{ return static_cast<avl_multiset &>(Base::container_from_iterator(it)); }
static const avl_multiset &container_from_iterator(const_iterator it)
BOOST_INTRUSIVE_FORCEINLINE static const avl_multiset &container_from_iterator(const_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
BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value));
avltree()
BOOST_INTRUSIVE_FORCEINLINE avltree()
: Base()
{}
explicit avltree( const key_compare &cmp, const value_traits &v_traits = value_traits())
BOOST_INTRUSIVE_FORCEINLINE explicit avltree( const key_compare &cmp, const value_traits &v_traits = value_traits())
: Base(cmp, v_traits)
{}
template<class Iterator>
avltree( bool unique, Iterator b, Iterator e
BOOST_INTRUSIVE_FORCEINLINE avltree( bool unique, Iterator b, Iterator e
, const key_compare &cmp = key_compare()
, const value_traits &v_traits = value_traits())
: Base(unique, b, e, cmp, v_traits)
{}
avltree(BOOST_RV_REF(avltree) x)
BOOST_INTRUSIVE_FORCEINLINE avltree(BOOST_RV_REF(avltree) x)
: Base(BOOST_MOVE_BASE(Base, x))
{}
avltree& operator=(BOOST_RV_REF(avltree) x)
BOOST_INTRUSIVE_FORCEINLINE avltree& operator=(BOOST_RV_REF(avltree) x)
{ return static_cast<avltree &>(this->Base::operator=(BOOST_MOVE_BASE(Base, x))); }
template <class Cloner, class Disposer>
void clone_from(const avltree &src, Cloner cloner, Disposer disposer)
BOOST_INTRUSIVE_FORCEINLINE void clone_from(const avltree &src, Cloner cloner, Disposer disposer)
{ Base::clone_from(src, cloner, disposer); }
template <class Cloner, class Disposer>
void clone_from(BOOST_RV_REF(avltree) src, Cloner cloner, Disposer disposer)
BOOST_INTRUSIVE_FORCEINLINE void clone_from(BOOST_RV_REF(avltree) src, Cloner cloner, Disposer disposer)
{ Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer); }
static avltree &container_from_end_iterator(iterator end_iterator)
BOOST_INTRUSIVE_FORCEINLINE static avltree &container_from_end_iterator(iterator end_iterator)
{ return static_cast<avltree &>(Base::container_from_end_iterator(end_iterator)); }
static const avltree &container_from_end_iterator(const_iterator end_iterator)
BOOST_INTRUSIVE_FORCEINLINE static const avltree &container_from_end_iterator(const_iterator end_iterator)
{ return static_cast<const avltree &>(Base::container_from_end_iterator(end_iterator)); }
static avltree &container_from_iterator(iterator it)
BOOST_INTRUSIVE_FORCEINLINE static avltree &container_from_iterator(iterator it)
{ return static_cast<avltree &>(Base::container_from_iterator(it)); }
static const avltree &container_from_iterator(const_iterator it)
BOOST_INTRUSIVE_FORCEINLINE static const avltree &container_from_iterator(const_iterator it)
{ return static_cast<const avltree &>(Base::container_from_iterator(it)); }
};

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
BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value));
bs_set()
BOOST_INTRUSIVE_FORCEINLINE bs_set()
: Base()
{}
explicit bs_set( const key_compare &cmp, const value_traits &v_traits = value_traits())
BOOST_INTRUSIVE_FORCEINLINE explicit bs_set( const key_compare &cmp, const value_traits &v_traits = value_traits())
: Base(cmp, v_traits)
{}
template<class Iterator>
bs_set( Iterator b, Iterator e
BOOST_INTRUSIVE_FORCEINLINE bs_set( Iterator b, Iterator e
, const key_compare &cmp = key_compare()
, const value_traits &v_traits = value_traits())
: Base(b, e, cmp, v_traits)
{}
bs_set(BOOST_RV_REF(bs_set) x)
BOOST_INTRUSIVE_FORCEINLINE bs_set(BOOST_RV_REF(bs_set) x)
: Base(BOOST_MOVE_BASE(Base, x))
{}
bs_set& operator=(BOOST_RV_REF(bs_set) x)
BOOST_INTRUSIVE_FORCEINLINE bs_set& operator=(BOOST_RV_REF(bs_set) x)
{ return static_cast<bs_set &>(this->Base::operator=(BOOST_MOVE_BASE(Base, x))); }
template <class Cloner, class Disposer>
void clone_from(const bs_set &src, Cloner cloner, Disposer disposer)
BOOST_INTRUSIVE_FORCEINLINE void clone_from(const bs_set &src, Cloner cloner, Disposer disposer)
{ Base::clone_from(src, cloner, disposer); }
template <class Cloner, class Disposer>
void clone_from(BOOST_RV_REF(bs_set) src, Cloner cloner, Disposer disposer)
BOOST_INTRUSIVE_FORCEINLINE void clone_from(BOOST_RV_REF(bs_set) src, Cloner cloner, Disposer disposer)
{ Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer); }
static bs_set &container_from_end_iterator(iterator end_iterator)
BOOST_INTRUSIVE_FORCEINLINE static bs_set &container_from_end_iterator(iterator end_iterator)
{ return static_cast<bs_set &>(Base::container_from_end_iterator(end_iterator)); }
static const bs_set &container_from_end_iterator(const_iterator end_iterator)
BOOST_INTRUSIVE_FORCEINLINE static const bs_set &container_from_end_iterator(const_iterator end_iterator)
{ return static_cast<const bs_set &>(Base::container_from_end_iterator(end_iterator)); }
static bs_set &container_from_iterator(iterator it)
BOOST_INTRUSIVE_FORCEINLINE static bs_set &container_from_iterator(iterator it)
{ return static_cast<bs_set &>(Base::container_from_iterator(it)); }
static const bs_set &container_from_iterator(const_iterator it)
BOOST_INTRUSIVE_FORCEINLINE static const bs_set &container_from_iterator(const_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
BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value));
bs_multiset()
BOOST_INTRUSIVE_FORCEINLINE bs_multiset()
: Base()
{}
explicit bs_multiset( const key_compare &cmp, const value_traits &v_traits = value_traits())
BOOST_INTRUSIVE_FORCEINLINE explicit bs_multiset( const key_compare &cmp, const value_traits &v_traits = value_traits())
: Base(cmp, v_traits)
{}
template<class Iterator>
bs_multiset( Iterator b, Iterator e
BOOST_INTRUSIVE_FORCEINLINE bs_multiset( Iterator b, Iterator e
, const key_compare &cmp = key_compare()
, const value_traits &v_traits = value_traits())
: Base(b, e, cmp, v_traits)
{}
bs_multiset(BOOST_RV_REF(bs_multiset) x)
BOOST_INTRUSIVE_FORCEINLINE bs_multiset(BOOST_RV_REF(bs_multiset) x)
: Base(BOOST_MOVE_BASE(Base, x))
{}
bs_multiset& operator=(BOOST_RV_REF(bs_multiset) x)
BOOST_INTRUSIVE_FORCEINLINE bs_multiset& operator=(BOOST_RV_REF(bs_multiset) x)
{ return static_cast<bs_multiset &>(this->Base::operator=(BOOST_MOVE_BASE(Base, x))); }
template <class Cloner, class Disposer>
void clone_from(const bs_multiset &src, Cloner cloner, Disposer disposer)
BOOST_INTRUSIVE_FORCEINLINE void clone_from(const bs_multiset &src, Cloner cloner, Disposer disposer)
{ Base::clone_from(src, cloner, disposer); }
template <class Cloner, class Disposer>
void clone_from(BOOST_RV_REF(bs_multiset) src, Cloner cloner, Disposer disposer)
BOOST_INTRUSIVE_FORCEINLINE void clone_from(BOOST_RV_REF(bs_multiset) src, Cloner cloner, Disposer disposer)
{ Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer); }
static bs_multiset &container_from_end_iterator(iterator end_iterator)
BOOST_INTRUSIVE_FORCEINLINE static bs_multiset &container_from_end_iterator(iterator end_iterator)
{ return static_cast<bs_multiset &>(Base::container_from_end_iterator(end_iterator)); }
static const bs_multiset &container_from_end_iterator(const_iterator end_iterator)
BOOST_INTRUSIVE_FORCEINLINE static const bs_multiset &container_from_end_iterator(const_iterator end_iterator)
{ return static_cast<const bs_multiset &>(Base::container_from_end_iterator(end_iterator)); }
static bs_multiset &container_from_iterator(iterator it)
BOOST_INTRUSIVE_FORCEINLINE static bs_multiset &container_from_iterator(iterator it)
{ return static_cast<bs_multiset &>(Base::container_from_iterator(it)); }
static const bs_multiset &container_from_iterator(const_iterator it)
BOOST_INTRUSIVE_FORCEINLINE static const bs_multiset &container_from_iterator(const_iterator it)
{ return static_cast<const bs_multiset &>(Base::container_from_iterator(it)); }
};

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

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

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

@@ -161,52 +161,52 @@ class generic_hook
< NodeTraits
, Tag, LinkMode, BaseHookType> hooktags;
node_ptr this_ptr()
BOOST_INTRUSIVE_FORCEINLINE node_ptr this_ptr()
{ return pointer_traits<node_ptr>::pointer_to(static_cast<node&>(*this)); }
const_node_ptr this_ptr() const
BOOST_INTRUSIVE_FORCEINLINE const_node_ptr this_ptr() const
{ return pointer_traits<const_node_ptr>::pointer_to(static_cast<const node&>(*this)); }
public:
/// @endcond
generic_hook()
BOOST_INTRUSIVE_FORCEINLINE generic_hook()
{
if(hooktags::safemode_or_autounlink){
node_algorithms::init(this->this_ptr());
}
}
generic_hook(const generic_hook& )
BOOST_INTRUSIVE_FORCEINLINE generic_hook(const generic_hook& )
{
if(hooktags::safemode_or_autounlink){
node_algorithms::init(this->this_ptr());
}
}
generic_hook& operator=(const generic_hook& )
BOOST_INTRUSIVE_FORCEINLINE generic_hook& operator=(const generic_hook& )
{ return *this; }
~generic_hook()
BOOST_INTRUSIVE_FORCEINLINE ~generic_hook()
{
destructor_impl
(*this, detail::link_dispatch<hooktags::link_mode>());
}
void swap_nodes(generic_hook &other)
BOOST_INTRUSIVE_FORCEINLINE void swap_nodes(generic_hook &other)
{
node_algorithms::swap_nodes
(this->this_ptr(), other.this_ptr());
}
bool is_linked() const
BOOST_INTRUSIVE_FORCEINLINE bool is_linked() const
{
//is_linked() can be only used in safe-mode or auto-unlink
BOOST_STATIC_ASSERT(( hooktags::safemode_or_autounlink ));
return !node_algorithms::unique(this->this_ptr());
}
void unlink()
BOOST_INTRUSIVE_FORCEINLINE void unlink()
{
BOOST_STATIC_ASSERT(( (int)hooktags::link_mode == (int)auto_unlink ));
node_ptr n(this->this_ptr());

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

@@ -34,7 +34,7 @@
#define BOOST_INTRUSIVE_I ,
#define BOOST_INTRUSIVE_DOCIGN(T1) T1
#define BOOST_INTRUSIVE_DISABLE_FORCEINLINE
//#define BOOST_INTRUSIVE_DISABLE_FORCEINLINE
#if defined(BOOST_INTRUSIVE_DISABLE_FORCEINLINE)
#define BOOST_INTRUSIVE_FORCEINLINE inline

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

@@ -1471,38 +1471,38 @@ class list
typedef typename Base::iterator iterator;
typedef typename Base::const_iterator const_iterator;
list()
BOOST_INTRUSIVE_FORCEINLINE list()
: Base()
{}
explicit list(const value_traits &v_traits)
BOOST_INTRUSIVE_FORCEINLINE explicit list(const value_traits &v_traits)
: Base(v_traits)
{}
template<class Iterator>
list(Iterator b, Iterator e, const value_traits &v_traits = value_traits())
BOOST_INTRUSIVE_FORCEINLINE list(Iterator b, Iterator e, const value_traits &v_traits = value_traits())
: Base(b, e, v_traits)
{}
list(BOOST_RV_REF(list) x)
BOOST_INTRUSIVE_FORCEINLINE list(BOOST_RV_REF(list) x)
: Base(BOOST_MOVE_BASE(Base, x))
{}
list& operator=(BOOST_RV_REF(list) x)
BOOST_INTRUSIVE_FORCEINLINE list& operator=(BOOST_RV_REF(list) x)
{ return static_cast<list &>(this->Base::operator=(BOOST_MOVE_BASE(Base, x))); }
template <class Cloner, class Disposer>
void clone_from(const list &src, Cloner cloner, Disposer disposer)
BOOST_INTRUSIVE_FORCEINLINE void clone_from(const list &src, Cloner cloner, Disposer disposer)
{ Base::clone_from(src, cloner, disposer); }
template <class Cloner, class Disposer>
void clone_from(BOOST_RV_REF(list) src, Cloner cloner, Disposer disposer)
BOOST_INTRUSIVE_FORCEINLINE void clone_from(BOOST_RV_REF(list) src, Cloner cloner, Disposer disposer)
{ Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer); }
static list &container_from_end_iterator(iterator end_iterator)
BOOST_INTRUSIVE_FORCEINLINE static list &container_from_end_iterator(iterator end_iterator)
{ return static_cast<list &>(Base::container_from_end_iterator(end_iterator)); }
static const list &container_from_end_iterator(const_iterator end_iterator)
BOOST_INTRUSIVE_FORCEINLINE static const list &container_from_end_iterator(const_iterator end_iterator)
{ return static_cast<const list &>(Base::container_from_end_iterator(end_iterator)); }
};

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

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

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

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

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

@@ -273,7 +273,7 @@ class rbtree_algorithms
#endif //#ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
//! @copydoc ::boost::intrusive::bstree_algorithms::init_header(node_ptr)
static void init_header(node_ptr header)
BOOST_INTRUSIVE_FORCEINLINE static void init_header(node_ptr header)
{
bstree_algo::init_header(header);
NodeTraits::set_color(header, NodeTraits::red());

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

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

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

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

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

@@ -233,7 +233,7 @@ class slist_impl
{};
struct data_t
: public slist_impl::value_traits
: public value_traits
{
typedef typename slist_impl::value_traits value_traits;
explicit data_t(const value_traits &val_traits)
@@ -2202,45 +2202,45 @@ class slist
typedef typename Base::size_type size_type;
typedef typename Base::node_ptr node_ptr;
slist()
BOOST_INTRUSIVE_FORCEINLINE slist()
: Base()
{}
explicit slist(const value_traits &v_traits)
BOOST_INTRUSIVE_FORCEINLINE explicit slist(const value_traits &v_traits)
: Base(v_traits)
{}
struct incorporate_t{};
slist( const node_ptr & f, const node_ptr & before_l
BOOST_INTRUSIVE_FORCEINLINE slist( const node_ptr & f, const node_ptr & before_l
, size_type n, const value_traits &v_traits = value_traits())
: Base(f, before_l, n, v_traits)
{}
template<class Iterator>
slist(Iterator b, Iterator e, const value_traits &v_traits = value_traits())
BOOST_INTRUSIVE_FORCEINLINE slist(Iterator b, Iterator e, const value_traits &v_traits = value_traits())
: Base(b, e, v_traits)
{}
slist(BOOST_RV_REF(slist) x)
BOOST_INTRUSIVE_FORCEINLINE slist(BOOST_RV_REF(slist) x)
: Base(BOOST_MOVE_BASE(Base, x))
{}
slist& operator=(BOOST_RV_REF(slist) x)
BOOST_INTRUSIVE_FORCEINLINE slist& operator=(BOOST_RV_REF(slist) x)
{ return static_cast<slist &>(this->Base::operator=(BOOST_MOVE_BASE(Base, x))); }
template <class Cloner, class Disposer>
void clone_from(const slist &src, Cloner cloner, Disposer disposer)
BOOST_INTRUSIVE_FORCEINLINE void clone_from(const slist &src, Cloner cloner, Disposer disposer)
{ Base::clone_from(src, cloner, disposer); }
template <class Cloner, class Disposer>
void clone_from(BOOST_RV_REF(slist) src, Cloner cloner, Disposer disposer)
BOOST_INTRUSIVE_FORCEINLINE void clone_from(BOOST_RV_REF(slist) src, Cloner cloner, Disposer disposer)
{ Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer); }
static slist &container_from_end_iterator(iterator end_iterator)
BOOST_INTRUSIVE_FORCEINLINE static slist &container_from_end_iterator(iterator end_iterator)
{ return static_cast<slist &>(Base::container_from_end_iterator(end_iterator)); }
static const slist &container_from_end_iterator(const_iterator end_iterator)
BOOST_INTRUSIVE_FORCEINLINE static const slist &container_from_end_iterator(const_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
BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value));
splay_set()
BOOST_INTRUSIVE_FORCEINLINE splay_set()
: Base()
{}
explicit splay_set( const key_compare &cmp, const value_traits &v_traits = value_traits())
BOOST_INTRUSIVE_FORCEINLINE explicit splay_set( const key_compare &cmp, const value_traits &v_traits = value_traits())
: Base(cmp, v_traits)
{}
template<class Iterator>
splay_set( Iterator b, Iterator e
BOOST_INTRUSIVE_FORCEINLINE splay_set( Iterator b, Iterator e
, const key_compare &cmp = key_compare()
, const value_traits &v_traits = value_traits())
: Base(b, e, cmp, v_traits)
{}
splay_set(BOOST_RV_REF(splay_set) x)
BOOST_INTRUSIVE_FORCEINLINE splay_set(BOOST_RV_REF(splay_set) x)
: Base(::boost::move(static_cast<Base&>(x)))
{}
splay_set& operator=(BOOST_RV_REF(splay_set) x)
BOOST_INTRUSIVE_FORCEINLINE splay_set& operator=(BOOST_RV_REF(splay_set) x)
{ return static_cast<splay_set &>(this->Base::operator=(::boost::move(static_cast<Base&>(x)))); }
template <class Cloner, class Disposer>
void clone_from(const splay_set &src, Cloner cloner, Disposer disposer)
BOOST_INTRUSIVE_FORCEINLINE void clone_from(const splay_set &src, Cloner cloner, Disposer disposer)
{ Base::clone_from(src, cloner, disposer); }
template <class Cloner, class Disposer>
void clone_from(BOOST_RV_REF(splay_set) src, Cloner cloner, Disposer disposer)
BOOST_INTRUSIVE_FORCEINLINE void clone_from(BOOST_RV_REF(splay_set) src, Cloner cloner, Disposer disposer)
{ Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer); }
static splay_set &container_from_end_iterator(iterator end_iterator)
BOOST_INTRUSIVE_FORCEINLINE static splay_set &container_from_end_iterator(iterator end_iterator)
{ return static_cast<splay_set &>(Base::container_from_end_iterator(end_iterator)); }
static const splay_set &container_from_end_iterator(const_iterator end_iterator)
BOOST_INTRUSIVE_FORCEINLINE static const splay_set &container_from_end_iterator(const_iterator end_iterator)
{ return static_cast<const splay_set &>(Base::container_from_end_iterator(end_iterator)); }
static splay_set &container_from_iterator(iterator it)
BOOST_INTRUSIVE_FORCEINLINE static splay_set &container_from_iterator(iterator it)
{ return static_cast<splay_set &>(Base::container_from_iterator(it)); }
static const splay_set &container_from_iterator(const_iterator it)
BOOST_INTRUSIVE_FORCEINLINE static const splay_set &container_from_iterator(const_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
BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value));
splay_multiset()
BOOST_INTRUSIVE_FORCEINLINE splay_multiset()
: Base()
{}
explicit splay_multiset( const key_compare &cmp, const value_traits &v_traits = value_traits())
BOOST_INTRUSIVE_FORCEINLINE explicit splay_multiset( const key_compare &cmp, const value_traits &v_traits = value_traits())
: Base(cmp, v_traits)
{}
template<class Iterator>
splay_multiset( Iterator b, Iterator e
BOOST_INTRUSIVE_FORCEINLINE splay_multiset( Iterator b, Iterator e
, const key_compare &cmp = key_compare()
, const value_traits &v_traits = value_traits())
: Base(b, e, cmp, v_traits)
{}
splay_multiset(BOOST_RV_REF(splay_multiset) x)
BOOST_INTRUSIVE_FORCEINLINE splay_multiset(BOOST_RV_REF(splay_multiset) x)
: Base(::boost::move(static_cast<Base&>(x)))
{}
splay_multiset& operator=(BOOST_RV_REF(splay_multiset) x)
BOOST_INTRUSIVE_FORCEINLINE splay_multiset& operator=(BOOST_RV_REF(splay_multiset) x)
{ return static_cast<splay_multiset &>(this->Base::operator=(::boost::move(static_cast<Base&>(x)))); }
template <class Cloner, class Disposer>
void clone_from(const splay_multiset &src, Cloner cloner, Disposer disposer)
BOOST_INTRUSIVE_FORCEINLINE void clone_from(const splay_multiset &src, Cloner cloner, Disposer disposer)
{ Base::clone_from(src, cloner, disposer); }
template <class Cloner, class Disposer>
void clone_from(BOOST_RV_REF(splay_multiset) src, Cloner cloner, Disposer disposer)
BOOST_INTRUSIVE_FORCEINLINE void clone_from(BOOST_RV_REF(splay_multiset) src, Cloner cloner, Disposer disposer)
{ Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer); }
static splay_multiset &container_from_end_iterator(iterator end_iterator)
BOOST_INTRUSIVE_FORCEINLINE static splay_multiset &container_from_end_iterator(iterator end_iterator)
{ return static_cast<splay_multiset &>(Base::container_from_end_iterator(end_iterator)); }
static const splay_multiset &container_from_end_iterator(const_iterator end_iterator)
BOOST_INTRUSIVE_FORCEINLINE static const splay_multiset &container_from_end_iterator(const_iterator end_iterator)
{ return static_cast<const splay_multiset &>(Base::container_from_end_iterator(end_iterator)); }
static splay_multiset &container_from_iterator(iterator it)
BOOST_INTRUSIVE_FORCEINLINE static splay_multiset &container_from_iterator(iterator it)
{ return static_cast<splay_multiset &>(Base::container_from_iterator(it)); }
static const splay_multiset &container_from_iterator(const_iterator it)
BOOST_INTRUSIVE_FORCEINLINE static const splay_multiset &container_from_iterator(const_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
BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value));
splaytree()
BOOST_INTRUSIVE_FORCEINLINE splaytree()
: Base()
{}
explicit splaytree( const key_compare &cmp, const value_traits &v_traits = value_traits())
BOOST_INTRUSIVE_FORCEINLINE explicit splaytree( const key_compare &cmp, const value_traits &v_traits = value_traits())
: Base(cmp, v_traits)
{}
template<class Iterator>
splaytree( bool unique, Iterator b, Iterator e
BOOST_INTRUSIVE_FORCEINLINE splaytree( bool unique, Iterator b, Iterator e
, const key_compare &cmp = key_compare()
, const value_traits &v_traits = value_traits())
: Base(unique, b, e, cmp, v_traits)
{}
splaytree(BOOST_RV_REF(splaytree) x)
BOOST_INTRUSIVE_FORCEINLINE splaytree(BOOST_RV_REF(splaytree) x)
: Base(BOOST_MOVE_BASE(Base, x))
{}
splaytree& operator=(BOOST_RV_REF(splaytree) x)
BOOST_INTRUSIVE_FORCEINLINE splaytree& operator=(BOOST_RV_REF(splaytree) x)
{ return static_cast<splaytree &>(this->Base::operator=(BOOST_MOVE_BASE(Base, x))); }
template <class Cloner, class Disposer>
void clone_from(const splaytree &src, Cloner cloner, Disposer disposer)
BOOST_INTRUSIVE_FORCEINLINE void clone_from(const splaytree &src, Cloner cloner, Disposer disposer)
{ Base::clone_from(src, cloner, disposer); }
template <class Cloner, class Disposer>
void clone_from(BOOST_RV_REF(splaytree) src, Cloner cloner, Disposer disposer)
BOOST_INTRUSIVE_FORCEINLINE void clone_from(BOOST_RV_REF(splaytree) src, Cloner cloner, Disposer disposer)
{ Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer); }
static splaytree &container_from_end_iterator(iterator end_iterator)
BOOST_INTRUSIVE_FORCEINLINE static splaytree &container_from_end_iterator(iterator end_iterator)
{ return static_cast<splaytree &>(Base::container_from_end_iterator(end_iterator)); }
static const splaytree &container_from_end_iterator(const_iterator end_iterator)
BOOST_INTRUSIVE_FORCEINLINE static const splaytree &container_from_end_iterator(const_iterator end_iterator)
{ return static_cast<const splaytree &>(Base::container_from_end_iterator(end_iterator)); }
static splaytree &container_from_iterator(iterator it)
BOOST_INTRUSIVE_FORCEINLINE static splaytree &container_from_iterator(iterator it)
{ return static_cast<splaytree &>(Base::container_from_iterator(it)); }
static const splaytree &container_from_iterator(const_iterator it)
BOOST_INTRUSIVE_FORCEINLINE static const splaytree &container_from_iterator(const_iterator it)
{ return static_cast<const splaytree &>(Base::container_from_iterator(it)); }
};

18
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 optimize_multikey = OptimizeMultiKey;
static node_ptr get_next(const const_node_ptr & n)
BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_next(const const_node_ptr & n)
{ return pointer_traits<node_ptr>::static_cast_from(n->next_); }
static void set_next(node_ptr n, node_ptr next)
BOOST_INTRUSIVE_FORCEINLINE static void set_next(node_ptr n, node_ptr next)
{ n->next_ = next; }
static node_ptr get_prev_in_group(const const_node_ptr & n)
BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_prev_in_group(const const_node_ptr & n)
{ return n->prev_in_group_; }
static void set_prev_in_group(node_ptr n, node_ptr prev)
BOOST_INTRUSIVE_FORCEINLINE static void set_prev_in_group(node_ptr n, node_ptr prev)
{ n->prev_in_group_ = prev; }
static std::size_t get_hash(const const_node_ptr & n)
BOOST_INTRUSIVE_FORCEINLINE static std::size_t get_hash(const const_node_ptr & n)
{ return n->hash_; }
static void set_hash(const node_ptr & n, std::size_t h)
BOOST_INTRUSIVE_FORCEINLINE static void set_hash(const node_ptr & n, std::size_t h)
{ n->hash_ = h; }
};
@@ -127,19 +127,19 @@ struct unordered_algorithms
typedef typename NodeTraits::node_ptr node_ptr;
typedef typename NodeTraits::const_node_ptr const_node_ptr;
static void init(typename base_type::node_ptr n)
BOOST_INTRUSIVE_FORCEINLINE static void init(typename base_type::node_ptr n)
{
base_type::init(n);
group_algorithms::init(n);
}
static void init_header(typename base_type::node_ptr n)
BOOST_INTRUSIVE_FORCEINLINE static void init_header(typename base_type::node_ptr n)
{
base_type::init_header(n);
group_algorithms::init_header(n);
}
static void unlink(typename base_type::node_ptr n)
BOOST_INTRUSIVE_FORCEINLINE static void unlink(typename base_type::node_ptr n)
{
base_type::unlink(n);
group_algorithms::unlink(n);