diff --git a/include/boost/intrusive/avl_set.hpp b/include/boost/intrusive/avl_set.hpp index b03d3045..2d95c8fa 100644 --- a/include/boost/intrusive/avl_set.hpp +++ b/include/boost/intrusive/avl_set.hpp @@ -525,46 +525,46 @@ class avl_set //Assert if passed value traits are compatible with the type BOOST_STATIC_ASSERT((detail::is_same::value)); - BOOST_INTRUSIVE_FORCEINLINE avl_set() + inline avl_set() : 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) {} template - BOOST_INTRUSIVE_FORCEINLINE avl_set( Iterator b, Iterator e + inline 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) {} - 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)) {} - 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(this->Base::operator=(BOOST_MOVE_BASE(Base, x))); } template - 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); } template - 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); } - 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(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(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(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(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::value)); - BOOST_INTRUSIVE_FORCEINLINE avl_multiset() + inline avl_multiset() : 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) {} template - BOOST_INTRUSIVE_FORCEINLINE avl_multiset( Iterator b, Iterator e + inline 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) {} - 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)) {} - 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(this->Base::operator=(BOOST_MOVE_BASE(Base, x))); } template - 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); } template - 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); } - 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(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(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(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(Base::container_from_iterator(it)); } }; diff --git a/include/boost/intrusive/avltree.hpp b/include/boost/intrusive/avltree.hpp index 747d41cc..7647ee84 100644 --- a/include/boost/intrusive/avltree.hpp +++ b/include/boost/intrusive/avltree.hpp @@ -535,46 +535,46 @@ class avltree //Assert if passed value traits are compatible with the type BOOST_STATIC_ASSERT((detail::is_same::value)); - BOOST_INTRUSIVE_FORCEINLINE avltree() + inline avltree() : 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) {} template - 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 value_traits &v_traits = value_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)) {} - BOOST_INTRUSIVE_FORCEINLINE avltree& operator=(BOOST_RV_REF(avltree) x) + inline avltree& operator=(BOOST_RV_REF(avltree) x) { return static_cast(this->Base::operator=(BOOST_MOVE_BASE(Base, x))); } template - 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); } template - 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); } - 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(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(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(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(Base::container_from_iterator(it)); } }; diff --git a/include/boost/intrusive/avltree_algorithms.hpp b/include/boost/intrusive/avltree_algorithms.hpp index 0fd158d5..81954906 100644 --- a/include/boost/intrusive/avltree_algorithms.hpp +++ b/include/boost/intrusive/avltree_algorithms.hpp @@ -42,7 +42,7 @@ struct avltree_node_cloner typedef typename NodeTraits::node_ptr node_ptr; typedef detail::ebo_functor_holder base_t; - BOOST_INTRUSIVE_FORCEINLINE avltree_node_cloner(F f) + inline avltree_node_cloner(F f) : base_t(f) {} diff --git a/include/boost/intrusive/bs_set.hpp b/include/boost/intrusive/bs_set.hpp index 1755decf..24795561 100644 --- a/include/boost/intrusive/bs_set.hpp +++ b/include/boost/intrusive/bs_set.hpp @@ -522,46 +522,46 @@ class bs_set //Assert if passed value traits are compatible with the type BOOST_STATIC_ASSERT((detail::is_same::value)); - BOOST_INTRUSIVE_FORCEINLINE bs_set() + inline bs_set() : 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) {} template - BOOST_INTRUSIVE_FORCEINLINE bs_set( Iterator b, Iterator e + inline 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) {} - 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)) {} - 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(this->Base::operator=(BOOST_MOVE_BASE(Base, x))); } template - 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); } template - 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); } - 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(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(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(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(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::value)); - BOOST_INTRUSIVE_FORCEINLINE bs_multiset() + inline bs_multiset() : 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) {} template - BOOST_INTRUSIVE_FORCEINLINE bs_multiset( Iterator b, Iterator e + inline 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) {} - 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)) {} - 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(this->Base::operator=(BOOST_MOVE_BASE(Base, x))); } template - 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); } template - 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); } - 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(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(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(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(Base::container_from_iterator(it)); } }; diff --git a/include/boost/intrusive/bstree.hpp b/include/boost/intrusive/bstree.hpp index 51687ebd..3e581475 100644 --- a/include/boost/intrusive/bstree.hpp +++ b/include/boost/intrusive/bstree.hpp @@ -105,7 +105,7 @@ struct bstbase3 struct holder_t : public ValueTraits { - BOOST_INTRUSIVE_FORCEINLINE explicit holder_t(const ValueTraits &vtraits) + inline explicit holder_t(const ValueTraits &vtraits) : ValueTraits(vtraits) {} header_holder_type root; @@ -121,73 +121,73 @@ struct bstbase3 return *base; } - BOOST_INTRUSIVE_FORCEINLINE bstbase3(const ValueTraits &vtraits) + inline bstbase3(const ValueTraits &vtraits) : holder(vtraits) { node_algorithms::init_header(this->header_ptr()); } - BOOST_INTRUSIVE_FORCEINLINE node_ptr header_ptr() + inline node_ptr header_ptr() { 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(); } - BOOST_INTRUSIVE_FORCEINLINE const value_traits &get_value_traits() const + inline const value_traits &get_value_traits() const { return this->holder; } - BOOST_INTRUSIVE_FORCEINLINE value_traits &get_value_traits() + inline value_traits &get_value_traits() { return this->holder; } typedef typename boost::intrusive::value_traits_pointers ::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::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()); } - BOOST_INTRUSIVE_FORCEINLINE const_iterator begin() const BOOST_NOEXCEPT + inline const_iterator begin() const BOOST_NOEXCEPT { 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()); } - 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()); } - BOOST_INTRUSIVE_FORCEINLINE const_iterator end() const BOOST_NOEXCEPT + inline const_iterator end() const BOOST_NOEXCEPT { 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()); } - BOOST_INTRUSIVE_FORCEINLINE iterator root() + inline iterator root() { 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(); } - 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()); } - BOOST_INTRUSIVE_FORCEINLINE reverse_iterator rbegin() + inline reverse_iterator rbegin() { return reverse_iterator(end()); } - BOOST_INTRUSIVE_FORCEINLINE const_reverse_iterator rbegin() const + inline const_reverse_iterator rbegin() const { return const_reverse_iterator(end()); } - BOOST_INTRUSIVE_FORCEINLINE const_reverse_iterator crbegin() const + inline const_reverse_iterator crbegin() const { return const_reverse_iterator(end()); } - BOOST_INTRUSIVE_FORCEINLINE reverse_iterator rend() + inline reverse_iterator rend() { return reverse_iterator(begin()); } - BOOST_INTRUSIVE_FORCEINLINE const_reverse_iterator rend() const + inline const_reverse_iterator rend() const { return const_reverse_iterator(begin()); } - BOOST_INTRUSIVE_FORCEINLINE const_reverse_iterator crend() const + inline const_reverse_iterator crend() const { return const_reverse_iterator(begin()); } void replace_node(iterator replace_this, reference with_this) @@ -199,7 +199,7 @@ struct bstbase3 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()); } iterator rebalance_subtree(iterator r) BOOST_NOEXCEPT @@ -223,7 +223,7 @@ struct bstbase3 const_iterator iterator_to(const_reference value) const BOOST_NOEXCEPT { return const_iterator (this->get_value_traits().to_node_ptr(*pointer_traits::const_cast_from(pointer_traits::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)); } }; @@ -314,17 +314,17 @@ struct bstbase2 typedef BOOST_INTRUSIVE_IMPDEF(typename pointer_traits::difference_type) difference_type; 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(); } - BOOST_INTRUSIVE_FORCEINLINE key_compare key_comp() const + inline key_compare key_comp() const { return this->get_comp().key_comp(); } //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()); } - 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()); } template @@ -342,7 +342,7 @@ struct bstbase2 } //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()); } template @@ -352,7 +352,7 @@ struct bstbase2 (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()); } template @@ -367,13 +367,13 @@ struct bstbase2 { typedef detail::key_nodeptr_comp type; }; template - BOOST_INTRUSIVE_FORCEINLINE typename key_node_comp_ret::type key_node_comp(KeyTypeKeyCompare comp) const + inline typename key_node_comp_ret::type key_node_comp(KeyTypeKeyCompare comp) const { return detail::key_nodeptr_comp(comp, &this->get_value_traits()); } //find - BOOST_INTRUSIVE_FORCEINLINE iterator find(const key_type &key) + inline iterator find(const key_type &key) { return this->find(key, this->key_comp()); } template @@ -383,7 +383,7 @@ struct bstbase2 (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()); } template @@ -394,7 +394,7 @@ struct bstbase2 } //equal_range - BOOST_INTRUSIVE_FORCEINLINE std::pair equal_range(const key_type &key) + inline std::pair equal_range(const key_type &key) { return this->equal_range(key, this->key_comp()); } template @@ -406,7 +406,7 @@ struct bstbase2 , iterator(ret.second, this->priv_value_traits_ptr())); } - BOOST_INTRUSIVE_FORCEINLINE std::pair + inline std::pair equal_range(const key_type &key) const { return this->equal_range(key, this->key_comp()); } @@ -421,7 +421,7 @@ struct bstbase2 } //lower_bound_range - BOOST_INTRUSIVE_FORCEINLINE std::pair lower_bound_range(const key_type &key) + inline std::pair lower_bound_range(const key_type &key) { return this->lower_bound_range(key, this->key_comp()); } template @@ -433,7 +433,7 @@ struct bstbase2 , iterator(ret.second, this->priv_value_traits_ptr())); } - BOOST_INTRUSIVE_FORCEINLINE std::pair + inline std::pair lower_bound_range(const key_type &key) const { return this->lower_bound_range(key, this->key_comp()); } @@ -448,7 +448,7 @@ struct bstbase2 } //bounded_range - BOOST_INTRUSIVE_FORCEINLINE std::pair bounded_range + inline std::pair bounded_range (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); } @@ -463,7 +463,7 @@ struct bstbase2 , iterator(ret.second, this->priv_value_traits_ptr())); } - BOOST_INTRUSIVE_FORCEINLINE std::pair bounded_range + inline std::pair bounded_range (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); } @@ -479,11 +479,11 @@ struct bstbase2 } //insert_unique_check - BOOST_INTRUSIVE_FORCEINLINE std::pair insert_unique_check + inline std::pair insert_unique_check (const key_type &key, insert_commit_data &commit_data) { return this->insert_unique_check(key, this->key_comp(), commit_data); } - BOOST_INTRUSIVE_FORCEINLINE std::pair insert_unique_check + inline std::pair insert_unique_check (const_iterator hint, const key_type &key, insert_commit_data &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 ::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) { this->sz_traits().set_size(size_type(0)); @@ -536,10 +536,10 @@ struct bstbase_hack typedef detail::size_holder size_traits; - BOOST_INTRUSIVE_FORCEINLINE size_traits &sz_traits() + inline size_traits &sz_traits() { return static_cast(*this); } - BOOST_INTRUSIVE_FORCEINLINE const size_traits &sz_traits() const + inline const size_traits &sz_traits() const { return static_cast(*this); } }; @@ -551,13 +551,13 @@ struct bstbase_hack base_type; typedef typename base_type::value_compare value_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) {} typedef detail::size_holder size_traits; - BOOST_INTRUSIVE_FORCEINLINE size_traits sz_traits() const + inline size_traits sz_traits() const { return size_traits(); } }; @@ -579,7 +579,7 @@ struct bstbase ::type node_algorithms; 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) {} @@ -742,7 +742,7 @@ class bstree_impl //! Effects: 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; } #ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED @@ -2186,46 +2186,46 @@ class bstree //Assert if passed value traits are compatible with the type BOOST_STATIC_ASSERT((detail::is_same::value)); - BOOST_INTRUSIVE_FORCEINLINE bstree() + inline bstree() : 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) {} template - 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 value_traits &v_traits = value_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)) {} - BOOST_INTRUSIVE_FORCEINLINE bstree& operator=(BOOST_RV_REF(bstree) x) + inline bstree& operator=(BOOST_RV_REF(bstree) x) { return static_cast(this->Base::operator=(BOOST_MOVE_BASE(Base, x))); } template - 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); } template - 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); } - 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(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(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(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(Base::container_from_iterator(it)); } }; diff --git a/include/boost/intrusive/bstree_algorithms.hpp b/include/boost/intrusive/bstree_algorithms.hpp index 5113a584..45e6b181 100644 --- a/include/boost/intrusive/bstree_algorithms.hpp +++ b/include/boost/intrusive/bstree_algorithms.hpp @@ -38,7 +38,7 @@ namespace intrusive { template struct insert_commit_data_t { - BOOST_INTRUSIVE_FORCEINLINE insert_commit_data_t() + inline insert_commit_data_t() : link_left(false), node() {} bool link_left; @@ -67,7 +67,7 @@ struct bstree_node_checker struct 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) {} @@ -76,7 +76,7 @@ struct bstree_node_checker 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) {} @@ -186,14 +186,14 @@ class bstree_algorithms : public bstree_algorithms_base template 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) {} - BOOST_INTRUSIVE_FORCEINLINE void release() + inline void release() { disposer_ = 0; } - BOOST_INTRUSIVE_FORCEINLINE ~dispose_subtree_disposer() + inline ~dispose_subtree_disposer() { if(disposer_){ dispose_subtree(subtree_, *disposer_); @@ -213,7 +213,7 @@ class bstree_algorithms : public bstree_algorithms_base //! Complexity: Constant time. //! //! Throws: 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); } //! Requires: 'header' is the header node of a tree. @@ -223,7 +223,7 @@ class bstree_algorithms : public bstree_algorithms_base //! Complexity: Constant time. //! //! Throws: 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); } //! Requires: 'header' is the header node of a tree. @@ -233,7 +233,7 @@ class bstree_algorithms : public bstree_algorithms_base //! Complexity: Constant time. //! //! Throws: 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); return p ? p : detail::uncast(header); @@ -247,7 +247,7 @@ class bstree_algorithms : public bstree_algorithms_base //! Complexity: Constant time. //! //! Throws: 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); } #if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) @@ -456,7 +456,7 @@ class bstree_algorithms : public bstree_algorithms_base //! new_node is not equivalent to node_to_be_replaced according to the //! ordering rules. This function is faster than erasing and inserting //! 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); } @@ -875,7 +875,7 @@ class bstree_algorithms : public bstree_algorithms_base //! //! Throws: If "comp" throws. template - BOOST_INTRUSIVE_FORCEINLINE static std::pair equal_range + inline static std::pair equal_range (const_node_ptr header, const KeyType &key, KeyNodePtrCompare comp) { return bounded_range(header, key, key, comp, true, true); @@ -919,7 +919,7 @@ class bstree_algorithms : public bstree_algorithms_base //! //! Throws: If "comp" throws. template - BOOST_INTRUSIVE_FORCEINLINE static node_ptr lower_bound + inline static node_ptr lower_bound (const_node_ptr header, const KeyType &key, KeyNodePtrCompare 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 //! //! Throws: If "comp" throws. template - BOOST_INTRUSIVE_FORCEINLINE static node_ptr upper_bound + inline static node_ptr upper_bound (const_node_ptr header, const KeyType &key, KeyNodePtrCompare 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 //! Notes: This function has only sense if a "insert_unique_check" has been //! previously executed to fill "commit_data". No value should be inserted or //! 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 { return insert_commit(header, new_value, commit_data); } @@ -1322,7 +1322,7 @@ class bstree_algorithms : public bstree_algorithms_base //! Complexity: Amortized constant time. //! //! Throws: 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; erase(header, z, ignored); @@ -1341,7 +1341,7 @@ class bstree_algorithms : public bstree_algorithms_base //! //! Throws: If the comparison throws. template - BOOST_INTRUSIVE_FORCEINLINE static bool transfer_unique + inline static bool transfer_unique (node_ptr header1, NodePtrCompare comp, node_ptr header2, node_ptr z) { data_for_rebalance ignored; @@ -1358,7 +1358,7 @@ class bstree_algorithms : public bstree_algorithms_base //! //! Throws: If the comparison throws. template - BOOST_INTRUSIVE_FORCEINLINE static void transfer_equal + inline static void transfer_equal (node_ptr header1, NodePtrCompare comp, node_ptr header2, node_ptr z) { data_for_rebalance ignored; @@ -1635,7 +1635,7 @@ class bstree_algorithms : public bstree_algorithms_base //! Complexity: Constant. //! //! Throws: 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; } //! Requires: p is a node of a tree. @@ -1645,7 +1645,7 @@ class bstree_algorithms : public bstree_algorithms_base //! Complexity: Constant. //! //! Throws: 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; } static void insert_before_check diff --git a/include/boost/intrusive/circular_list_algorithms.hpp b/include/boost/intrusive/circular_list_algorithms.hpp index ab34c7e3..2c99aa05 100644 --- a/include/boost/intrusive/circular_list_algorithms.hpp +++ b/include/boost/intrusive/circular_list_algorithms.hpp @@ -80,7 +80,7 @@ class circular_list_algorithms //! Complexity: Constant //! //! Throws: 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); } //! Effects: Constructs an empty list, making this_node the only @@ -102,7 +102,7 @@ class circular_list_algorithms //! Complexity: Constant //! //! Throws: 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; } diff --git a/include/boost/intrusive/circular_slist_algorithms.hpp b/include/boost/intrusive/circular_slist_algorithms.hpp index 5ce4e8cd..bc4beaa7 100644 --- a/include/boost/intrusive/circular_slist_algorithms.hpp +++ b/include/boost/intrusive/circular_slist_algorithms.hpp @@ -146,7 +146,7 @@ class circular_slist_algorithms //! Complexity: Constant //! //! Throws: 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); } //! Requires: 'p' is the first node of a list. @@ -156,7 +156,7 @@ class circular_slist_algorithms //! Complexity: Constant time. //! //! Throws: 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); } //! Effects: Returns true if this_node_points to an empty list. @@ -164,7 +164,7 @@ class circular_slist_algorithms //! Complexity: Constant //! //! Throws: 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; } //! Effects: Returns true if this_node points to a sentinel node. @@ -172,7 +172,7 @@ class circular_slist_algorithms //! Complexity: Constant //! //! Throws: 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(); } //! Effects: Marks this node as a "sentinel" node, a special state that is different from "empty", @@ -181,7 +181,7 @@ class circular_slist_algorithms //! Complexity: Constant //! //! Throws: 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()); } //! Requires: this_node and prev_init_node must be in the same circular list. @@ -193,7 +193,7 @@ class circular_slist_algorithms //! Complexity: Linear to the number of elements between prev_init_node and this_node. //! //! Throws: 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); } //! Requires: this_node must be in a circular list or be an empty circular list. @@ -203,7 +203,7 @@ class circular_slist_algorithms //! Complexity: Linear to the number of elements in the circular list. //! //! Throws: 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); } //! Requires: this_node must be in a circular list or be an empty circular list. @@ -213,7 +213,7 @@ class circular_slist_algorithms //! Complexity: Linear to the number of elements in the circular list. //! //! Throws: 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); } //! Requires: this_node and p must be in the same circular list. @@ -276,7 +276,7 @@ class circular_slist_algorithms //! Complexity: Linear to the number of elements in the circular list. //! //! Throws: 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); } //! Requires: this_node and other_node must be nodes inserted @@ -453,7 +453,7 @@ class circular_slist_algorithms //! //! Throws: Nothing. template - 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); } }; diff --git a/include/boost/intrusive/detail/any_node_and_algorithms.hpp b/include/boost/intrusive/detail/any_node_and_algorithms.hpp index 7949eecd..d216c5b1 100644 --- a/include/boost/intrusive/detail/any_node_and_algorithms.hpp +++ b/include/boost/intrusive/detail/any_node_and_algorithms.hpp @@ -252,7 +252,7 @@ class any_algorithms //! Throws: Nothing. //! //! Nodes: 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(); }; //! Effects: Returns true if 'n' is in the same state as if called init(node) @@ -260,10 +260,10 @@ class any_algorithms //! Complexity: Constant. //! //! Throws: Nothing. - BOOST_INTRUSIVE_FORCEINLINE static bool inited(const_node_ptr n) + inline static bool inited(const_node_ptr n) { 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; } static void unlink(node_ptr) diff --git a/include/boost/intrusive/detail/common_slist_algorithms.hpp b/include/boost/intrusive/detail/common_slist_algorithms.hpp index 8310231e..0965079b 100644 --- a/include/boost/intrusive/detail/common_slist_algorithms.hpp +++ b/include/boost/intrusive/detail/common_slist_algorithms.hpp @@ -52,7 +52,7 @@ class common_slist_algorithms 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()); } static bool unique(const_node_ptr this_node) BOOST_NOEXCEPT @@ -61,16 +61,16 @@ class common_slist_algorithms 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); } - 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)); 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); } static void link_after(node_ptr prev_node, node_ptr this_node) BOOST_NOEXCEPT @@ -216,7 +216,7 @@ class common_slist_algorithms //! //! Throws: Nothing. template - 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_traits::set_next(bb, node_traits::get_next(i)); diff --git a/include/boost/intrusive/detail/default_header_holder.hpp b/include/boost/intrusive/detail/default_header_holder.hpp index 42f35d2b..ba665e79 100644 --- a/include/boost/intrusive/detail/default_header_holder.hpp +++ b/include/boost/intrusive/detail/default_header_holder.hpp @@ -40,14 +40,14 @@ struct default_header_holder : public NodeTraits::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)); } - BOOST_INTRUSIVE_FORCEINLINE node_ptr get_node() + inline node_ptr get_node() { return pointer_traits< node_ptr >::pointer_to(*static_cast< node* >(this)); } // (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)); } }; diff --git a/include/boost/intrusive/detail/ebo_functor_holder.hpp b/include/boost/intrusive/detail/ebo_functor_holder.hpp index 88831667..1213112c 100644 --- a/include/boost/intrusive/detail/ebo_functor_holder.hpp +++ b/include/boost/intrusive/detail/ebo_functor_holder.hpp @@ -166,57 +166,57 @@ class ebo_functor_holder public: typedef T functor_type; - BOOST_INTRUSIVE_FORCEINLINE ebo_functor_holder() + inline ebo_functor_holder() : t_() {} - BOOST_INTRUSIVE_FORCEINLINE explicit ebo_functor_holder(const T &t) + inline explicit ebo_functor_holder(const 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)) {} template - 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), ::boost::forward(arg2)) {} - BOOST_INTRUSIVE_FORCEINLINE ebo_functor_holder(const ebo_functor_holder &x) + inline ebo_functor_holder(const ebo_functor_holder &x) : 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_) {} - 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(); 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()); return *this; } - BOOST_INTRUSIVE_FORCEINLINE ebo_functor_holder& operator=(const T &x) + inline ebo_functor_holder& operator=(const T &x) { this->get() = x; 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); return *this; } - BOOST_INTRUSIVE_FORCEINLINE T& get(){return t_;} - BOOST_INTRUSIVE_FORCEINLINE const T& get()const{return t_;} + inline T& get(){return t_;} + inline const T& get()const{return t_;} private: T t_; @@ -231,58 +231,58 @@ class ebo_functor_holder public: typedef T functor_type; - BOOST_INTRUSIVE_FORCEINLINE ebo_functor_holder() + inline ebo_functor_holder() : T() {} - BOOST_INTRUSIVE_FORCEINLINE explicit ebo_functor_holder(const T &t) + inline explicit ebo_functor_holder(const 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)) {} template - 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), ::boost::forward(arg2)) {} - BOOST_INTRUSIVE_FORCEINLINE ebo_functor_holder(const ebo_functor_holder &x) + inline ebo_functor_holder(const ebo_functor_holder &x) : T(static_cast(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)) {} - 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; this->get() = r; 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()); return *this; } - BOOST_INTRUSIVE_FORCEINLINE ebo_functor_holder& operator=(const T &x) + inline ebo_functor_holder& operator=(const T &x) { this->get() = x; 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); return *this; } - BOOST_INTRUSIVE_FORCEINLINE T& get(){return *this;} - BOOST_INTRUSIVE_FORCEINLINE const T& get()const{return *this;} + inline T& get(){return *this;} + inline const T& get()const{return *this;} }; } //namespace detail { diff --git a/include/boost/intrusive/detail/equal_to_value.hpp b/include/boost/intrusive/detail/equal_to_value.hpp index c5d9e530..48b1f411 100644 --- a/include/boost/intrusive/detail/equal_to_value.hpp +++ b/include/boost/intrusive/detail/equal_to_value.hpp @@ -39,7 +39,7 @@ class equal_to_value : t_(t) {} - BOOST_INTRUSIVE_FORCEINLINE bool operator()(ConstReference t)const + inline bool operator()(ConstReference t)const { return t_ == t; } }; diff --git a/include/boost/intrusive/detail/exception_disposer.hpp b/include/boost/intrusive/detail/exception_disposer.hpp index 0e21faeb..f76e8917 100644 --- a/include/boost/intrusive/detail/exception_disposer.hpp +++ b/include/boost/intrusive/detail/exception_disposer.hpp @@ -41,7 +41,7 @@ class exception_disposer : cont_(&cont), disp_(disp) {} - BOOST_INTRUSIVE_FORCEINLINE void release() + inline void release() { cont_ = 0; } ~exception_disposer() diff --git a/include/boost/intrusive/detail/generic_hook.hpp b/include/boost/intrusive/detail/generic_hook.hpp index 6e43f90d..acfc51aa 100644 --- a/include/boost/intrusive/detail/generic_hook.hpp +++ b/include/boost/intrusive/detail/generic_hook.hpp @@ -41,7 +41,7 @@ struct link_dispatch {}; template -BOOST_INTRUSIVE_FORCEINLINE void destructor_impl(Hook &hook, detail::link_dispatch) +inline void destructor_impl(Hook &hook, detail::link_dispatch) { //If this assertion raises, you might have destroyed an object //while it was still inserted in a container that is alive. //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 -BOOST_INTRUSIVE_FORCEINLINE void destructor_impl(Hook &hook, detail::link_dispatch) +inline void destructor_impl(Hook &hook, detail::link_dispatch) { hook.unlink(); } template -BOOST_INTRUSIVE_FORCEINLINE void destructor_impl(Hook &, detail::link_dispatch) +inline void destructor_impl(Hook &, detail::link_dispatch) {} } //namespace detail { @@ -161,52 +161,52 @@ class generic_hook < NodeTraits , Tag, LinkMode, BaseHookType> hooktags; - BOOST_INTRUSIVE_FORCEINLINE node_ptr this_ptr() BOOST_NOEXCEPT + inline node_ptr this_ptr() BOOST_NOEXCEPT { return pointer_traits::pointer_to(static_cast(*this)); } - BOOST_INTRUSIVE_FORCEINLINE const_node_ptr this_ptr() const BOOST_NOEXCEPT + inline const_node_ptr this_ptr() const BOOST_NOEXCEPT { return pointer_traits::pointer_to(static_cast(*this)); } public: /// @endcond - BOOST_INTRUSIVE_FORCEINLINE generic_hook() BOOST_NOEXCEPT + inline generic_hook() BOOST_NOEXCEPT { if(hooktags::safemode_or_autounlink){ 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){ 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; } - BOOST_INTRUSIVE_FORCEINLINE ~generic_hook() + inline ~generic_hook() { destructor_impl (*this, detail::link_dispatch()); } - BOOST_INTRUSIVE_FORCEINLINE void swap_nodes(generic_hook &other) BOOST_NOEXCEPT + inline void swap_nodes(generic_hook &other) BOOST_NOEXCEPT { node_algorithms::swap_nodes (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 BOOST_STATIC_ASSERT(( hooktags::safemode_or_autounlink )); 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 )); node_ptr n(this->this_ptr()); diff --git a/include/boost/intrusive/detail/hashtable_node.hpp b/include/boost/intrusive/detail/hashtable_node.hpp index 8e9a0625..26c84804 100644 --- a/include/boost/intrusive/detail/hashtable_node.hpp +++ b/include/boost/intrusive/detail/hashtable_node.hpp @@ -52,25 +52,25 @@ struct bucket_impl typedef detail::common_slist_algorithms algo_t; 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; } - BOOST_INTRUSIVE_FORCEINLINE node_ptr get_node_ptr() + inline node_ptr get_node_ptr() { return pointer_traits::pointer_to(*this); } - BOOST_INTRUSIVE_FORCEINLINE const_node_ptr get_node_ptr() const + inline const_node_ptr get_node_ptr() const { return pointer_traits::pointer_to(*this); } - BOOST_INTRUSIVE_FORCEINLINE node_ptr begin_ptr() + inline node_ptr begin_ptr() { return node_traits::get_next(get_node_ptr()); } }; @@ -136,7 +136,7 @@ class hashtable_iterator , hashtable_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:: pointer_to(static_cast(*p)); @@ -144,61 +144,61 @@ class hashtable_iterator public: - BOOST_INTRUSIVE_FORCEINLINE hashtable_iterator () + inline hashtable_iterator () : 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) , traitsptr_ (cont ? pointer_traits::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()) {} - 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()) {} - BOOST_INTRUSIVE_FORCEINLINE const siterator &slist_it() const + inline const siterator &slist_it() const { return slist_it_; } - BOOST_INTRUSIVE_FORCEINLINE hashtable_iterator unconst() const + inline hashtable_iterator unconst() const { return hashtable_iterator(this->slist_it(), this->get_bucket_value_traits()); } - BOOST_INTRUSIVE_FORCEINLINE hashtable_iterator& operator++() + inline hashtable_iterator& operator++() { 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; } - BOOST_INTRUSIVE_FORCEINLINE hashtable_iterator operator++(int) + inline hashtable_iterator operator++(int) { hashtable_iterator result (*this); this->increment(); 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_; } - 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); } - BOOST_INTRUSIVE_FORCEINLINE reference operator*() const + inline reference operator*() const { return *this->operator ->(); } - BOOST_INTRUSIVE_FORCEINLINE pointer operator->() const + inline pointer operator->() const { return this->priv_value_traits().to_value_ptr (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_; } - BOOST_INTRUSIVE_FORCEINLINE const value_traits &priv_value_traits() const + inline const value_traits &priv_value_traits() const { return traitsptr_->priv_value_traits(); } private: @@ -281,7 +281,7 @@ class hashtable_iterator , hashtable_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:: pointer_to(static_cast(*p)); @@ -289,67 +289,67 @@ class hashtable_iterator public: - BOOST_INTRUSIVE_FORCEINLINE hashtable_iterator () + inline hashtable_iterator () : slist_it_() //Value initialization to achieve "null iterators" (N3644) , 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) , 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()) {} - 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()) {} - BOOST_INTRUSIVE_FORCEINLINE const siterator &slist_it() const + inline const siterator &slist_it() const { return slist_it_; } - BOOST_INTRUSIVE_FORCEINLINE hashtable_iterator unconst() const + inline hashtable_iterator unconst() const { return hashtable_iterator(this->slist_it(), members_.nodeptr_, members_.get_ptr()); } - BOOST_INTRUSIVE_FORCEINLINE hashtable_iterator& operator++() + inline hashtable_iterator& operator++() { 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; } - BOOST_INTRUSIVE_FORCEINLINE hashtable_iterator operator++(int) + inline hashtable_iterator operator++(int) { hashtable_iterator result (*this); this->increment(); 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_; } - 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_; } - BOOST_INTRUSIVE_FORCEINLINE reference operator*() const + inline reference operator*() const { return *this->operator ->(); } - BOOST_INTRUSIVE_FORCEINLINE pointer operator->() const + inline pointer operator->() const { return this->operator_arrow(detail::bool_()); } - BOOST_INTRUSIVE_FORCEINLINE const_value_traits_ptr get_value_traits() const + inline const_value_traits_ptr get_value_traits() const { return members_.get_ptr(); } - BOOST_INTRUSIVE_FORCEINLINE bucket_ptr get_bucket_ptr() const + inline bucket_ptr get_bucket_ptr() const { return members_.nodeptr_; } 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())); } - 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())); } void increment() diff --git a/include/boost/intrusive/detail/hook_traits.hpp b/include/boost/intrusive/detail/hook_traits.hpp index 06713487..c33ede0d 100644 --- a/include/boost/intrusive/detail/hook_traits.hpp +++ b/include/boost/intrusive/detail/hook_traits.hpp @@ -28,7 +28,6 @@ #include #include #include -#include namespace boost { namespace intrusive { @@ -47,8 +46,6 @@ struct bhtraits_base template rebind_pointer::type pointer; typedef typename pointer_traits:: template rebind_pointer::type const_pointer; - //typedef typename pointer_traits::reference reference; - //typedef typename pointer_traits::reference const_reference; typedef T & reference; typedef const T & const_reference; typedef node_holder_type & node_holder_reference; @@ -56,35 +53,31 @@ struct bhtraits_base typedef node& 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_to (static_cast(static_cast(*n))); - BOOST_ASSERT(!!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::pointer_to (static_cast(static_cast(*n))); - BOOST_ASSERT(!!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::pointer_to (static_cast(static_cast(value))); - BOOST_ASSERT(!!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::pointer_to (static_cast(static_cast(value))); - BOOST_ASSERT(!!p); return p; } }; @@ -121,26 +114,26 @@ struct mhtraits 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::pointer_to (static_cast(static_cast(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::pointer_to (static_cast(static_cast(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_to (*detail::parent_from_member (static_cast(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::pointer_to (*detail::parent_from_member @@ -169,23 +162,23 @@ struct fhtraits typedef const value_type & const_reference; 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(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(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)); } - 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)); } 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(&*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(&*n)); } }; diff --git a/include/boost/intrusive/detail/iiterator.hpp b/include/boost/intrusive/detail/iiterator.hpp index 5ab1de2b..75b6d838 100644 --- a/include/boost/intrusive/detail/iiterator.hpp +++ b/include/boost/intrusive/detail/iiterator.hpp @@ -84,15 +84,15 @@ template struct iiterator_members { - BOOST_INTRUSIVE_FORCEINLINE iiterator_members() + inline iiterator_members() : 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) {} - BOOST_INTRUSIVE_FORCEINLINE StoredPointer get_ptr() const + inline StoredPointer get_ptr() const { return ptr_; } NodePtr nodeptr_; @@ -102,15 +102,15 @@ struct iiterator_members template struct iiterator_members { - BOOST_INTRUSIVE_FORCEINLINE iiterator_members() + inline iiterator_members() : 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) {} - BOOST_INTRUSIVE_FORCEINLINE StoredPointer get_ptr() const + inline StoredPointer get_ptr() const { return StoredPointer(); } NodePtr nodeptr_; diff --git a/include/boost/intrusive/detail/iterator.hpp b/include/boost/intrusive/detail/iterator.hpp index ec91cd4f..d0ca41c3 100644 --- a/include/boost/intrusive/detail/iterator.hpp +++ b/include/boost/intrusive/detail/iterator.hpp @@ -181,7 +181,7 @@ struct iterator_disable_if_tag_difference_type //////////////////// template -BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_tag::type +inline typename iterator_enable_if_tag::type iterator_advance(InputIt& it, typename iter_difference::type n) { while(n--) @@ -197,7 +197,7 @@ typename iterator_enable_if_tag::type } template -BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_tag::type +inline typename iterator_enable_if_tag::type iterator_advance(InputIt& it, typename iter_difference::type n) { for (; 0 < n; --n) @@ -207,14 +207,14 @@ BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_tag -BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_tag::type +inline typename iterator_enable_if_tag::type iterator_advance(InputIt& it, Distance n) { it += n; } template -BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_tag::type +inline typename iterator_enable_if_tag::type make_iterator_advance(InputIt it, Distance n) { (iterator_advance)(it, n); @@ -222,14 +222,14 @@ BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_tag -BOOST_INTRUSIVE_FORCEINLINE +inline void iterator_uadvance(It& it, typename iter_size::type n) { (iterator_advance)(it, (typename iterator_traits::difference_type)n); } template -BOOST_INTRUSIVE_FORCEINLINE +inline It make_iterator_uadvance(It it, typename iter_size::type n) { (iterator_uadvance)(it, n); @@ -253,7 +253,7 @@ typename iterator_disable_if_tag_difference_type } template -BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_tag_difference_type +inline typename iterator_enable_if_tag_difference_type ::type iterator_distance(InputIt first, InputIt last) { @@ -266,7 +266,7 @@ BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_tag_difference_type //////////////////////////////////////// template -BOOST_INTRUSIVE_FORCEINLINE typename iter_size::type +inline typename iter_size::type iterator_udistance(It first, It last) { return (typename iter_size::type)(iterator_distance)(first, last); @@ -277,14 +277,14 @@ BOOST_INTRUSIVE_FORCEINLINE typename iter_size::type //////////////////////////////////////// template -BOOST_INTRUSIVE_FORCEINLINE InputIt iterator_next(InputIt it, typename iter_difference::type n) +inline InputIt iterator_next(InputIt it, typename iter_difference::type n) { (iterator_advance)(it, n); return it; } template -BOOST_INTRUSIVE_FORCEINLINE InputIt iterator_unext(InputIt it, typename iterator_traits::size_type n) +inline InputIt iterator_unext(InputIt it, typename iterator_traits::size_type n) { (iterator_uadvance)(it, n); return it; @@ -295,11 +295,11 @@ BOOST_INTRUSIVE_FORCEINLINE InputIt iterator_unext(InputIt it, typename iterator //////////////////////////////////////// template -BOOST_INTRUSIVE_FORCEINLINE typename iterator_traits::pointer iterator_arrow_result(const I &i) +inline typename iterator_traits::pointer iterator_arrow_result(const I &i) { return i.operator->(); } template -BOOST_INTRUSIVE_FORCEINLINE T * iterator_arrow_result(T *p) +inline T * iterator_arrow_result(T *p) { return p; } } //namespace intrusive diff --git a/include/boost/intrusive/detail/key_nodeptr_comp.hpp b/include/boost/intrusive/detail/key_nodeptr_comp.hpp index 1029a340..4e7f7c27 100644 --- a/include/boost/intrusive/detail/key_nodeptr_comp.hpp +++ b/include/boost/intrusive/detail/key_nodeptr_comp.hpp @@ -78,40 +78,40 @@ struct key_nodeptr_comp static const bool value = same_type || is_convertible::value; }; - BOOST_INTRUSIVE_FORCEINLINE base_t base() const + inline base_t base() const { return static_cast(*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) {} //pred(pnode) template - BOOST_INTRUSIVE_FORCEINLINE bool operator()(const T1 &t1, typename enable_if_c< is_same_or_nodeptr_convertible::value, sfinae_type* >::type = 0) const + inline bool operator()(const T1 &t1, typename enable_if_c< is_same_or_nodeptr_convertible::value, sfinae_type* >::type = 0) const { return base().get()(key_of_value()(*traits_->to_value_ptr(t1))); } //operator() 2 arg //pred(pnode, pnode) template - BOOST_INTRUSIVE_FORCEINLINE bool operator() + inline bool operator() (const T1 &t1, const T2 &t2, typename enable_if_c< is_same_or_nodeptr_convertible::value && is_same_or_nodeptr_convertible::value, sfinae_type* >::type = 0) const { return base()(*traits_->to_value_ptr(t1), *traits_->to_value_ptr(t2)); } //pred(pnode, key) template - BOOST_INTRUSIVE_FORCEINLINE bool operator() + inline bool operator() (const T1 &t1, const T2 &t2, typename enable_if_c< is_same_or_nodeptr_convertible::value && !is_same_or_nodeptr_convertible::value, sfinae_type* >::type = 0) const { return base()(*traits_->to_value_ptr(t1), t2); } //pred(key, pnode) template - BOOST_INTRUSIVE_FORCEINLINE bool operator() + inline bool operator() (const T1 &t1, const T2 &t2, typename enable_if_c< !is_same_or_nodeptr_convertible::value && is_same_or_nodeptr_convertible::value, sfinae_type* >::type = 0) const { return base()(t1, *traits_->to_value_ptr(t2)); } //pred(key, key) template - BOOST_INTRUSIVE_FORCEINLINE bool operator() + inline bool operator() (const T1 &t1, const T2 &t2, typename enable_if_c< !is_same_or_nodeptr_convertible::value && !is_same_or_nodeptr_convertible::value, sfinae_type* >::type = 0) const { return base()(t1, t2); } diff --git a/include/boost/intrusive/detail/list_iterator.hpp b/include/boost/intrusive/detail/list_iterator.hpp index f301a4b8..0a10e848 100644 --- a/include/boost/intrusive/detail/list_iterator.hpp +++ b/include/boost/intrusive/detail/list_iterator.hpp @@ -60,81 +60,81 @@ class list_iterator typedef typename types_t::iterator_type::reference reference; 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) {} - BOOST_INTRUSIVE_FORCEINLINE list_iterator(const list_iterator &other) + inline list_iterator(const list_iterator &other) : 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()) {} - 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; } - BOOST_INTRUSIVE_FORCEINLINE node_ptr pointed_node() const + inline node_ptr pointed_node() const { return members_.nodeptr_; } - BOOST_INTRUSIVE_FORCEINLINE list_iterator &operator=(node_ptr nodeptr) + inline list_iterator &operator=(node_ptr nodeptr) { 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(); } public: - BOOST_INTRUSIVE_FORCEINLINE list_iterator& operator++() + inline list_iterator& operator++() { node_ptr p = node_traits::get_next(members_.nodeptr_); members_.nodeptr_ = p; return static_cast (*this); } - BOOST_INTRUSIVE_FORCEINLINE list_iterator operator++(int) + inline list_iterator operator++(int) { list_iterator result (*this); members_.nodeptr_ = node_traits::get_next(members_.nodeptr_); return result; } - BOOST_INTRUSIVE_FORCEINLINE list_iterator& operator--() + inline list_iterator& operator--() { members_.nodeptr_ = node_traits::get_previous(members_.nodeptr_); return static_cast (*this); } - BOOST_INTRUSIVE_FORCEINLINE list_iterator operator--(int) + inline list_iterator operator--(int) { list_iterator result (*this); members_.nodeptr_ = node_traits::get_previous(members_.nodeptr_); 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(); } - 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); } - BOOST_INTRUSIVE_FORCEINLINE reference operator*() const + inline reference operator*() const { return *operator->(); } - BOOST_INTRUSIVE_FORCEINLINE pointer operator->() const + inline pointer operator->() const { return this->operator_arrow(detail::bool_()); } - BOOST_INTRUSIVE_FORCEINLINE list_iterator unconst() const + inline list_iterator unconst() const { return list_iterator(this->pointed_node(), this->get_value_traits()); } private: - BOOST_INTRUSIVE_FORCEINLINE pointer operator_arrow(detail::false_) const + inline pointer operator_arrow(detail::false_) const { 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_); } iiterator_members members_; diff --git a/include/boost/intrusive/detail/node_cloner_disposer.hpp b/include/boost/intrusive/detail/node_cloner_disposer.hpp index 97e8d153..a836699f 100644 --- a/include/boost/intrusive/detail/node_cloner_disposer.hpp +++ b/include/boost/intrusive/detail/node_cloner_disposer.hpp @@ -59,7 +59,7 @@ struct node_cloner {} // 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); node_ptr n = traits_->to_node_ptr(*base_t::get()(v)); @@ -85,11 +85,11 @@ struct node_disposer static const bool safemode_or_autounlink = is_safe_autounlink::value; - BOOST_INTRUSIVE_FORCEINLINE node_disposer(F f, const ValueTraits *cont) + inline node_disposer(F f, const ValueTraits *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) node_algorithms::init(p); diff --git a/include/boost/intrusive/detail/simple_disposers.hpp b/include/boost/intrusive/detail/simple_disposers.hpp index 6b9bd4bc..41d2e247 100644 --- a/include/boost/intrusive/detail/simple_disposers.hpp +++ b/include/boost/intrusive/detail/simple_disposers.hpp @@ -41,7 +41,7 @@ class init_disposer typedef typename NodeAlgorithms::node_ptr node_ptr; public: - BOOST_INTRUSIVE_FORCEINLINE void operator()(node_ptr p) + inline void operator()(node_ptr p) { NodeAlgorithms::init(p); } }; diff --git a/include/boost/intrusive/detail/size_holder.hpp b/include/boost/intrusive/detail/size_holder.hpp index bd14dc50..ba5f418f 100644 --- a/include/boost/intrusive/detail/size_holder.hpp +++ b/include/boost/intrusive/detail/size_holder.hpp @@ -33,25 +33,25 @@ struct size_holder static const bool constant_time_size = ConstantSize; typedef SizeType size_type; - BOOST_INTRUSIVE_FORCEINLINE SizeType get_size() const + inline SizeType get_size() const { return size_; } - BOOST_INTRUSIVE_FORCEINLINE void set_size(SizeType size) + inline void set_size(SizeType size) { size_ = size; } - BOOST_INTRUSIVE_FORCEINLINE void decrement() + inline void decrement() { --size_; } - BOOST_INTRUSIVE_FORCEINLINE void increment() + inline void increment() { ++size_; } - BOOST_INTRUSIVE_FORCEINLINE void increase(SizeType n) + inline void increase(SizeType n) { size_ += n; } - BOOST_INTRUSIVE_FORCEINLINE void decrease(SizeType n) + inline void decrease(SizeType 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 size_; @@ -63,25 +63,25 @@ struct size_holder static const bool constant_time_size = false; typedef SizeType size_type; - BOOST_INTRUSIVE_FORCEINLINE size_type get_size() const + inline size_type get_size() const { 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{ diff --git a/include/boost/intrusive/detail/slist_iterator.hpp b/include/boost/intrusive/detail/slist_iterator.hpp index 9c5ee274..a87d0af8 100644 --- a/include/boost/intrusive/detail/slist_iterator.hpp +++ b/include/boost/intrusive/detail/slist_iterator.hpp @@ -63,75 +63,75 @@ class slist_iterator typedef typename types_t::iterator_type::reference reference; 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) {} - BOOST_INTRUSIVE_FORCEINLINE explicit slist_iterator(node_ptr nodeptr) + inline explicit slist_iterator(node_ptr nodeptr) : members_(nodeptr, const_value_traits_ptr()) { 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()) {} - BOOST_INTRUSIVE_FORCEINLINE slist_iterator(const nonconst_iterator &other) + inline slist_iterator(const nonconst_iterator &other) : 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; } - BOOST_INTRUSIVE_FORCEINLINE node_ptr pointed_node() const + inline node_ptr pointed_node() const { 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(*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(); } - BOOST_INTRUSIVE_FORCEINLINE bool operator!() const + inline bool operator!() const { return !members_.nodeptr_; } public: - BOOST_INTRUSIVE_FORCEINLINE slist_iterator& operator++() + inline slist_iterator& operator++() { members_.nodeptr_ = node_traits::get_next(members_.nodeptr_); return static_cast (*this); } - BOOST_INTRUSIVE_FORCEINLINE slist_iterator operator++(int) + inline slist_iterator operator++(int) { slist_iterator result (*this); members_.nodeptr_ = node_traits::get_next(members_.nodeptr_); 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(); } - 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(); } - BOOST_INTRUSIVE_FORCEINLINE reference operator*() const + inline reference operator*() const { return *operator->(); } - BOOST_INTRUSIVE_FORCEINLINE pointer operator->() const + inline pointer operator->() const { return this->operator_arrow(detail::bool_()); } - BOOST_INTRUSIVE_FORCEINLINE slist_iterator unconst() const + inline slist_iterator unconst() const { return slist_iterator(this->pointed_node(), this->get_value_traits()); } private: - BOOST_INTRUSIVE_FORCEINLINE pointer operator_arrow(detail::false_) const + inline pointer operator_arrow(detail::false_) const { 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_); } iiterator_members members_; diff --git a/include/boost/intrusive/detail/transform_iterator.hpp b/include/boost/intrusive/detail/transform_iterator.hpp index 0a715754..55131033 100644 --- a/include/boost/intrusive/detail/transform_iterator.hpp +++ b/include/boost/intrusive/detail/transform_iterator.hpp @@ -33,11 +33,11 @@ namespace detail { template struct operator_arrow_proxy { - BOOST_INTRUSIVE_FORCEINLINE operator_arrow_proxy(const PseudoReference &px) + inline operator_arrow_proxy(const PseudoReference &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-> // again automatically per 13.3.1.2 para 8 // operator T*() const { return &m_value; } @@ -47,11 +47,11 @@ struct operator_arrow_proxy template struct operator_arrow_proxy { - BOOST_INTRUSIVE_FORCEINLINE operator_arrow_proxy(T &px) + inline operator_arrow_proxy(T &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-> // again automatically per 13.3.1.2 para 8 // operator T*() const { return &m_value; } @@ -76,53 +76,53 @@ class transform_iterator : members_() {} - BOOST_INTRUSIVE_FORCEINLINE Iterator get_it() const + inline Iterator get_it() const { return members_.m_it; } //Constructors - BOOST_INTRUSIVE_FORCEINLINE transform_iterator& operator++() + inline transform_iterator& operator++() { increment(); return *this; } - BOOST_INTRUSIVE_FORCEINLINE transform_iterator operator++(int) + inline transform_iterator operator++(int) { transform_iterator result (*this); increment(); 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); } - 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); } - 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); } //Arithmetic transform_iterator& operator+=(typename Iterator::difference_type off) { 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); other.advance(off); 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; } - 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; } - 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); } - BOOST_INTRUSIVE_FORCEINLINE typename UnaryFunction::result_type operator*() const + inline typename UnaryFunction::result_type operator*() const { return dereference(); } - BOOST_INTRUSIVE_FORCEINLINE operator_arrow_proxy + inline operator_arrow_proxy operator->() const { return operator_arrow_proxy(dereference()); } @@ -130,27 +130,27 @@ class transform_iterator struct members : UnaryFunction { - BOOST_INTRUSIVE_FORCEINLINE members(const Iterator &it, const UnaryFunction &f) + inline members(const Iterator &it, const UnaryFunction &f) : UnaryFunction(f), m_it(it) {} - BOOST_INTRUSIVE_FORCEINLINE members() + inline members() {} Iterator m_it; } members_; - BOOST_INTRUSIVE_FORCEINLINE void increment() + inline void increment() { ++members_.m_it; } - BOOST_INTRUSIVE_FORCEINLINE void decrement() + inline void decrement() { --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; } - 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; } typename UnaryFunction::result_type dereference() const diff --git a/include/boost/intrusive/detail/tree_iterator.hpp b/include/boost/intrusive/detail/tree_iterator.hpp index ba1375f8..f97cecb3 100644 --- a/include/boost/intrusive/detail/tree_iterator.hpp +++ b/include/boost/intrusive/detail/tree_iterator.hpp @@ -68,32 +68,32 @@ class tree_iterator typedef typename types_t::iterator_type::reference reference; 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) {} - BOOST_INTRUSIVE_FORCEINLINE tree_iterator(const tree_iterator &other) + inline tree_iterator(const tree_iterator &other) : 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()) {} - 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; } - BOOST_INTRUSIVE_FORCEINLINE tree_iterator &operator=(node_ptr nodeptr) + inline tree_iterator &operator=(node_ptr nodeptr) { members_.nodeptr_ = nodeptr; return *this; } - BOOST_INTRUSIVE_FORCEINLINE node_ptr pointed_node() const + inline node_ptr pointed_node() const { return members_.nodeptr_; } public: - BOOST_INTRUSIVE_FORCEINLINE tree_iterator& operator++() + inline tree_iterator& operator++() { members_.nodeptr_ = node_algorithms::next_node(members_.nodeptr_); return *this; @@ -106,7 +106,7 @@ class tree_iterator return result; } - BOOST_INTRUSIVE_FORCEINLINE tree_iterator& operator--() + inline tree_iterator& operator--() { members_.nodeptr_ = node_algorithms::prev_node(members_.nodeptr_); return *this; @@ -119,43 +119,43 @@ class tree_iterator return result; } - BOOST_INTRUSIVE_FORCEINLINE tree_iterator& go_left() + inline tree_iterator& go_left() { members_.nodeptr_ = node_traits::get_left(members_.nodeptr_); return *this; } - BOOST_INTRUSIVE_FORCEINLINE tree_iterator& go_right() + inline tree_iterator& go_right() { members_.nodeptr_ = node_traits::get_right(members_.nodeptr_); return *this; } - BOOST_INTRUSIVE_FORCEINLINE tree_iterator& go_parent() + inline tree_iterator& go_parent() { members_.nodeptr_ = node_traits::get_parent(members_.nodeptr_); 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; } - BOOST_INTRUSIVE_FORCEINLINE bool operator! () const + inline bool operator! () const { 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(); } - 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); } - BOOST_INTRUSIVE_FORCEINLINE reference operator*() const + inline reference operator*() const { return *operator->(); } - BOOST_INTRUSIVE_FORCEINLINE pointer operator->() const + inline pointer operator->() const { return this->operator_arrow(detail::bool_()); } - BOOST_INTRUSIVE_FORCEINLINE const_value_traits_ptr get_value_traits() const + inline const_value_traits_ptr get_value_traits() const { return members_.get_ptr(); } tree_iterator end_iterator_from_it() const @@ -167,10 +167,10 @@ class tree_iterator { return tree_iterator(this->pointed_node(), this->get_value_traits()); } private: - BOOST_INTRUSIVE_FORCEINLINE pointer operator_arrow(detail::false_) const + inline pointer operator_arrow(detail::false_) const { 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_); } iiterator_members members_; diff --git a/include/boost/intrusive/detail/tree_value_compare.hpp b/include/boost/intrusive/detail/tree_value_compare.hpp index c78da0ac..d8b88f62 100644 --- a/include/boost/intrusive/detail/tree_value_compare.hpp +++ b/include/boost/intrusive/detail/tree_value_compare.hpp @@ -59,67 +59,67 @@ struct tree_value_compare typedef boost::intrusive::detail::ebo_functor_holder base_t; - BOOST_INTRUSIVE_FORCEINLINE tree_value_compare() + inline tree_value_compare() : 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) {} - 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()) {} - 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; } - 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; } - BOOST_INTRUSIVE_FORCEINLINE const key_compare &key_comp() const + inline const key_compare &key_comp() const { return static_cast(*this); } - BOOST_INTRUSIVE_FORCEINLINE Ret operator()(const key_type &key) const + inline Ret operator()(const key_type &key) const { 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)); } template - BOOST_INTRUSIVE_FORCEINLINE Ret operator()( const U &nonkey + inline Ret operator()( const U &nonkey , typename disable_if_smartref_to::type* = 0) const { 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); } - 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)); } - 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)); } - 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); } template - 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::type* = 0) const { return this->key_comp()(key1, nonkey2); } template - 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::type* = 0) const { return this->key_comp()(nonkey1, key2); } template - 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::type* = 0) const { return this->key_comp()(KeyOfValue()(value1), nonvalue2); } template - 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::type* = 0) const { return this->key_comp()(nonvalue1, KeyOfValue()(value2)); } }; @@ -137,45 +137,45 @@ struct tree_value_compare typedef boost::intrusive::detail::ebo_functor_holder base_t; - BOOST_INTRUSIVE_FORCEINLINE tree_value_compare() + inline tree_value_compare() : 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) {} - 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()) {} - 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; } - 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; } - BOOST_INTRUSIVE_FORCEINLINE const key_compare &key_comp() const + inline const key_compare &key_comp() const { return static_cast(*this); } - BOOST_INTRUSIVE_FORCEINLINE Ret operator()(const key_type &key) const + inline Ret operator()(const key_type &key) const { return this->key_comp()(key); } template - BOOST_INTRUSIVE_FORCEINLINE Ret operator()( const U &nonkey + inline Ret operator()( const U &nonkey , typename disable_if_smartref_to::type* = 0) const { 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); } template - 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::type* = 0) const { return this->key_comp()(key1, nonkey2); } template - 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::type* = 0) const { return this->key_comp()(nonkey1, key2); } }; diff --git a/include/boost/intrusive/hashtable.hpp b/include/boost/intrusive/hashtable.hpp index 688fb9b2..3baa4653 100644 --- a/include/boost/intrusive/hashtable.hpp +++ b/include/boost/intrusive/hashtable.hpp @@ -100,11 +100,11 @@ struct prime_list_holder private: template // sizeof(SizeType) < sizeof(std::size_t) - static BOOST_INTRUSIVE_FORCEINLINE SizeType truncate_size_type(std::size_t n, detail::true_) + static inline SizeType truncate_size_type(std::size_t n, detail::true_) { return n < std::size_t(SizeType(-1)) ? static_cast(n) : SizeType(-1); } template // sizeof(SizeType) == sizeof(std::size_t) - static BOOST_INTRUSIVE_FORCEINLINE SizeType truncate_size_type(std::size_t n, detail::false_) + static inline SizeType truncate_size_type(std::size_t n, detail::false_) { return static_cast(n); } static const std::size_t prime_list[]; @@ -139,30 +139,30 @@ struct prime_list_holder public: template - static BOOST_INTRUSIVE_FORCEINLINE SizeType suggested_upper_bucket_count(SizeType n) + static inline SizeType suggested_upper_bucket_count(SizeType n) { std::size_t const c = suggested_upper_bucket_count_impl(static_cast(n)); return truncate_size_type(c, detail::bool_<(sizeof(SizeType) < sizeof(std::size_t))>()); } template - static BOOST_INTRUSIVE_FORCEINLINE SizeType suggested_lower_bucket_count(SizeType n) + static inline SizeType suggested_lower_bucket_count(SizeType n) { std::size_t const c = suggested_lower_bucket_count_impl(static_cast(n)); return truncate_size_type(c, detail::bool_<(sizeof(SizeType) < sizeof(std::size_t))>()); } - static BOOST_INTRUSIVE_FORCEINLINE std::size_t suggested_lower_bucket_count_idx(std::size_t n) + static inline std::size_t suggested_lower_bucket_count_idx(std::size_t n) { return static_cast(suggested_lower_bucket_count_ptr(n) - &prime_list[0]); } - static BOOST_INTRUSIVE_FORCEINLINE std::size_t suggested_upper_bucket_count_idx(std::size_t n) + static inline std::size_t suggested_upper_bucket_count_idx(std::size_t n) { return static_cast(suggested_upper_bucket_count_ptr(n) - &prime_list[0]); } - static BOOST_INTRUSIVE_FORCEINLINE std::size_t size_from_index(std::size_t n) + static inline std::size_t size_from_index(std::size_t n) { return prime_list[std::ptrdiff_t(n)]; } template - BOOST_INTRUSIVE_FORCEINLINE static std::size_t modfunc(std::size_t hash) { return hash % SizeIndex; } + inline static std::size_t modfunc(std::size_t hash) { return hash % SizeIndex; } static std::size_t(*const positions[])(std::size_t); @@ -171,19 +171,19 @@ struct prime_list_holder static const std::size_t inv_sizes32_size; #endif - BOOST_INTRUSIVE_FORCEINLINE static std::size_t lower_size_index(std::size_t n) + inline static std::size_t lower_size_index(std::size_t n) { return prime_list_holder<>::suggested_lower_bucket_count_idx(n); } - BOOST_INTRUSIVE_FORCEINLINE static std::size_t upper_size_index(std::size_t n) + inline static std::size_t upper_size_index(std::size_t n) { return prime_list_holder<>::suggested_upper_bucket_count_idx(n); } - BOOST_INTRUSIVE_FORCEINLINE static std::size_t size(std::size_t size_index) + inline static std::size_t size(std::size_t size_index) { return prime_list_holder<>::size_from_index(size_index); } #if BOOST_INTRUSIVE_64_BIT_SIZE_T // https://github.com/lemire/fastmod - BOOST_INTRUSIVE_FORCEINLINE static uint64_t mul128_u32(uint64_t lowbits, uint32_t d) + inline static uint64_t mul128_u32(uint64_t lowbits, uint32_t d) { #if defined(_MSC_VER) return __umulh(lowbits, d); @@ -197,14 +197,14 @@ struct prime_list_holder #endif } - BOOST_INTRUSIVE_FORCEINLINE static uint32_t fastmod_u32(uint32_t a, uint64_t M, uint32_t d) + inline static uint32_t fastmod_u32(uint32_t a, uint64_t M, uint32_t d) { uint64_t lowbits = M * a; return (uint32_t)(mul128_u32(lowbits, d)); } #endif // BOOST_INTRUSIVE_64_BIT_SIZE_T - BOOST_INTRUSIVE_FORCEINLINE static std::size_t position(std::size_t hash,std::size_t size_index) + inline static std::size_t position(std::size_t hash,std::size_t size_index) { #if BOOST_INTRUSIVE_64_BIT_SIZE_T BOOST_CONSTEXPR_OR_CONST std::size_t sizes_under_32bit = sizeof(inv_sizes32)/sizeof(inv_sizes32[0]); @@ -453,7 +453,7 @@ class exception_bucket_disposer : cont_(&cont), disp_(disp), constructed_(constructed) {} - BOOST_INTRUSIVE_FORCEINLINE void release() + inline void release() { cont_ = 0; } ~exception_bucket_disposer() @@ -502,37 +502,37 @@ struct bucket_traits_impl /// @endcond - BOOST_INTRUSIVE_FORCEINLINE bucket_traits_impl(bucket_ptr buckets, size_type len) + inline bucket_traits_impl(bucket_ptr buckets, size_type len) : buckets_(buckets), buckets_len_(len) {} - BOOST_INTRUSIVE_FORCEINLINE bucket_traits_impl(const bucket_traits_impl& x) + inline bucket_traits_impl(const bucket_traits_impl& x) : buckets_(x.buckets_), buckets_len_(x.buckets_len_) {} - BOOST_INTRUSIVE_FORCEINLINE bucket_traits_impl(BOOST_RV_REF(bucket_traits_impl) x) + inline bucket_traits_impl(BOOST_RV_REF(bucket_traits_impl) x) : buckets_(x.buckets_), buckets_len_(x.buckets_len_) { x.buckets_ = bucket_ptr(); x.buckets_len_ = 0u; } - BOOST_INTRUSIVE_FORCEINLINE bucket_traits_impl& operator=(BOOST_RV_REF(bucket_traits_impl) x) + inline bucket_traits_impl& operator=(BOOST_RV_REF(bucket_traits_impl) x) { buckets_ = x.buckets_; buckets_len_ = x.buckets_len_; x.buckets_ = bucket_ptr(); x.buckets_len_ = 0u; return *this; } - BOOST_INTRUSIVE_FORCEINLINE bucket_traits_impl& operator=(BOOST_COPY_ASSIGN_REF(bucket_traits_impl) x) + inline bucket_traits_impl& operator=(BOOST_COPY_ASSIGN_REF(bucket_traits_impl) x) { buckets_ = x.buckets_; buckets_len_ = x.buckets_len_; return *this; } - BOOST_INTRUSIVE_FORCEINLINE bucket_ptr bucket_begin() const + inline bucket_ptr bucket_begin() const { return buckets_; } - BOOST_INTRUSIVE_FORCEINLINE size_type bucket_count() const BOOST_NOEXCEPT + inline size_type bucket_count() const BOOST_NOEXCEPT { return buckets_len_; } @@ -568,10 +568,10 @@ struct insert_commit_data_impl { std::size_t hash; std::size_t bucket_idx; - BOOST_INTRUSIVE_FORCEINLINE std::size_t get_hash() const + inline std::size_t get_hash() const { return hash; } - BOOST_INTRUSIVE_FORCEINLINE void set_hash(std::size_t h) + inline void set_hash(std::size_t h) { hash = h; } }; @@ -579,15 +579,15 @@ template<> struct insert_commit_data_impl { std::size_t bucket_idx; - BOOST_INTRUSIVE_FORCEINLINE std::size_t get_hash() const + inline std::size_t get_hash() const { return 0U; } - BOOST_INTRUSIVE_FORCEINLINE void set_hash(std::size_t) + inline void set_hash(std::size_t) {} }; template -BOOST_INTRUSIVE_FORCEINLINE typename pointer_traits::template rebind_pointer::type +inline typename pointer_traits::template rebind_pointer::type dcast_bucket_ptr(const SlistNodePtr &p) { typedef typename pointer_traits::template rebind_pointer::type node_ptr; @@ -689,13 +689,13 @@ struct group_functions } } - BOOST_INTRUSIVE_FORCEINLINE static void erase_from_group(slist_node_ptr, node_ptr, detail::false_) + inline static void erase_from_group(slist_node_ptr, node_ptr, detail::false_) {} - BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_last_in_group(node_ptr first_in_group, detail::true_) + inline static node_ptr get_last_in_group(node_ptr first_in_group, detail::true_) { return group_traits::get_next(first_in_group); } - BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_last_in_group(node_ptr n, detail::false_) + inline static node_ptr get_last_in_group(node_ptr n, detail::false_) { return n; } static node_ptr get_first_in_group(node_ptr n, detail::true_) @@ -707,17 +707,17 @@ struct group_functions return n; } - BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_first_in_group(node_ptr n, detail::false_) + inline static node_ptr get_first_in_group(node_ptr n, detail::false_) { return n; } - BOOST_INTRUSIVE_FORCEINLINE static bool is_first_in_group(node_ptr ptr) + inline static bool is_first_in_group(node_ptr ptr) { return node_traits::get_next(group_traits::get_next(ptr)) != ptr; } - BOOST_INTRUSIVE_FORCEINLINE static void insert_in_group(node_ptr first_in_group, node_ptr n, detail::true_) + inline static void insert_in_group(node_ptr first_in_group, node_ptr n, detail::true_) { group_algorithms::link_after(first_in_group, n); } - BOOST_INTRUSIVE_FORCEINLINE static void insert_in_group(node_ptr, node_ptr, detail::false_) + inline static void insert_in_group(node_ptr, node_ptr, detail::false_) {} //Splits a group in two groups, and makes "new_first" the first node in the second group. @@ -753,7 +753,7 @@ class incremental_rehash_rollback , split_traits_(split_tr), released_(false) {} - BOOST_INTRUSIVE_FORCEINLINE void release() + inline void release() { released_ = true; } ~incremental_rehash_rollback() @@ -776,21 +776,21 @@ class incremental_rehash_rollback template struct node_functions { - BOOST_INTRUSIVE_FORCEINLINE static void store_hash(typename NodeTraits::node_ptr p, std::size_t h, detail::true_) + inline static void store_hash(typename NodeTraits::node_ptr p, std::size_t h, detail::true_) { return NodeTraits::set_hash(p, h); } - BOOST_INTRUSIVE_FORCEINLINE static void store_hash(typename NodeTraits::node_ptr, std::size_t, detail::false_) + inline static void store_hash(typename NodeTraits::node_ptr, std::size_t, detail::false_) {} }; -BOOST_INTRUSIVE_FORCEINLINE std::size_t hash_to_bucket(std::size_t hash_value, std::size_t bucket_cnt, detail::false_) +inline std::size_t hash_to_bucket(std::size_t hash_value, std::size_t bucket_cnt, detail::false_) { return hash_value % bucket_cnt; } -BOOST_INTRUSIVE_FORCEINLINE std::size_t hash_to_bucket(std::size_t hash_value, std::size_t bucket_cnt, detail::true_) +inline std::size_t hash_to_bucket(std::size_t hash_value, std::size_t bucket_cnt, detail::true_) { return hash_value & (bucket_cnt - 1); } template //!fastmod_buckets -BOOST_INTRUSIVE_FORCEINLINE std::size_t hash_to_bucket_split(std::size_t hash_value, std::size_t bucket_cnt, std::size_t split, detail::false_) +inline std::size_t hash_to_bucket_split(std::size_t hash_value, std::size_t bucket_cnt, std::size_t split, detail::false_) { std::size_t bucket_number = hash_to_bucket(hash_value, bucket_cnt, detail::bool_()); BOOST_IF_CONSTEXPR(Incremental) @@ -799,7 +799,7 @@ BOOST_INTRUSIVE_FORCEINLINE std::size_t hash_to_bucket_split(std::size_t hash_va } template //fastmod_buckets -BOOST_INTRUSIVE_FORCEINLINE std::size_t hash_to_bucket_split(std::size_t hash_value, std::size_t , std::size_t split, detail::true_) +inline std::size_t hash_to_bucket_split(std::size_t hash_value, std::size_t , std::size_t split, detail::true_) { return prime_fmod_size::position(hash_value, split); } @@ -886,11 +886,11 @@ struct downcast_node_to_value_t template rebind_pointer ::type const_value_traits_ptr; - BOOST_INTRUSIVE_FORCEINLINE downcast_node_to_value_t(const_value_traits_ptr ptr) + inline downcast_node_to_value_t(const_value_traits_ptr ptr) : base_t(ptr) {} - BOOST_INTRUSIVE_FORCEINLINE result_type operator()(first_argument_type arg) const + inline result_type operator()(first_argument_type arg) const { return this->base_t::operator()(static_cast(arg)); } }; @@ -905,14 +905,14 @@ struct node_cast_adaptor typedef typename pointer_traits::element_type node; template - BOOST_INTRUSIVE_FORCEINLINE node_cast_adaptor(const ConvertibleToF &c2f, const RealValuTraits *traits) + inline node_cast_adaptor(const ConvertibleToF &c2f, const RealValuTraits *traits) : base_t(base_t(c2f, traits)) {} - BOOST_INTRUSIVE_FORCEINLINE typename base_t::node_ptr operator()(const slist_node &to_clone) + inline typename base_t::node_ptr operator()(const slist_node &to_clone) { return base_t::operator()(static_cast(to_clone)); } - BOOST_INTRUSIVE_FORCEINLINE void operator()(SlistNodePtr to_clone) + inline void operator()(SlistNodePtr to_clone) { base_t::operator()(pointer_traits::pointer_to(static_cast(*to_clone))); } @@ -935,11 +935,11 @@ struct bucket_plus_vtraits BOOST_MOVABLE_BUT_NOT_COPYABLE(data_type) public: - BOOST_INTRUSIVE_FORCEINLINE data_type(const ValueTraits& val_traits, const BucketTraits& b_traits) + inline data_type(const ValueTraits& val_traits, const BucketTraits& b_traits) : ValueTraits(val_traits), BucketTraits(b_traits) {} - BOOST_INTRUSIVE_FORCEINLINE data_type(BOOST_RV_REF(data_type) other) + inline data_type(BOOST_RV_REF(data_type) other) : ValueTraits (BOOST_MOVE_BASE(ValueTraits, other)) , BucketTraits(BOOST_MOVE_BASE(BucketTraits, other)) {} @@ -994,49 +994,49 @@ struct bucket_plus_vtraits static const std::size_t bucket_overhead = LinearBuckets ? 1u : 0u; - BOOST_INTRUSIVE_FORCEINLINE bucket_plus_vtraits(const ValueTraits &val_traits, const bucket_traits &b_traits) + inline bucket_plus_vtraits(const ValueTraits &val_traits, const bucket_traits &b_traits) : m_data(val_traits, b_traits) {} - BOOST_INTRUSIVE_FORCEINLINE bucket_plus_vtraits(BOOST_RV_REF(bucket_plus_vtraits) other) + inline bucket_plus_vtraits(BOOST_RV_REF(bucket_plus_vtraits) other) : m_data(boost::move(((bucket_plus_vtraits&)other).m_data)) {} - 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::pointer_to(this->priv_value_traits()); } //bucket_value_traits // - BOOST_INTRUSIVE_FORCEINLINE const bucket_plus_vtraits &get_bucket_value_traits() const + inline const bucket_plus_vtraits &get_bucket_value_traits() const { return *this; } - BOOST_INTRUSIVE_FORCEINLINE bucket_plus_vtraits &get_bucket_value_traits() + inline bucket_plus_vtraits &get_bucket_value_traits() { return *this; } - BOOST_INTRUSIVE_FORCEINLINE const_bucket_value_traits_ptr bucket_value_traits_ptr() const + inline const_bucket_value_traits_ptr bucket_value_traits_ptr() const { return pointer_traits::pointer_to(this->get_bucket_value_traits()); } //value traits // - BOOST_INTRUSIVE_FORCEINLINE const value_traits &priv_value_traits() const + inline const value_traits &priv_value_traits() const { return static_cast(this->m_data); } - BOOST_INTRUSIVE_FORCEINLINE value_traits &priv_value_traits() + inline value_traits &priv_value_traits() { return static_cast(this->m_data); } //value traits // - BOOST_INTRUSIVE_FORCEINLINE const bucket_traits &priv_bucket_traits() const + inline const bucket_traits &priv_bucket_traits() const { return static_cast(this->m_data); } - BOOST_INTRUSIVE_FORCEINLINE bucket_traits& priv_bucket_traits() + inline bucket_traits& priv_bucket_traits() { return static_cast(this->m_data); } //bucket operations - BOOST_INTRUSIVE_FORCEINLINE bucket_ptr priv_bucket_pointer() const BOOST_NOEXCEPT + inline bucket_ptr priv_bucket_pointer() const BOOST_NOEXCEPT { return this->priv_bucket_traits().bucket_begin(); } - BOOST_INTRUSIVE_FORCEINLINE std::size_t priv_usable_bucket_count() const BOOST_NOEXCEPT + inline std::size_t priv_usable_bucket_count() const BOOST_NOEXCEPT { BOOST_IF_CONSTEXPR(bucket_overhead){ const std::size_t n = this->priv_bucket_traits().bucket_count(); @@ -1047,19 +1047,19 @@ struct bucket_plus_vtraits } } - BOOST_INTRUSIVE_FORCEINLINE bucket_type &priv_bucket(std::size_t n) const BOOST_NOEXCEPT + inline bucket_type &priv_bucket(std::size_t n) const BOOST_NOEXCEPT { BOOST_INTRUSIVE_INVARIANT_ASSERT(n < this->priv_usable_bucket_count()); return this->priv_bucket_pointer()[std::ptrdiff_t(n)]; } - BOOST_INTRUSIVE_FORCEINLINE bucket_ptr priv_bucket_ptr(std::size_t n) const BOOST_NOEXCEPT + inline bucket_ptr priv_bucket_ptr(std::size_t n) const BOOST_NOEXCEPT { return pointer_traits::pointer_to(this->priv_bucket(n)); } - BOOST_INTRUSIVE_FORCEINLINE bucket_ptr priv_past_usable_bucket_ptr() const + inline bucket_ptr priv_past_usable_bucket_ptr() const { return this->priv_bucket_pointer() + std::ptrdiff_t(priv_usable_bucket_count()); } - BOOST_INTRUSIVE_FORCEINLINE bucket_ptr priv_invalid_bucket_ptr() const + inline bucket_ptr priv_invalid_bucket_ptr() const { BOOST_IF_CONSTEXPR(LinearBuckets) { return bucket_ptr(); @@ -1069,7 +1069,7 @@ struct bucket_plus_vtraits } } - BOOST_INTRUSIVE_FORCEINLINE void priv_set_sentinel_bucket() const + inline void priv_set_sentinel_bucket() const { BOOST_IF_CONSTEXPR(LinearBuckets) { BOOST_INTRUSIVE_INVARIANT_ASSERT(this->priv_bucket_traits().bucket_count() > 1); @@ -1078,7 +1078,7 @@ struct bucket_plus_vtraits } } - BOOST_INTRUSIVE_FORCEINLINE void priv_unset_sentinel_bucket() const + inline void priv_unset_sentinel_bucket() const { BOOST_IF_CONSTEXPR(LinearBuckets) { BOOST_INTRUSIVE_INVARIANT_ASSERT(this->priv_bucket_traits().bucket_count() > 1); @@ -1087,46 +1087,46 @@ struct bucket_plus_vtraits } } - BOOST_INTRUSIVE_FORCEINLINE siterator priv_end_sit() const + inline siterator priv_end_sit() const { return priv_end_sit(linear_buckets_t()); } - BOOST_INTRUSIVE_FORCEINLINE siterator priv_end_sit(detail::true_) const + inline siterator priv_end_sit(detail::true_) const { return siterator(this->priv_bucket_pointer() + std::ptrdiff_t(this->priv_bucket_traits().bucket_count() - bucket_overhead)); } - BOOST_INTRUSIVE_FORCEINLINE siterator priv_end_sit(detail::false_) const + inline siterator priv_end_sit(detail::false_) const { return siterator(this->priv_bucket_pointer()->get_node_ptr()); } - BOOST_INTRUSIVE_FORCEINLINE siterator priv_bucket_lbegin(std::size_t n) const + inline siterator priv_bucket_lbegin(std::size_t n) const { siterator s(this->priv_bucket_lbbegin(n)); return ++s; } - BOOST_INTRUSIVE_FORCEINLINE siterator priv_bucket_lbbegin(std::size_t n) const + inline siterator priv_bucket_lbbegin(std::size_t n) const { return this->sit_bbegin(this->priv_bucket(n)); } - BOOST_INTRUSIVE_FORCEINLINE siterator priv_bucket_lend(std::size_t n) const + inline siterator priv_bucket_lend(std::size_t n) const { return this->sit_end(this->priv_bucket(n)); } - BOOST_INTRUSIVE_FORCEINLINE std::size_t priv_bucket_size(std::size_t n) const + inline std::size_t priv_bucket_size(std::size_t n) const { return slist_node_algorithms::count(this->priv_bucket(n).get_node_ptr())-1u; } - BOOST_INTRUSIVE_FORCEINLINE bool priv_bucket_empty(std::size_t n) const + inline bool priv_bucket_empty(std::size_t n) const { return slist_node_algorithms::is_empty(this->priv_bucket(n).get_node_ptr()); } - BOOST_INTRUSIVE_FORCEINLINE bool priv_bucket_empty(bucket_ptr p) const + inline bool priv_bucket_empty(bucket_ptr p) const { return slist_node_algorithms::is_empty(p->get_node_ptr()); } - static BOOST_INTRUSIVE_FORCEINLINE siterator priv_bucket_lbegin(bucket_type &b) + static inline siterator priv_bucket_lbegin(bucket_type &b) { return siterator(slist_node_traits::get_next(b.get_node_ptr())); } - static BOOST_INTRUSIVE_FORCEINLINE siterator priv_bucket_lbbegin(bucket_type& b) + static inline siterator priv_bucket_lbbegin(bucket_type& b) { return siterator(b.get_node_ptr()); } - static BOOST_INTRUSIVE_FORCEINLINE siterator priv_bucket_lend(bucket_type& b) + static inline siterator priv_bucket_lend(bucket_type& b) { return siterator(slist_node_algorithms::end_node(b.get_node_ptr())); } - static BOOST_INTRUSIVE_FORCEINLINE std::size_t priv_bucket_size(const bucket_type& b) + static inline std::size_t priv_bucket_size(const bucket_type& b) { return slist_node_algorithms::count(b.get_node_ptr())-1u; } - static BOOST_INTRUSIVE_FORCEINLINE bool priv_bucket_empty(const bucket_type& b) + static inline bool priv_bucket_empty(const bucket_type& b) { return slist_node_algorithms::is_empty(b.get_node_ptr()); } template @@ -1206,7 +1206,7 @@ struct bucket_plus_vtraits } template - BOOST_INTRUSIVE_FORCEINLINE static void priv_erase_node(bucket_type &b, siterator i, NodeDisposer node_disposer, detail::false_) //!optimize multikey + inline static void priv_erase_node(bucket_type &b, siterator i, NodeDisposer node_disposer, detail::false_) //!optimize multikey { slist_node_ptr bi = slist_node_algorithms::get_previous_node(b.get_node_ptr(), i.pointed_node()); slist_node_algorithms::unlink_after_and_dispose(bi, node_disposer); @@ -1252,14 +1252,14 @@ struct bucket_plus_vtraits return siterator(last_node_group); } - BOOST_INTRUSIVE_FORCEINLINE static siterator priv_get_last(bucket_type &b, detail::false_) //NOT optimize multikey + inline static siterator priv_get_last(bucket_type &b, detail::false_) //NOT optimize multikey { slist_node_ptr p = b.get_node_ptr(); return siterator(slist_node_algorithms::get_previous_node(p, slist_node_algorithms::end_node(p))); } template - static BOOST_INTRUSIVE_FORCEINLINE std::size_t priv_erase_whole_bucket(bucket_type &b, NodeDisposer node_disposer) + static inline std::size_t priv_erase_whole_bucket(bucket_type &b, NodeDisposer node_disposer) { return slist_node_algorithms::detach_and_dispose(b.get_node_ptr(), node_disposer); } static siterator priv_get_previous(bucket_type &b, siterator i, detail::true_) //optimize multikey @@ -1274,7 +1274,7 @@ struct bucket_plus_vtraits return siterator(n); } - BOOST_INTRUSIVE_FORCEINLINE static siterator priv_get_previous(bucket_type &b, siterator i, detail::false_) //NOT optimize multikey + inline static siterator priv_get_previous(bucket_type &b, siterator i, detail::false_) //NOT optimize multikey { return siterator(slist_node_algorithms::get_previous_node(b.get_node_ptr(), i.pointed_node())); } template @@ -1286,47 +1286,47 @@ struct bucket_plus_vtraits }; template - BOOST_INTRUSIVE_FORCEINLINE typename typeof_node_disposer::type + inline typename typeof_node_disposer::type make_node_disposer(const Disposer &disposer) const { typedef typename typeof_node_disposer::type return_t; return return_t(disposer, &this->priv_value_traits()); } - static BOOST_INTRUSIVE_FORCEINLINE bucket_ptr to_ptr(bucket_type &b) + static inline bucket_ptr to_ptr(bucket_type &b) { return pointer_traits::pointer_to(b); } - static BOOST_INTRUSIVE_FORCEINLINE siterator sit_bbegin(bucket_type& b) + static inline siterator sit_bbegin(bucket_type& b) { return siterator(b.get_node_ptr()); } - static BOOST_INTRUSIVE_FORCEINLINE siterator sit_begin(bucket_type& b) + static inline siterator sit_begin(bucket_type& b) { return siterator(b.begin_ptr()); } - static BOOST_INTRUSIVE_FORCEINLINE siterator sit_end(bucket_type& b) + static inline siterator sit_end(bucket_type& b) { return siterator(slist_node_algorithms::end_node(b.get_node_ptr())); } - BOOST_INTRUSIVE_FORCEINLINE static std::size_t priv_stored_hash(siterator s, detail::true_) //store_hash + inline static std::size_t priv_stored_hash(siterator s, detail::true_) //store_hash { return node_traits::get_hash(dcast_bucket_ptr(s.pointed_node())); } - BOOST_INTRUSIVE_FORCEINLINE static std::size_t priv_stored_hash(siterator, detail::false_) //NO store_hash + inline static std::size_t priv_stored_hash(siterator, detail::false_) //NO store_hash { return std::size_t(-1); } - BOOST_INTRUSIVE_FORCEINLINE node &priv_value_to_node(reference v) + inline node &priv_value_to_node(reference v) { return *this->priv_value_traits().to_node_ptr(v); } - BOOST_INTRUSIVE_FORCEINLINE const node &priv_value_to_node(const_reference v) const + inline const node &priv_value_to_node(const_reference v) const { return *this->priv_value_traits().to_node_ptr(v); } - BOOST_INTRUSIVE_FORCEINLINE node_ptr priv_value_to_node_ptr(reference v) + inline node_ptr priv_value_to_node_ptr(reference v) { return this->priv_value_traits().to_node_ptr(v); } - BOOST_INTRUSIVE_FORCEINLINE const_node_ptr priv_value_to_node_ptr(const_reference v) const + inline const_node_ptr priv_value_to_node_ptr(const_reference v) const { return this->priv_value_traits().to_node_ptr(v); } - BOOST_INTRUSIVE_FORCEINLINE reference priv_value_from_siterator(siterator s) + inline reference priv_value_from_siterator(siterator s) { return *this->priv_value_traits().to_value_ptr(dcast_bucket_ptr(s.pointed_node())); } - BOOST_INTRUSIVE_FORCEINLINE const_reference priv_value_from_siterator(siterator s) const + inline const_reference priv_value_from_siterator(siterator s) const { return *this->priv_value_traits().to_value_ptr(dcast_bucket_ptr(s.pointed_node())); } static void priv_init_buckets(const bucket_ptr buckets_ptr, const std::size_t bucket_cnt) @@ -1351,37 +1351,37 @@ struct bucket_plus_vtraits } } - BOOST_INTRUSIVE_FORCEINLINE std::size_t priv_stored_or_compute_hash(const value_type &v, detail::true_) const //For store_hash == true + inline std::size_t priv_stored_or_compute_hash(const value_type &v, detail::true_) const //For store_hash == true { return node_traits::get_hash(this->priv_value_traits().to_node_ptr(v)); } typedef hashtable_iterator iterator; typedef hashtable_iterator const_iterator; - BOOST_INTRUSIVE_FORCEINLINE iterator end() BOOST_NOEXCEPT + inline iterator end() BOOST_NOEXCEPT { return this->build_iterator(this->priv_end_sit(), bucket_ptr()); } - BOOST_INTRUSIVE_FORCEINLINE const_iterator end() const BOOST_NOEXCEPT + inline const_iterator end() const BOOST_NOEXCEPT { return this->cend(); } - BOOST_INTRUSIVE_FORCEINLINE const_iterator cend() const BOOST_NOEXCEPT + inline const_iterator cend() const BOOST_NOEXCEPT { return this->build_const_iterator(this->priv_end_sit(), bucket_ptr()); } - BOOST_INTRUSIVE_FORCEINLINE iterator build_iterator(siterator s, bucket_ptr p) + inline iterator build_iterator(siterator s, bucket_ptr p) { return this->build_iterator(s, p, linear_buckets_t()); } - BOOST_INTRUSIVE_FORCEINLINE iterator build_iterator(siterator s, bucket_ptr p, detail::true_) //linear buckets + inline iterator build_iterator(siterator s, bucket_ptr p, detail::true_) //linear buckets { return iterator(s, p, this->priv_value_traits_ptr()); } - BOOST_INTRUSIVE_FORCEINLINE iterator build_iterator(siterator s, bucket_ptr, detail::false_) //!linear buckets + inline iterator build_iterator(siterator s, bucket_ptr, detail::false_) //!linear buckets { return iterator(s, &this->get_bucket_value_traits()); } - BOOST_INTRUSIVE_FORCEINLINE const_iterator build_const_iterator(siterator s, bucket_ptr p) const + inline const_iterator build_const_iterator(siterator s, bucket_ptr p) const { return this->build_const_iterator(s, p, linear_buckets_t()); } - BOOST_INTRUSIVE_FORCEINLINE const_iterator build_const_iterator(siterator s, bucket_ptr p, detail::true_) const //linear buckets + inline const_iterator build_const_iterator(siterator s, bucket_ptr p, detail::true_) const //linear buckets { return const_iterator(s, p, this->priv_value_traits_ptr()); } - BOOST_INTRUSIVE_FORCEINLINE const_iterator build_const_iterator(siterator s, bucket_ptr, detail::false_) const //!linear buckets + inline const_iterator build_const_iterator(siterator s, bucket_ptr, detail::false_) const //!linear buckets { return const_iterator(s, &this->get_bucket_value_traits()); } }; @@ -1477,29 +1477,29 @@ struct bucket_hash_t typedef bucket_plus_vtraits bucket_plus_vtraits_t; typedef detail::ebo_functor_holder base_t; - BOOST_INTRUSIVE_FORCEINLINE bucket_hash_t(const ValueTraits &val_traits, const bucket_traits &b_traits, const hasher & h) + inline bucket_hash_t(const ValueTraits &val_traits, const bucket_traits &b_traits, const hasher & h) : base_t(h) , bucket_plus_vtraits_t(val_traits, b_traits) {} - BOOST_INTRUSIVE_FORCEINLINE bucket_hash_t(BOOST_RV_REF(bucket_hash_t) other) + inline bucket_hash_t(BOOST_RV_REF(bucket_hash_t) other) : base_t(BOOST_MOVE_BASE(base_t, other)) , bucket_plus_vtraits_t(BOOST_MOVE_BASE(bucket_plus_vtraits_t, other)) {} template - BOOST_INTRUSIVE_FORCEINLINE std::size_t priv_hash(const K &k) const + inline std::size_t priv_hash(const K &k) const { return this->base_t::operator()(k); } - BOOST_INTRUSIVE_FORCEINLINE const hasher &priv_hasher() const + inline const hasher &priv_hasher() const { return this->base_t::get(); } - BOOST_INTRUSIVE_FORCEINLINE hasher &priv_hasher() + inline hasher &priv_hasher() { return this->base_t::get(); } using bucket_plus_vtraits_t::priv_stored_or_compute_hash; //For store_hash == true - BOOST_INTRUSIVE_FORCEINLINE std::size_t priv_stored_or_compute_hash(const value_type &v, detail::false_) const //For store_hash == false + inline std::size_t priv_stored_or_compute_hash(const value_type &v, detail::false_) const //For store_hash == false { return this->priv_hasher()(key_of_value()(v)); } }; @@ -1553,27 +1553,27 @@ struct bucket_hash_equal_t , equal_holder_t(e) {} - BOOST_INTRUSIVE_FORCEINLINE bucket_hash_equal_t(BOOST_RV_REF(bucket_hash_equal_t) other) + inline bucket_hash_equal_t(BOOST_RV_REF(bucket_hash_equal_t) other) : bucket_hash_type(BOOST_MOVE_BASE(bucket_hash_type, other)) , equal_holder_t(BOOST_MOVE_BASE(equal_holder_t, other)) {} - BOOST_INTRUSIVE_FORCEINLINE bucket_ptr priv_get_cache() + inline bucket_ptr priv_get_cache() { return this->priv_bucket_pointer(); } - BOOST_INTRUSIVE_FORCEINLINE void priv_set_cache(bucket_ptr) + inline void priv_set_cache(bucket_ptr) {} - BOOST_INTRUSIVE_FORCEINLINE void priv_set_cache_bucket_num(std::size_t) + inline void priv_set_cache_bucket_num(std::size_t) {} - BOOST_INTRUSIVE_FORCEINLINE std::size_t priv_get_cache_bucket_num() + inline std::size_t priv_get_cache_bucket_num() { return 0u; } - BOOST_INTRUSIVE_FORCEINLINE void priv_init_cache() + inline void priv_init_cache() {} - BOOST_INTRUSIVE_FORCEINLINE void priv_swap_cache(bucket_hash_equal_t &) + inline void priv_swap_cache(bucket_hash_equal_t &) {} siterator priv_begin(bucket_ptr &pbucketptr) const @@ -1591,22 +1591,22 @@ struct bucket_hash_equal_t return this->priv_end_sit(); } - BOOST_INTRUSIVE_FORCEINLINE void priv_insertion_update_cache(std::size_t) + inline void priv_insertion_update_cache(std::size_t) {} - BOOST_INTRUSIVE_FORCEINLINE void priv_erasure_update_cache_range(std::size_t, std::size_t) + inline void priv_erasure_update_cache_range(std::size_t, std::size_t) {} - BOOST_INTRUSIVE_FORCEINLINE void priv_erasure_update_cache(bucket_ptr) + inline void priv_erasure_update_cache(bucket_ptr) {} - BOOST_INTRUSIVE_FORCEINLINE void priv_erasure_update_cache() + inline void priv_erasure_update_cache() {} - BOOST_INTRUSIVE_FORCEINLINE const key_equal &priv_equal() const + inline const key_equal &priv_equal() const { return this->equal_holder_t::get(); } - BOOST_INTRUSIVE_FORCEINLINE key_equal &priv_equal() + inline key_equal &priv_equal() { return this->equal_holder_t::get(); } }; @@ -1645,7 +1645,7 @@ struct bucket_hash_equal_t::type bucket_ptr; - BOOST_INTRUSIVE_FORCEINLINE bucket_ptr priv_get_cache() const + inline bucket_ptr priv_get_cache() const { return cached_begin_; } - BOOST_INTRUSIVE_FORCEINLINE void priv_set_cache(bucket_ptr p) + inline void priv_set_cache(bucket_ptr p) { cached_begin_ = p; } - BOOST_INTRUSIVE_FORCEINLINE void priv_set_cache_bucket_num(std::size_t insertion_bucket) + inline void priv_set_cache_bucket_num(std::size_t insertion_bucket) { BOOST_INTRUSIVE_INVARIANT_ASSERT(insertion_bucket <= this->priv_usable_bucket_count()); this->cached_begin_ = this->priv_bucket_pointer() + std::ptrdiff_t(insertion_bucket); } - BOOST_INTRUSIVE_FORCEINLINE std::size_t priv_get_cache_bucket_num() + inline std::size_t priv_get_cache_bucket_num() { return std::size_t(this->cached_begin_ - this->priv_bucket_pointer()); } - BOOST_INTRUSIVE_FORCEINLINE void priv_init_cache() + inline void priv_init_cache() { this->cached_begin_ = this->priv_past_usable_bucket_ptr(); } - BOOST_INTRUSIVE_FORCEINLINE void priv_swap_cache(bucket_hash_equal_t &other) + inline void priv_swap_cache(bucket_hash_equal_t &other) { ::boost::adl_move_swap(this->cached_begin_, other.cached_begin_); } siterator priv_begin(bucket_ptr& pbucketptr) const @@ -1694,10 +1694,10 @@ struct bucket_hash_equal_tequal_holder_t::get(); } - BOOST_INTRUSIVE_FORCEINLINE key_equal &priv_equal() + inline key_equal &priv_equal() { return this->equal_holder_t::get(); } void priv_erasure_update_cache_range(std::size_t first_bucket_num, std::size_t last_bucket_num) @@ -1756,7 +1756,7 @@ struct hashtable_size_wrapper {} typedef detail::size_holder < true, SizeType> size_traits;//size_traits - BOOST_INTRUSIVE_FORCEINLINE hashtable_size_wrapper(BOOST_RV_REF(hashtable_size_wrapper) other) + inline hashtable_size_wrapper(BOOST_RV_REF(hashtable_size_wrapper) other) : DeriveFrom(BOOST_MOVE_BASE(DeriveFrom, other)) {} @@ -1765,19 +1765,19 @@ struct hashtable_size_wrapper typedef const size_traits & size_traits_const_t; typedef size_traits & size_traits_t; - BOOST_INTRUSIVE_FORCEINLINE SizeType get_hashtable_size_wrapper_size() const + inline SizeType get_hashtable_size_wrapper_size() const { return size_traits_.get_size(); } - BOOST_INTRUSIVE_FORCEINLINE void set_hashtable_size_wrapper_size(SizeType s) + inline void set_hashtable_size_wrapper_size(SizeType s) { size_traits_.set_size(s); } - BOOST_INTRUSIVE_FORCEINLINE void inc_hashtable_size_wrapper_size() + inline void inc_hashtable_size_wrapper_size() { size_traits_.increment(); } - BOOST_INTRUSIVE_FORCEINLINE void dec_hashtable_size_wrapper_size() + inline void dec_hashtable_size_wrapper_size() { size_traits_.decrement(); } - BOOST_INTRUSIVE_FORCEINLINE size_traits_t priv_size_traits() + inline size_traits_t priv_size_traits() { return size_traits_; } }; @@ -1798,7 +1798,7 @@ struct hashtable_size_wrapper , ::boost::forward(arg2)) {} - BOOST_INTRUSIVE_FORCEINLINE hashtable_size_wrapper(BOOST_RV_REF(hashtable_size_wrapper) other) + inline hashtable_size_wrapper(BOOST_RV_REF(hashtable_size_wrapper) other) : DeriveFrom(BOOST_MOVE_BASE(DeriveFrom, other)) {} @@ -1807,19 +1807,19 @@ struct hashtable_size_wrapper typedef size_traits size_traits_const_t; typedef size_traits size_traits_t; - BOOST_INTRUSIVE_FORCEINLINE SizeType get_hashtable_size_wrapper_size() const + inline SizeType get_hashtable_size_wrapper_size() const { return 0u; } - BOOST_INTRUSIVE_FORCEINLINE void set_hashtable_size_wrapper_size(SizeType) + inline void set_hashtable_size_wrapper_size(SizeType) {} - BOOST_INTRUSIVE_FORCEINLINE void inc_hashtable_size_wrapper_size() + inline void inc_hashtable_size_wrapper_size() {} - BOOST_INTRUSIVE_FORCEINLINE void dec_hashtable_size_wrapper_size() + inline void dec_hashtable_size_wrapper_size() {} - BOOST_INTRUSIVE_FORCEINLINE size_traits priv_size_traits() + inline size_traits priv_size_traits() { return size_traits(); } }; @@ -1908,11 +1908,11 @@ struct hashdata_internal : split_bucket_hash_equal_t(val_traits, b_traits, h, e) {} - BOOST_INTRUSIVE_FORCEINLINE hashdata_internal(BOOST_RV_REF(hashdata_internal) other) + inline hashdata_internal(BOOST_RV_REF(hashdata_internal) other) : split_bucket_hash_equal_t(BOOST_MOVE_BASE(split_bucket_hash_equal_t, other)) {} - BOOST_INTRUSIVE_FORCEINLINE typename split_bucket_hash_equal_t::size_traits_t priv_split_traits() + inline typename split_bucket_hash_equal_t::size_traits_t priv_split_traits() { return this->priv_size_traits(); } ~hashdata_internal() @@ -1942,20 +1942,20 @@ struct hashdata_internal typedef typename bucket_plus_vtraits_t::const_iterator const_iterator; //public functions - BOOST_INTRUSIVE_FORCEINLINE SizeType split_count() const BOOST_NOEXCEPT + inline SizeType split_count() const BOOST_NOEXCEPT { return this->split_bucket_hash_equal_t::get_hashtable_size_wrapper_size(); } - BOOST_INTRUSIVE_FORCEINLINE void split_count(SizeType s) BOOST_NOEXCEPT + inline void split_count(SizeType s) BOOST_NOEXCEPT { this->split_bucket_hash_equal_t::set_hashtable_size_wrapper_size(s); } //public functions - BOOST_INTRUSIVE_FORCEINLINE void inc_split_count() BOOST_NOEXCEPT + inline void inc_split_count() BOOST_NOEXCEPT { this->split_bucket_hash_equal_t::inc_hashtable_size_wrapper_size(); } - BOOST_INTRUSIVE_FORCEINLINE void dec_split_count() BOOST_NOEXCEPT + inline void dec_split_count() BOOST_NOEXCEPT { this->split_bucket_hash_equal_t::dec_hashtable_size_wrapper_size(); } - BOOST_INTRUSIVE_FORCEINLINE static SizeType initial_split_from_bucket_count(SizeType bc) BOOST_NOEXCEPT + inline static SizeType initial_split_from_bucket_count(SizeType bc) BOOST_NOEXCEPT { BOOST_IF_CONSTEXPR(fastmod_buckets) { size_type split; @@ -1975,7 +1975,7 @@ struct hashdata_internal } } - BOOST_INTRUSIVE_FORCEINLINE static SizeType rehash_split_from_bucket_count(SizeType bc) BOOST_NOEXCEPT + inline static SizeType rehash_split_from_bucket_count(SizeType bc) BOOST_NOEXCEPT { BOOST_IF_CONSTEXPR(fastmod_buckets) { return (initial_split_from_bucket_count)(bc); @@ -1991,7 +1991,7 @@ struct hashdata_internal } } - BOOST_INTRUSIVE_FORCEINLINE iterator iterator_to(reference value) BOOST_NOEXCEPT_IF(!linear_buckets) + inline iterator iterator_to(reference value) BOOST_NOEXCEPT_IF(!linear_buckets) { return iterator_to(value, linear_buckets_t()); } const_iterator iterator_to(const_reference value) const BOOST_NOEXCEPT_IF(!linear_buckets) @@ -2019,25 +2019,25 @@ struct hashdata_internal typedef detail::bool_ fastmod_buckets_t; - BOOST_INTRUSIVE_FORCEINLINE bucket_type &priv_hash_to_bucket(std::size_t hash_value) const + inline bucket_type &priv_hash_to_bucket(std::size_t hash_value) const { return this->priv_bucket(this->priv_hash_to_nbucket(hash_value)); } - BOOST_INTRUSIVE_FORCEINLINE bucket_ptr priv_hash_to_bucket_ptr(std::size_t hash_value) const + inline bucket_ptr priv_hash_to_bucket_ptr(std::size_t hash_value) const { return this->priv_bucket_ptr(this->priv_hash_to_nbucket(hash_value)); } - BOOST_INTRUSIVE_FORCEINLINE size_type priv_hash_to_nbucket(std::size_t hash_value) const + inline size_type priv_hash_to_nbucket(std::size_t hash_value) const { return (priv_hash_to_nbucket)(hash_value, fastmod_buckets_t()); } - BOOST_INTRUSIVE_FORCEINLINE size_type priv_hash_to_nbucket(std::size_t hash_value, detail::true_) const //fastmod_buckets_t + inline size_type priv_hash_to_nbucket(std::size_t hash_value, detail::true_) const //fastmod_buckets_t { return static_cast(prime_fmod_size::position(hash_value, this->split_count())); } - BOOST_INTRUSIVE_FORCEINLINE size_type priv_hash_to_nbucket(std::size_t hash_value, detail::false_) const //!fastmod_buckets_t + inline size_type priv_hash_to_nbucket(std::size_t hash_value, detail::false_) const //!fastmod_buckets_t { return static_cast(hash_to_bucket_split (hash_value, this->priv_usable_bucket_count(), this->split_count(), detail::false_())); } - BOOST_INTRUSIVE_FORCEINLINE iterator iterator_to(reference value, detail::false_) BOOST_NOEXCEPT + inline iterator iterator_to(reference value, detail::false_) BOOST_NOEXCEPT { return iterator( siterator(this->priv_value_to_node_ptr(value)) , &this->get_bucket_value_traits()); @@ -2081,22 +2081,22 @@ struct hashdata_internal return const_local_iterator(sit, this->priv_value_traits_ptr()); } - BOOST_INTRUSIVE_FORCEINLINE size_type bucket_count() const BOOST_NOEXCEPT + inline size_type bucket_count() const BOOST_NOEXCEPT { return size_type(this->priv_usable_bucket_count()); } - BOOST_INTRUSIVE_FORCEINLINE size_type bucket_size(size_type n) const BOOST_NOEXCEPT + inline size_type bucket_size(size_type n) const BOOST_NOEXCEPT { return (size_type)this->priv_bucket_size(n); } - BOOST_INTRUSIVE_FORCEINLINE bucket_ptr bucket_pointer() const BOOST_NOEXCEPT + inline bucket_ptr bucket_pointer() const BOOST_NOEXCEPT { return this->priv_bucket_pointer(); } - BOOST_INTRUSIVE_FORCEINLINE local_iterator begin(size_type n) BOOST_NOEXCEPT + inline local_iterator begin(size_type n) BOOST_NOEXCEPT { return local_iterator(this->priv_bucket_lbegin(n), this->priv_value_traits_ptr()); } - BOOST_INTRUSIVE_FORCEINLINE const_local_iterator begin(size_type n) const BOOST_NOEXCEPT + inline const_local_iterator begin(size_type n) const BOOST_NOEXCEPT { return this->cbegin(n); } - static BOOST_INTRUSIVE_FORCEINLINE size_type suggested_upper_bucket_count(size_type n) BOOST_NOEXCEPT + static inline size_type suggested_upper_bucket_count(size_type n) BOOST_NOEXCEPT { BOOST_IF_CONSTEXPR(fastmod_buckets){ std::size_t s = prime_fmod_size::upper_size_index(n); @@ -2107,7 +2107,7 @@ struct hashdata_internal } } - static BOOST_INTRUSIVE_FORCEINLINE size_type suggested_lower_bucket_count(size_type n) BOOST_NOEXCEPT + static inline size_type suggested_lower_bucket_count(size_type n) BOOST_NOEXCEPT { BOOST_IF_CONSTEXPR(fastmod_buckets){ std::size_t s = prime_fmod_size::lower_size_index(n); @@ -2131,7 +2131,7 @@ struct hashdata_internal local_iterator end(size_type n) BOOST_NOEXCEPT { return local_iterator(this->priv_bucket_lend(n), this->priv_value_traits_ptr()); } - BOOST_INTRUSIVE_FORCEINLINE const_local_iterator end(size_type n) const BOOST_NOEXCEPT + inline const_local_iterator end(size_type n) const BOOST_NOEXCEPT { return this->cend(n); } const_local_iterator cend(size_type n) const BOOST_NOEXCEPT @@ -2143,27 +2143,27 @@ struct hashdata_internal //Public functions for hashtable_impl - BOOST_INTRUSIVE_FORCEINLINE iterator begin() BOOST_NOEXCEPT + inline iterator begin() BOOST_NOEXCEPT { bucket_ptr p; siterator s = this->priv_begin(p); return this->build_iterator(s, p); } - BOOST_INTRUSIVE_FORCEINLINE const_iterator begin() const BOOST_NOEXCEPT + inline const_iterator begin() const BOOST_NOEXCEPT { return this->cbegin(); } - BOOST_INTRUSIVE_FORCEINLINE const_iterator cbegin() const BOOST_NOEXCEPT + inline const_iterator cbegin() const BOOST_NOEXCEPT { bucket_ptr p; siterator s = this->priv_begin(p); return this->build_const_iterator(s, p); } - BOOST_INTRUSIVE_FORCEINLINE hasher hash_function() const + inline hasher hash_function() const { return this->priv_hasher(); } - BOOST_INTRUSIVE_FORCEINLINE key_equal key_eq() const + inline key_equal key_eq() const { return this->priv_equal(); } }; @@ -2378,16 +2378,16 @@ class hashtable_impl this->split_count(this->initial_split_from_bucket_count(bucket_sz)); } - BOOST_INTRUSIVE_FORCEINLINE SizeType priv_size_count() const BOOST_NOEXCEPT + inline SizeType priv_size_count() const BOOST_NOEXCEPT { return this->internal_type::get_hashtable_size_wrapper_size(); } - BOOST_INTRUSIVE_FORCEINLINE void priv_size_count(SizeType s) BOOST_NOEXCEPT + inline void priv_size_count(SizeType s) BOOST_NOEXCEPT { this->internal_type::set_hashtable_size_wrapper_size(s); } - BOOST_INTRUSIVE_FORCEINLINE void priv_size_inc() BOOST_NOEXCEPT + inline void priv_size_inc() BOOST_NOEXCEPT { this->internal_type::inc_hashtable_size_wrapper_size(); } - BOOST_INTRUSIVE_FORCEINLINE void priv_size_dec() BOOST_NOEXCEPT + inline void priv_size_dec() BOOST_NOEXCEPT { this->internal_type::dec_hashtable_size_wrapper_size(); } public: @@ -2635,7 +2635,7 @@ class hashtable_impl //! Throws: If cloner or hasher throw or hash or equality predicate copying //! throws. Basic guarantee. template - BOOST_INTRUSIVE_FORCEINLINE void clone_from(const hashtable_impl &src, Cloner cloner, Disposer disposer) + inline void clone_from(const hashtable_impl &src, Cloner cloner, Disposer disposer) { this->priv_clone_from(src, cloner, disposer); } //! Requires: Disposer::operator()(pointer) shouldn't throw @@ -2658,7 +2658,7 @@ class hashtable_impl //! Throws: If cloner or hasher throw or hash or equality predicate copying //! throws. Basic guarantee. template - BOOST_INTRUSIVE_FORCEINLINE void clone_from(BOOST_RV_REF(hashtable_impl) src, Cloner cloner, Disposer disposer) + inline void clone_from(BOOST_RV_REF(hashtable_impl) src, Cloner cloner, Disposer disposer) { this->priv_clone_from(static_cast(src), cloner, disposer); } //! Requires: value must be an lvalue @@ -2828,7 +2828,7 @@ class hashtable_impl //! objects are inserted or erased from the unordered_set. //! //! After a successful rehashing insert_commit_data remains valid. - BOOST_INTRUSIVE_FORCEINLINE std::pair insert_unique_check + inline std::pair insert_unique_check ( const key_type &key, insert_commit_data &commit_data) { return this->insert_unique_check(key, this->priv_hasher(), this->priv_equal(), commit_data); } @@ -2872,7 +2872,7 @@ class hashtable_impl //! //! Note: Invalidates the iterators (but not the references) //! to the erased element. No destructors are called. - BOOST_INTRUSIVE_FORCEINLINE void erase(const_iterator i) BOOST_NOEXCEPT + inline void erase(const_iterator i) BOOST_NOEXCEPT { this->erase_and_dispose(i, detail::null_disposer()); } //! Effects: Erases the range pointed to by b end e. @@ -2884,7 +2884,7 @@ class hashtable_impl //! //! Note: Invalidates the iterators (but not the references) //! to the erased elements. No destructors are called. - BOOST_INTRUSIVE_FORCEINLINE void erase(const_iterator b, const_iterator e) BOOST_NOEXCEPT + inline void erase(const_iterator b, const_iterator e) BOOST_NOEXCEPT { this->erase_and_dispose(b, e, detail::null_disposer()); } //! Effects: Erases all the elements with the given value. @@ -2899,7 +2899,7 @@ class hashtable_impl //! //! Note: Invalidates the iterators (but not the references) //! to the erased elements. No destructors are called. - BOOST_INTRUSIVE_FORCEINLINE size_type erase(const key_type &key) + inline size_type erase(const key_type &key) { return this->erase(key, this->priv_hasher(), this->priv_equal()); } //! Requires: "hash_func" must be a hash function that induces @@ -2923,7 +2923,7 @@ class hashtable_impl //! Note: Invalidates the iterators (but not the references) //! to the erased elements. No destructors are called. template - BOOST_INTRUSIVE_FORCEINLINE size_type erase(const KeyType& key, KeyHasher hash_func, KeyEqual equal_func) + inline size_type erase(const KeyType& key, KeyHasher hash_func, KeyEqual equal_func) { return this->erase_and_dispose(key, hash_func, equal_func, detail::null_disposer()); } //! Requires: Disposer::operator()(pointer) shouldn't throw. @@ -3007,7 +3007,7 @@ class hashtable_impl //! Note: Invalidates the iterators (but not the references) //! to the erased elements. No destructors are called. template - BOOST_INTRUSIVE_FORCEINLINE size_type erase_and_dispose(const key_type &key, Disposer disposer) + inline size_type erase_and_dispose(const key_type &key, Disposer disposer) { return this->erase_and_dispose(key, this->priv_hasher(), this->priv_equal(), disposer); } //! Requires: Disposer::operator()(pointer) shouldn't throw. @@ -3110,7 +3110,7 @@ class hashtable_impl //! Complexity: Average case O(1), worst case O(this->size()). //! //! Throws: If the internal hasher or the equality functor throws. - BOOST_INTRUSIVE_FORCEINLINE size_type count(const key_type &key) const + inline size_type count(const key_type &key) const { return this->count(key, this->priv_hasher(), this->priv_equal()); } //! Requires: "hash_func" must be a hash function that induces @@ -3141,7 +3141,7 @@ class hashtable_impl //! Complexity: Average case O(1), worst case O(this->size()). //! //! Throws: If the internal hasher or the equality functor throws. - BOOST_INTRUSIVE_FORCEINLINE iterator find(const key_type &key) + inline iterator find(const key_type &key) { return this->find(key, this->priv_hasher(), this->priv_equal()); } //! Requires: "hash_func" must be a hash function that induces @@ -3178,7 +3178,7 @@ class hashtable_impl //! Complexity: Average case O(1), worst case O(this->size()). //! //! Throws: If the internal hasher or the equality functor throws. - 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->priv_hasher(), this->priv_equal()); } //! Requires: "hash_func" must be a hash function that induces @@ -3217,7 +3217,7 @@ class hashtable_impl //! Complexity: Average case O(this->count(value)). Worst case O(this->size()). //! //! Throws: If the internal hasher or the equality functor throws. - BOOST_INTRUSIVE_FORCEINLINE std::pair equal_range(const key_type &key) + inline std::pair equal_range(const key_type &key) { return this->equal_range(key, this->priv_hasher(), this->priv_equal()); } //! Requires: "hash_func" must be a hash function that induces @@ -3258,7 +3258,7 @@ class hashtable_impl //! Complexity: Average case O(this->count(value)). Worst case O(this->size()). //! //! Throws: If the internal hasher or the equality functor throws. - BOOST_INTRUSIVE_FORCEINLINE std::pair + inline std::pair equal_range(const key_type &key) const { return this->equal_range(key, this->priv_hasher(), this->priv_equal()); } @@ -3393,7 +3393,7 @@ class hashtable_impl //! Throws: If the hash functor throws. //! //! Note: the return value is in the range [0, this->bucket_count()). - BOOST_INTRUSIVE_FORCEINLINE size_type bucket(const key_type& k) const + inline size_type bucket(const key_type& k) const { return this->priv_hash_to_nbucket(this->priv_hash(k)); } //! Requires: "hash_func" must be a hash function that induces @@ -3409,7 +3409,7 @@ class hashtable_impl //! //! Note: the return value is in the range [0, this->bucket_count()). template - BOOST_INTRUSIVE_FORCEINLINE size_type bucket(const KeyType& k, KeyHasher hash_func) const + inline size_type bucket(const KeyType& k, KeyHasher hash_func) const { return this->priv_hash_to_nbucket(hash_func(k)); } #if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) @@ -3527,7 +3527,7 @@ class hashtable_impl //! Complexity: Average case linear in this->size(), worst case quadratic. //! //! Throws: If the hasher functor throws. Basic guarantee. - BOOST_INTRUSIVE_FORCEINLINE void rehash(const bucket_traits &new_bucket_traits) + inline void rehash(const bucket_traits &new_bucket_traits) { this->priv_rehash_impl(new_bucket_traits, false); } //! Note: This function is used when keys from inserted elements are changed @@ -3550,7 +3550,7 @@ class hashtable_impl //! Complexity: Average case linear in this->size(), worst case quadratic. //! //! Throws: If the hasher functor throws. Basic guarantee. - BOOST_INTRUSIVE_FORCEINLINE void full_rehash() + inline void full_rehash() { this->priv_rehash_impl(this->priv_bucket_traits(), true); } //! Requires: @@ -3748,7 +3748,7 @@ class hashtable_impl { return !(x < y); } /// @cond - BOOST_INTRUSIVE_FORCEINLINE void check() const {} + inline void check() const {} private: static void priv_initialize_new_buckets @@ -4050,17 +4050,17 @@ class hashtable_impl } template - BOOST_INTRUSIVE_FORCEINLINE bool priv_is_value_equal_to_key + inline bool priv_is_value_equal_to_key (const value_type &v, const std::size_t h, const KeyType &key, KeyEqual equal_func, detail::true_) const //compare_hash { return this->priv_stored_or_compute_hash(v, store_hash_t()) == h && equal_func(key, key_of_value()(v)); } template - BOOST_INTRUSIVE_FORCEINLINE bool priv_is_value_equal_to_key + inline bool priv_is_value_equal_to_key (const value_type& v, const std::size_t , const KeyType& key, KeyEqual equal_func, detail::false_) const //compare_hash { return equal_func(key, key_of_value()(v)); } //return previous iterator to the next equal range group in case - BOOST_INTRUSIVE_FORCEINLINE static void priv_go_to_last_in_group + inline static void priv_go_to_last_in_group (siterator &it_first_in_group, detail::true_) BOOST_NOEXCEPT //optimize_multikey { it_first_in_group = @@ -4069,7 +4069,7 @@ class hashtable_impl } //return previous iterator to the next equal range group in case - BOOST_INTRUSIVE_FORCEINLINE static void priv_go_to_last_in_group //!optimize_multikey + inline static void priv_go_to_last_in_group //!optimize_multikey (siterator /*&it_first_in_group*/, detail::false_) BOOST_NOEXCEPT { } @@ -4171,16 +4171,16 @@ class hashtable_impl return r; } - BOOST_INTRUSIVE_FORCEINLINE size_type priv_get_bucket_num(const_iterator it) BOOST_NOEXCEPT + inline size_type priv_get_bucket_num(const_iterator it) BOOST_NOEXCEPT { return this->priv_get_bucket_num(it, linear_buckets_t()); } - BOOST_INTRUSIVE_FORCEINLINE size_type priv_get_bucket_num(const_iterator it, detail::true_) BOOST_NOEXCEPT //linear + inline size_type priv_get_bucket_num(const_iterator it, detail::true_) BOOST_NOEXCEPT //linear { return size_type(it.get_bucket_ptr() - this->priv_bucket_pointer()); } - BOOST_INTRUSIVE_FORCEINLINE size_type priv_get_bucket_num(const_iterator it, detail::false_) BOOST_NOEXCEPT //!linear + inline size_type priv_get_bucket_num(const_iterator it, detail::false_) BOOST_NOEXCEPT //!linear { return this->priv_get_bucket_num_hash_dispatch(it.slist_it(), store_hash_t()); } - BOOST_INTRUSIVE_FORCEINLINE size_type priv_get_bucket_num_hash_dispatch(siterator it, detail::true_) BOOST_NOEXCEPT //store_hash + inline size_type priv_get_bucket_num_hash_dispatch(siterator it, detail::true_) BOOST_NOEXCEPT //store_hash { return (size_type)this->priv_hash_to_nbucket(this->priv_stored_hash(it, store_hash_t())); } size_type priv_get_bucket_num_hash_dispatch(siterator it, detail::false_) BOOST_NOEXCEPT //NO store_hash @@ -4199,13 +4199,13 @@ class hashtable_impl } - BOOST_INTRUSIVE_FORCEINLINE bucket_ptr priv_get_bucket_ptr(const_iterator it) BOOST_NOEXCEPT + inline bucket_ptr priv_get_bucket_ptr(const_iterator it) BOOST_NOEXCEPT { return this->priv_get_bucket_ptr(it, linear_buckets_t()); } - BOOST_INTRUSIVE_FORCEINLINE bucket_ptr priv_get_bucket_ptr(const_iterator it, detail::true_) BOOST_NOEXCEPT //linear + inline bucket_ptr priv_get_bucket_ptr(const_iterator it, detail::true_) BOOST_NOEXCEPT //linear { return it.get_bucket_ptr(); } - BOOST_INTRUSIVE_FORCEINLINE bucket_ptr priv_get_bucket_ptr(const_iterator it, detail::false_) BOOST_NOEXCEPT //!linear + inline bucket_ptr priv_get_bucket_ptr(const_iterator it, detail::false_) BOOST_NOEXCEPT //!linear { return this->priv_bucket_ptr(this->priv_get_bucket_num_hash_dispatch(it.slist_it(), store_hash_t())); } /// @endcond @@ -4330,26 +4330,26 @@ class hashtable //Assert if passed value traits are compatible with the type BOOST_STATIC_ASSERT((detail::is_same::value)); - BOOST_INTRUSIVE_FORCEINLINE explicit hashtable ( const bucket_traits &b_traits + inline explicit hashtable ( const bucket_traits &b_traits , const hasher & hash_func = hasher() , const key_equal &equal_func = key_equal() , const value_traits &v_traits = value_traits()) : Base(b_traits, hash_func, equal_func, v_traits) {} - BOOST_INTRUSIVE_FORCEINLINE hashtable(BOOST_RV_REF(hashtable) x) + inline hashtable(BOOST_RV_REF(hashtable) x) : Base(BOOST_MOVE_BASE(Base, x)) {} - BOOST_INTRUSIVE_FORCEINLINE hashtable& operator=(BOOST_RV_REF(hashtable) x) + inline hashtable& operator=(BOOST_RV_REF(hashtable) x) { return static_cast(this->Base::operator=(BOOST_MOVE_BASE(Base, x))); } template - BOOST_INTRUSIVE_FORCEINLINE void clone_from(const hashtable &src, Cloner cloner, Disposer disposer) + inline void clone_from(const hashtable &src, Cloner cloner, Disposer disposer) { Base::clone_from(src, cloner, disposer); } template - BOOST_INTRUSIVE_FORCEINLINE void clone_from(BOOST_RV_REF(hashtable) src, Cloner cloner, Disposer disposer) + inline void clone_from(BOOST_RV_REF(hashtable) src, Cloner cloner, Disposer disposer) { Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer); } }; diff --git a/include/boost/intrusive/linear_slist_algorithms.hpp b/include/boost/intrusive/linear_slist_algorithms.hpp index a616d7ed..65a43f44 100644 --- a/include/boost/intrusive/linear_slist_algorithms.hpp +++ b/include/boost/intrusive/linear_slist_algorithms.hpp @@ -151,7 +151,7 @@ class linear_slist_algorithms //! Complexity: Constant //! //! Throws: 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 ()); } //! Requires: 'p' is the first node of a list. @@ -161,7 +161,7 @@ class linear_slist_algorithms //! Complexity: Constant time. //! //! Throws: 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(); } //! Effects: Returns true if this_node_points to an empty list. @@ -169,7 +169,7 @@ class linear_slist_algorithms //! Complexity: Constant //! //! Throws: 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); } //! Effects: Returns true if this_node points to a sentinel node. @@ -177,7 +177,7 @@ class linear_slist_algorithms //! Complexity: Constant //! //! Throws: 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; } //! Effects: Marks this node as a "sentinel" node, a special state that is different from "empty", @@ -186,7 +186,7 @@ class linear_slist_algorithms //! Complexity: Constant //! //! Throws: 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); } //! Requires: this_node and prev_init_node must be in the same linear list. @@ -198,7 +198,7 @@ class linear_slist_algorithms //! Complexity: Linear to the number of elements between prev_init_node and this_node. //! //! Throws: 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 { return base_t::get_previous_node(prev_init_node, this_node); } @@ -230,7 +230,7 @@ class linear_slist_algorithms //! Complexity: Constant //! //! Throws: 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 other_nxt = NodeTraits::get_next(other_node); @@ -400,7 +400,7 @@ class linear_slist_algorithms //! //! Throws: Nothing. template - 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); } }; diff --git a/include/boost/intrusive/list.hpp b/include/boost/intrusive/list.hpp index 62291b48..218c5fb7 100644 --- a/include/boost/intrusive/list.hpp +++ b/include/boost/intrusive/list.hpp @@ -127,10 +127,10 @@ class list_impl ((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(); } - 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(); } struct root_plus_size : public size_traits @@ -141,29 +141,29 @@ class list_impl struct data_t : public 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) {} root_plus_size root_plus_size_; } data_; - BOOST_INTRUSIVE_FORCEINLINE size_traits &priv_size_traits() BOOST_NOEXCEPT + inline size_traits &priv_size_traits() BOOST_NOEXCEPT { 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_; } - BOOST_INTRUSIVE_FORCEINLINE const value_traits &priv_value_traits() const BOOST_NOEXCEPT + inline const value_traits &priv_value_traits() const BOOST_NOEXCEPT { return data_; } - BOOST_INTRUSIVE_FORCEINLINE value_traits &priv_value_traits() BOOST_NOEXCEPT + inline value_traits &priv_value_traits() BOOST_NOEXCEPT { return data_; } typedef typename boost::intrusive::value_traits_pointers ::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::pointer_to(this->priv_value_traits()); } /// @endcond @@ -364,7 +364,7 @@ class list_impl //! Throws: Nothing. //! //! Complexity: 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())); } //! Effects: Returns a const_reference to the first element of the list. @@ -372,7 +372,7 @@ class list_impl //! Throws: Nothing. //! //! Complexity: 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())); } //! Effects: Returns a reference to the last element of the list. @@ -380,7 +380,7 @@ class list_impl //! Throws: Nothing. //! //! Complexity: 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())); } //! Effects: Returns a const_reference to the last element of the list. @@ -388,7 +388,7 @@ class list_impl //! Throws: Nothing. //! //! Complexity: 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()))); } //! Effects: Returns an iterator to the first element contained in the list. @@ -396,7 +396,7 @@ class list_impl //! Throws: Nothing. //! //! Complexity: 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()); } //! Effects: Returns a const_iterator to the first element contained in the list. @@ -404,7 +404,7 @@ class list_impl //! Throws: Nothing. //! //! Complexity: Constant. - BOOST_INTRUSIVE_FORCEINLINE const_iterator begin() const BOOST_NOEXCEPT + inline const_iterator begin() const BOOST_NOEXCEPT { return this->cbegin(); } //! Effects: Returns a const_iterator to the first element contained in the list. @@ -412,7 +412,7 @@ class list_impl //! Throws: Nothing. //! //! Complexity: 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()); } //! Effects: Returns an iterator to the end of the list. @@ -420,7 +420,7 @@ class list_impl //! Throws: Nothing. //! //! Complexity: Constant. - BOOST_INTRUSIVE_FORCEINLINE iterator end() BOOST_NOEXCEPT + inline iterator end() BOOST_NOEXCEPT { return iterator(this->get_root_node(), this->priv_value_traits_ptr()); } //! Effects: Returns a const_iterator to the end of the list. @@ -428,7 +428,7 @@ class list_impl //! Throws: Nothing. //! //! Complexity: Constant. - BOOST_INTRUSIVE_FORCEINLINE const_iterator end() const BOOST_NOEXCEPT + inline const_iterator end() const BOOST_NOEXCEPT { return this->cend(); } //! Effects: Returns a constant iterator to the end of the list. @@ -436,7 +436,7 @@ class list_impl //! Throws: Nothing. //! //! Complexity: 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()); } //! Effects: Returns a reverse_iterator pointing to the beginning @@ -445,7 +445,7 @@ class list_impl //! Throws: Nothing. //! //! Complexity: Constant. - BOOST_INTRUSIVE_FORCEINLINE reverse_iterator rbegin() BOOST_NOEXCEPT + inline reverse_iterator rbegin() BOOST_NOEXCEPT { return reverse_iterator(this->end()); } //! Effects: Returns a const_reverse_iterator pointing to the beginning @@ -454,7 +454,7 @@ class list_impl //! Throws: Nothing. //! //! Complexity: Constant. - BOOST_INTRUSIVE_FORCEINLINE const_reverse_iterator rbegin() const BOOST_NOEXCEPT + inline const_reverse_iterator rbegin() const BOOST_NOEXCEPT { return this->crbegin(); } //! Effects: Returns a const_reverse_iterator pointing to the beginning @@ -463,7 +463,7 @@ class list_impl //! Throws: Nothing. //! //! Complexity: Constant. - BOOST_INTRUSIVE_FORCEINLINE const_reverse_iterator crbegin() const BOOST_NOEXCEPT + inline const_reverse_iterator crbegin() const BOOST_NOEXCEPT { return const_reverse_iterator(end()); } //! Effects: Returns a reverse_iterator pointing to the end @@ -472,7 +472,7 @@ class list_impl //! Throws: Nothing. //! //! Complexity: Constant. - BOOST_INTRUSIVE_FORCEINLINE reverse_iterator rend() BOOST_NOEXCEPT + inline reverse_iterator rend() BOOST_NOEXCEPT { return reverse_iterator(begin()); } //! Effects: Returns a const_reverse_iterator pointing to the end @@ -481,7 +481,7 @@ class list_impl //! Throws: Nothing. //! //! Complexity: Constant. - BOOST_INTRUSIVE_FORCEINLINE const_reverse_iterator rend() const BOOST_NOEXCEPT + inline const_reverse_iterator rend() const BOOST_NOEXCEPT { return this->crend(); } //! Effects: Returns a const_reverse_iterator pointing to the end @@ -490,7 +490,7 @@ class list_impl //! Throws: Nothing. //! //! Complexity: 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()); } //! Precondition: end_iterator must be a valid end iterator @@ -501,7 +501,7 @@ class list_impl //! Throws: Nothing. //! //! Complexity: 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); } //! Precondition: end_iterator must be a valid end const_iterator @@ -512,7 +512,7 @@ class list_impl //! Throws: Nothing. //! //! Complexity: 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); } //! Effects: 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. //! //! Note: 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) return this->priv_size_traits().get_size(); @@ -538,7 +538,7 @@ class list_impl //! Complexity: Constant. //! //! Note: 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()); } //! Effects: Swaps the elements of x and *this. @@ -563,7 +563,7 @@ class list_impl //! Complexity: Linear to the number of shifts. //! //! Note: 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); } //! Effects: Moves forward all the elements, so that the second @@ -575,7 +575,7 @@ class list_impl //! Complexity: Linear to the number of shifts. //! //! Note: 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); } //! Effects: Erases the element pointed by i of the list. @@ -590,7 +590,7 @@ class list_impl //! //! Note: Invalidates the iterators (but not the references) to the //! 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()); } //! Requires: b and e must be valid iterators to elements in *this. @@ -608,7 +608,7 @@ class list_impl //! //! Note: Invalidates the iterators (but not the references) to the //! 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){ 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()); } - 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); } - 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()); } - 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; } - 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); } - 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); } - 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); } /// @cond @@ -1474,38 +1474,38 @@ class list typedef typename Base::iterator iterator; typedef typename Base::const_iterator const_iterator; - BOOST_INTRUSIVE_FORCEINLINE list() + inline list() : Base() {} - BOOST_INTRUSIVE_FORCEINLINE explicit list(const value_traits &v_traits) + inline explicit list(const value_traits &v_traits) : Base(v_traits) {} template - 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) {} - BOOST_INTRUSIVE_FORCEINLINE list(BOOST_RV_REF(list) x) + inline list(BOOST_RV_REF(list) 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(this->Base::operator=(BOOST_MOVE_BASE(Base, x))); } template - 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); } template - 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); } - 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(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(Base::container_from_end_iterator(end_iterator)); } }; diff --git a/include/boost/intrusive/pointer_traits.hpp b/include/boost/intrusive/pointer_traits.hpp index 1b2ed057..48d984ee 100644 --- a/include/boost/intrusive/pointer_traits.hpp +++ b/include/boost/intrusive/pointer_traits.hpp @@ -130,7 +130,7 @@ struct pointer_traits //! //! Note: For non-conforming compilers only the existence of a member function called //! pointer_to 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 //tries to converts &r to pointer. @@ -150,7 +150,7 @@ struct pointer_traits //! Note: For non-conforming compilers only the existence of a member function called //! static_cast_from is checked. template - 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; const bool value = boost::intrusive::detail:: @@ -171,7 +171,7 @@ struct pointer_traits //! Note: For non-conforming compilers only the existence of a member function called //! const_cast_from is checked. template - 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; const bool value = boost::intrusive::detail:: @@ -192,7 +192,7 @@ struct pointer_traits //! Note: For non-conforming compilers only the existence of a member function called //! dynamic_cast_from is checked. template - 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; const bool value = boost::intrusive::detail:: @@ -208,46 +208,46 @@ struct pointer_traits private: //priv_to_raw_pointer template - BOOST_INTRUSIVE_FORCEINLINE static T* to_raw_pointer(T* p) BOOST_NOEXCEPT + inline static T* to_raw_pointer(T* p) BOOST_NOEXCEPT { return p; } template - BOOST_INTRUSIVE_FORCEINLINE static typename pointer_traits::element_type* + inline static typename pointer_traits::element_type* to_raw_pointer(const Pointer &p) BOOST_NOEXCEPT { return pointer_traits::to_raw_pointer(p.operator->()); } //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); } - 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)); } //priv_static_cast_from template - 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); } template - 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(to_raw_pointer(uptr))) : pointer(); } //priv_const_cast_from template - 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); } template - 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(*uptr)) : pointer(); } //priv_dynamic_cast_from template - 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); } template - 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(*uptr)) : pointer(); } ///@endcond }; @@ -296,25 +296,25 @@ struct pointer_traits //! Returns: 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); } //! Returns: static_cast(uptr) //! template - 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(uptr); } //! Returns: const_cast(uptr) //! template - 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(uptr); } //! Returns: dynamic_cast(uptr) //! template - 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(uptr); } }; diff --git a/include/boost/intrusive/priority_compare.hpp b/include/boost/intrusive/priority_compare.hpp index 3e83ada1..a78e2c91 100644 --- a/include/boost/intrusive/priority_compare.hpp +++ b/include/boost/intrusive/priority_compare.hpp @@ -31,7 +31,7 @@ namespace intrusive { namespace adldft { template -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; } } //namespace adldft { @@ -46,7 +46,7 @@ struct priority_compare typedef T second_argument_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; return priority_order(val, val2); @@ -57,7 +57,7 @@ template <> struct priority_compare { template - 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; return priority_order(t, u); diff --git a/include/boost/intrusive/rbtree.hpp b/include/boost/intrusive/rbtree.hpp index 922fce51..524d6350 100644 --- a/include/boost/intrusive/rbtree.hpp +++ b/include/boost/intrusive/rbtree.hpp @@ -538,46 +538,46 @@ class rbtree //Assert if passed value traits are compatible with the type BOOST_STATIC_ASSERT((detail::is_same::value)); - BOOST_INTRUSIVE_FORCEINLINE rbtree() + inline rbtree() : 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) {} template - 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 value_traits &v_traits = value_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)) {} - BOOST_INTRUSIVE_FORCEINLINE rbtree& operator=(BOOST_RV_REF(rbtree) x) + inline rbtree& operator=(BOOST_RV_REF(rbtree) x) { return static_cast(this->Base::operator=(BOOST_MOVE_BASE(Base, x))); } template - 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); } template - 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); } - 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(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(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(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(Base::container_from_iterator(it)); } }; diff --git a/include/boost/intrusive/set.hpp b/include/boost/intrusive/set.hpp index 30f0760d..cb9ea8fc 100644 --- a/include/boost/intrusive/set.hpp +++ b/include/boost/intrusive/set.hpp @@ -525,46 +525,46 @@ class set //Assert if passed value traits are compatible with the type BOOST_STATIC_ASSERT((detail::is_same::value)); - BOOST_INTRUSIVE_FORCEINLINE set() + inline set() : 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) {} template - BOOST_INTRUSIVE_FORCEINLINE set( Iterator b, Iterator e + inline set( Iterator b, Iterator e , const key_compare &cmp = key_compare() , const value_traits &v_traits = value_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)) {} - BOOST_INTRUSIVE_FORCEINLINE set& operator=(BOOST_RV_REF(set) x) + inline set& operator=(BOOST_RV_REF(set) x) { return static_cast(this->Base::operator=(BOOST_MOVE_BASE(Base, x))); } template - 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); } template - 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); } - 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(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(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(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(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::value)); - BOOST_INTRUSIVE_FORCEINLINE multiset() + inline multiset() : 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) {} template - BOOST_INTRUSIVE_FORCEINLINE multiset( Iterator b, Iterator e + inline multiset( Iterator b, Iterator e , const key_compare &cmp = key_compare() , const value_traits &v_traits = value_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)) {} - BOOST_INTRUSIVE_FORCEINLINE multiset& operator=(BOOST_RV_REF(multiset) x) + inline multiset& operator=(BOOST_RV_REF(multiset) x) { return static_cast(this->Base::operator=(BOOST_MOVE_BASE(Base, x))); } template - 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); } template - 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); } - 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(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(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(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(Base::container_from_iterator(it)); } }; diff --git a/include/boost/intrusive/sg_set.hpp b/include/boost/intrusive/sg_set.hpp index 72c412d6..7ccb7e73 100644 --- a/include/boost/intrusive/sg_set.hpp +++ b/include/boost/intrusive/sg_set.hpp @@ -534,46 +534,46 @@ class sg_set //Assert if passed value traits are compatible with the type BOOST_STATIC_ASSERT((detail::is_same::value)); - BOOST_INTRUSIVE_FORCEINLINE sg_set() + inline sg_set() : 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) {} template - BOOST_INTRUSIVE_FORCEINLINE sg_set( Iterator b, Iterator e + inline 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) {} - 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)) {} - 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(this->Base::operator=(BOOST_MOVE_BASE(Base, x))); } template - 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); } template - 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); } - 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(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(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(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(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::value)); - BOOST_INTRUSIVE_FORCEINLINE sg_multiset() + inline sg_multiset() : 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) {} template - BOOST_INTRUSIVE_FORCEINLINE sg_multiset( Iterator b, Iterator e + inline 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) {} - 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)) {} - 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(this->Base::operator=(BOOST_MOVE_BASE(Base, x))); } template - 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); } template - 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); } - 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(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(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(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(Base::container_from_iterator(it)); } }; diff --git a/include/boost/intrusive/sgtree.hpp b/include/boost/intrusive/sgtree.hpp index 9e687da1..5990ff10 100644 --- a/include/boost/intrusive/sgtree.hpp +++ b/include/boost/intrusive/sgtree.hpp @@ -1020,46 +1020,46 @@ class sgtree //Assert if passed value traits are compatible with the type BOOST_STATIC_ASSERT((detail::is_same::value)); - BOOST_INTRUSIVE_FORCEINLINE sgtree() + inline sgtree() : 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) {} template - 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 value_traits &v_traits = value_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)) {} - BOOST_INTRUSIVE_FORCEINLINE sgtree& operator=(BOOST_RV_REF(sgtree) x) + inline sgtree& operator=(BOOST_RV_REF(sgtree) x) { return static_cast(this->Base::operator=(BOOST_MOVE_BASE(Base, x))); } template - 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); } template - 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); } - 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(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(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(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(Base::container_from_iterator(it)); } }; diff --git a/include/boost/intrusive/sgtree_algorithms.hpp b/include/boost/intrusive/sgtree_algorithms.hpp index 726dbb99..ea0d2c54 100644 --- a/include/boost/intrusive/sgtree_algorithms.hpp +++ b/include/boost/intrusive/sgtree_algorithms.hpp @@ -287,7 +287,7 @@ class sgtree_algorithms //! @copydoc ::boost::intrusive::bstree_algorithms::insert_unique_commit(node_ptr,node_ptr,const insert_commit_data&) template - 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 ,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); } diff --git a/include/boost/intrusive/slist.hpp b/include/boost/intrusive/slist.hpp index 7319bf31..85c9deb2 100644 --- a/include/boost/intrusive/slist.hpp +++ b/include/boost/intrusive/slist.hpp @@ -172,47 +172,47 @@ class slist_impl //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_INTRUSIVE_FORCEINLINE node_ptr get_end_node() + inline node_ptr get_end_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()); } - BOOST_INTRUSIVE_FORCEINLINE node_ptr get_root_node() + inline node_ptr get_root_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(); } - BOOST_INTRUSIVE_FORCEINLINE node_ptr get_last_node() + inline node_ptr get_last_node() { return this->get_last_node(detail::bool_()); } - 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_()); } - 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_()); } - BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_last_node(detail::bool_) + inline static node_ptr get_last_node(detail::bool_) { //This function shall not be used if cache_last is not true BOOST_INTRUSIVE_INVARIANT_ASSERT(cache_last); return node_ptr(); } - BOOST_INTRUSIVE_FORCEINLINE static void set_last_node(node_ptr , detail::bool_) + inline static void set_last_node(node_ptr , detail::bool_) { //This function shall not be used if cache_last is not true BOOST_INTRUSIVE_INVARIANT_ASSERT(cache_last); } - BOOST_INTRUSIVE_FORCEINLINE node_ptr get_last_node(detail::bool_) + inline node_ptr get_last_node(detail::bool_) { return node_ptr(data_.root_plus_size_.last_); } - BOOST_INTRUSIVE_FORCEINLINE const_node_ptr get_last_node(detail::bool_) const + inline const_node_ptr get_last_node(detail::bool_) const { return const_node_ptr(data_.root_plus_size_.last_); } - BOOST_INTRUSIVE_FORCEINLINE void set_last_node(node_ptr n, detail::bool_) + inline void set_last_node(node_ptr n, detail::bool_) { data_.root_plus_size_.last_ = n; } void set_default_constructed_state() @@ -241,22 +241,22 @@ class slist_impl root_plus_size root_plus_size_; } data_; - BOOST_INTRUSIVE_FORCEINLINE size_traits &priv_size_traits() + inline size_traits &priv_size_traits() { 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_; } - BOOST_INTRUSIVE_FORCEINLINE const value_traits &priv_value_traits() const + inline const value_traits &priv_value_traits() const { return data_; } - BOOST_INTRUSIVE_FORCEINLINE value_traits &priv_value_traits() + inline value_traits &priv_value_traits() { return data_; } typedef typename boost::intrusive::value_traits_pointers ::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::pointer_to(this->priv_value_traits()); } /// @endcond @@ -501,7 +501,7 @@ class slist_impl //! Throws: Nothing. //! //! Complexity: 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())); } //! Effects: Returns a const_reference to the first element of the list. @@ -509,7 +509,7 @@ class slist_impl //! Throws: Nothing. //! //! Complexity: 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()))); } //! Effects: Returns a reference to the last element of the list. @@ -534,7 +534,7 @@ class slist_impl //! //! Note: Does not affect the validity of iterators and references. //! 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)); return *this->priv_value_traits().to_value_ptr(this->get_last_node()); @@ -545,7 +545,7 @@ class slist_impl //! Throws: Nothing. //! //! Complexity: 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()); } //! Effects: Returns a const_iterator to the first element contained in the list. @@ -553,7 +553,7 @@ class slist_impl //! Throws: Nothing. //! //! Complexity: 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()); } //! Effects: Returns a const_iterator to the first element contained in the list. @@ -561,7 +561,7 @@ class slist_impl //! Throws: Nothing. //! //! Complexity: 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()); } //! Effects: Returns an iterator to the end of the list. @@ -569,7 +569,7 @@ class slist_impl //! Throws: Nothing. //! //! Complexity: Constant. - BOOST_INTRUSIVE_FORCEINLINE iterator end() BOOST_NOEXCEPT + inline iterator end() BOOST_NOEXCEPT { return iterator(this->get_end_node(), this->priv_value_traits_ptr()); } //! Effects: Returns a const_iterator to the end of the list. @@ -577,7 +577,7 @@ class slist_impl //! Throws: Nothing. //! //! Complexity: 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()); } //! Effects: Returns a const_iterator to the end of the list. @@ -585,7 +585,7 @@ class slist_impl //! Throws: Nothing. //! //! Complexity: Constant. - BOOST_INTRUSIVE_FORCEINLINE const_iterator cend() const BOOST_NOEXCEPT + inline const_iterator cend() const BOOST_NOEXCEPT { return this->end(); } //! Effects: Returns an iterator that points to a position @@ -594,7 +594,7 @@ class slist_impl //! Throws: Nothing. //! //! Complexity: 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()); } //! Effects: Returns an iterator that points to a position @@ -603,7 +603,7 @@ class slist_impl //! Throws: Nothing. //! //! Complexity: 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()); } //! Effects: Returns an iterator that points to a position @@ -612,7 +612,7 @@ class slist_impl //! Throws: Nothing. //! //! Complexity: Constant. - BOOST_INTRUSIVE_FORCEINLINE const_iterator cbefore_begin() const BOOST_NOEXCEPT + inline const_iterator cbefore_begin() const BOOST_NOEXCEPT { return this->before_begin(); } //! Effects: Returns an iterator to the last element contained in the list. @@ -622,7 +622,7 @@ class slist_impl //! Complexity: Constant. //! //! Note: 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 BOOST_INTRUSIVE_INVARIANT_ASSERT(cache_last); @@ -636,7 +636,7 @@ class slist_impl //! Complexity: Constant. //! //! Note: 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 BOOST_INTRUSIVE_INVARIANT_ASSERT(cache_last); @@ -650,7 +650,7 @@ class slist_impl //! Complexity: Constant. //! //! Note: 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()); } //! Precondition: end_iterator must be a valid end iterator @@ -661,7 +661,7 @@ class slist_impl //! Throws: Nothing. //! //! Complexity: 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); } //! Precondition: end_iterator must be a valid end const_iterator @@ -672,7 +672,7 @@ class slist_impl //! Throws: Nothing. //! //! Complexity: 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); } //! Effects: 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. //! //! Note: 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) return this->priv_size_traits().get_size(); @@ -698,7 +698,7 @@ class slist_impl //! Complexity: Constant. //! //! Note: 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()); } //! Effects: Swaps the elements of x and *this. @@ -2195,45 +2195,45 @@ class slist typedef typename Base::size_type size_type; typedef typename Base::node_ptr node_ptr; - BOOST_INTRUSIVE_FORCEINLINE slist() + inline slist() : Base() {} - BOOST_INTRUSIVE_FORCEINLINE explicit slist(const value_traits &v_traits) + inline explicit slist(const value_traits &v_traits) : Base(v_traits) {} 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()) : Base(f, before_l, n, v_traits) {} template - 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) {} - BOOST_INTRUSIVE_FORCEINLINE slist(BOOST_RV_REF(slist) x) + inline slist(BOOST_RV_REF(slist) 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(this->Base::operator=(BOOST_MOVE_BASE(Base, x))); } template - 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); } template - 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); } - 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(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(Base::container_from_end_iterator(end_iterator)); } }; diff --git a/include/boost/intrusive/splay_set.hpp b/include/boost/intrusive/splay_set.hpp index f700934f..217068d3 100644 --- a/include/boost/intrusive/splay_set.hpp +++ b/include/boost/intrusive/splay_set.hpp @@ -546,46 +546,46 @@ class splay_set //Assert if passed value traits are compatible with the type BOOST_STATIC_ASSERT((detail::is_same::value)); - BOOST_INTRUSIVE_FORCEINLINE splay_set() + inline splay_set() : 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) {} template - BOOST_INTRUSIVE_FORCEINLINE splay_set( Iterator b, Iterator e + inline 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) {} - 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(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(this->Base::operator=(::boost::move(static_cast(x)))); } template - 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); } template - 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); } - 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(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(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(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(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::value)); - BOOST_INTRUSIVE_FORCEINLINE splay_multiset() + inline splay_multiset() : 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) {} template - BOOST_INTRUSIVE_FORCEINLINE splay_multiset( Iterator b, Iterator e + inline 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) {} - 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(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(this->Base::operator=(::boost::move(static_cast(x)))); } template - 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); } template - 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); } - 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(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(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(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(Base::container_from_iterator(it)); } }; diff --git a/include/boost/intrusive/splaytree.hpp b/include/boost/intrusive/splaytree.hpp index 44e5c786..208a3e36 100644 --- a/include/boost/intrusive/splaytree.hpp +++ b/include/boost/intrusive/splaytree.hpp @@ -613,46 +613,46 @@ class splaytree //Assert if passed value traits are compatible with the type BOOST_STATIC_ASSERT((detail::is_same::value)); - BOOST_INTRUSIVE_FORCEINLINE splaytree() + inline splaytree() : 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) {} template - 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 value_traits &v_traits = value_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)) {} - BOOST_INTRUSIVE_FORCEINLINE splaytree& operator=(BOOST_RV_REF(splaytree) x) + inline splaytree& operator=(BOOST_RV_REF(splaytree) x) { return static_cast(this->Base::operator=(BOOST_MOVE_BASE(Base, x))); } template - 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); } template - 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); } - 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(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(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(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(Base::container_from_iterator(it)); } }; diff --git a/include/boost/intrusive/treap.hpp b/include/boost/intrusive/treap.hpp index ff84b747..34dae3b7 100644 --- a/include/boost/intrusive/treap.hpp +++ b/include/boost/intrusive/treap.hpp @@ -255,7 +255,7 @@ class treap_impl //! Complexity: Constant. //! //! Throws: Nothing. - BOOST_INTRUSIVE_FORCEINLINE iterator top() BOOST_NOEXCEPT + inline iterator top() BOOST_NOEXCEPT { return this->tree_type::root(); } //! Effects: Returns a const_iterator pointing to the highest priority object of the treap.. @@ -263,7 +263,7 @@ class treap_impl //! Complexity: Constant. //! //! Throws: Nothing. - BOOST_INTRUSIVE_FORCEINLINE const_iterator top() const BOOST_NOEXCEPT + inline const_iterator top() const BOOST_NOEXCEPT { return this->ctop(); } //! Effects: Returns a const_iterator pointing to the highest priority object of the treap.. @@ -271,7 +271,7 @@ class treap_impl //! Complexity: Constant. //! //! Throws: Nothing. - BOOST_INTRUSIVE_FORCEINLINE const_iterator ctop() const BOOST_NOEXCEPT + inline const_iterator ctop() const BOOST_NOEXCEPT { return this->tree_type::root(); } #ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED @@ -310,7 +310,7 @@ class treap_impl //! Complexity: Constant. //! //! Throws: Nothing. - BOOST_INTRUSIVE_FORCEINLINE reverse_iterator rtop() BOOST_NOEXCEPT + inline reverse_iterator rtop() BOOST_NOEXCEPT { return reverse_iterator(this->top()); } //! Effects: Returns a const_reverse_iterator pointing to the highest priority objec @@ -319,7 +319,7 @@ class treap_impl //! Complexity: Constant. //! //! Throws: 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()); } //! Effects: Returns a const_reverse_iterator pointing to the highest priority object @@ -328,7 +328,7 @@ class treap_impl //! Complexity: Constant. //! //! Throws: 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()); } #ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED @@ -1315,49 +1315,49 @@ class treap //Assert if passed value traits are compatible with the type BOOST_STATIC_ASSERT((detail::is_same::value)); - BOOST_INTRUSIVE_FORCEINLINE treap() + inline treap() : Base() {} - BOOST_INTRUSIVE_FORCEINLINE explicit treap( const key_compare &cmp + inline explicit treap( const key_compare &cmp , const priority_compare &pcmp = priority_compare() , const value_traits &v_traits = value_traits()) : Base(cmp, pcmp, v_traits) {} template - 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 priority_compare &pcmp = priority_compare() , const value_traits &v_traits = value_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)) {} - BOOST_INTRUSIVE_FORCEINLINE treap& operator=(BOOST_RV_REF(treap) x) + inline treap& operator=(BOOST_RV_REF(treap) x) { return static_cast(this->Base::operator=(BOOST_MOVE_BASE(Base, x))); } template - 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); } template - 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); } - 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(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(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(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(Base::container_from_iterator(it)); } }; diff --git a/include/boost/intrusive/treap_algorithms.hpp b/include/boost/intrusive/treap_algorithms.hpp index a8ddee6e..8c836c52 100644 --- a/include/boost/intrusive/treap_algorithms.hpp +++ b/include/boost/intrusive/treap_algorithms.hpp @@ -172,6 +172,10 @@ class treap_algorithms /// @endcond { /// @cond + inline insert_commit_data() + : bstree_algo::insert_commit_data(), rotations() + {} + std::size_t rotations; /// @endcond }; diff --git a/include/boost/intrusive/treap_set.hpp b/include/boost/intrusive/treap_set.hpp index d15a83b4..f0ede210 100644 --- a/include/boost/intrusive/treap_set.hpp +++ b/include/boost/intrusive/treap_set.hpp @@ -215,22 +215,22 @@ class treap_set_impl #if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) //! @copydoc ::boost::intrusive::treap::top() - BOOST_INTRUSIVE_FORCEINLINE iterator top() BOOST_NOEXCEPT; + inline iterator top() BOOST_NOEXCEPT; //! @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 - BOOST_INTRUSIVE_FORCEINLINE const_iterator ctop() const BOOST_NOEXCEPT; + inline const_iterator ctop() const BOOST_NOEXCEPT; //! @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 - BOOST_INTRUSIVE_FORCEINLINE const_reverse_iterator rtop() const BOOST_NOEXCEPT; + inline const_reverse_iterator rtop() const BOOST_NOEXCEPT; //! @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 priority_compare priority_comp() const; @@ -542,49 +542,49 @@ class treap_set //Assert if passed value traits are compatible with the type BOOST_STATIC_ASSERT((detail::is_same::value)); - BOOST_INTRUSIVE_FORCEINLINE treap_set() + inline treap_set() : 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 value_traits &v_traits = value_traits()) : Base(cmp, pcmp, v_traits) {} template - BOOST_INTRUSIVE_FORCEINLINE treap_set( Iterator b, Iterator e + inline treap_set( Iterator b, Iterator e , const key_compare &cmp = key_compare() , const priority_compare &pcmp = priority_compare() , const value_traits &v_traits = value_traits()) : Base(b, e, cmp, pcmp, v_traits) {} - 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)) {} - 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(this->Base::operator=(BOOST_MOVE_BASE(Base, x))); } template - 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); } template - 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); } - 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(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(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(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(Base::container_from_iterator(it)); } }; @@ -774,22 +774,22 @@ class treap_multiset_impl #if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) //! @copydoc ::boost::intrusive::treap::top() - BOOST_INTRUSIVE_FORCEINLINE iterator top() BOOST_NOEXCEPT; + inline iterator top() BOOST_NOEXCEPT; //! @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 - BOOST_INTRUSIVE_FORCEINLINE const_iterator ctop() const BOOST_NOEXCEPT; + inline const_iterator ctop() const BOOST_NOEXCEPT; //! @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 - BOOST_INTRUSIVE_FORCEINLINE const_reverse_iterator rtop() const BOOST_NOEXCEPT; + inline const_reverse_iterator rtop() const BOOST_NOEXCEPT; //! @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 priority_compare priority_comp() const; @@ -1057,49 +1057,49 @@ class treap_multiset //Assert if passed value traits are compatible with the type BOOST_STATIC_ASSERT((detail::is_same::value)); - BOOST_INTRUSIVE_FORCEINLINE treap_multiset() + inline treap_multiset() : 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 value_traits &v_traits = value_traits()) : Base(cmp, pcmp, v_traits) {} template - BOOST_INTRUSIVE_FORCEINLINE treap_multiset( Iterator b, Iterator e + inline treap_multiset( Iterator b, Iterator e , const key_compare &cmp = key_compare() , const priority_compare &pcmp = priority_compare() , const value_traits &v_traits = value_traits()) : Base(b, e, cmp, pcmp, v_traits) {} - 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)) {} - 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(this->Base::operator=(BOOST_MOVE_BASE(Base, x))); } template - 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); } template - 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); } - 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(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(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(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(Base::container_from_iterator(it)); } }; diff --git a/include/boost/intrusive/unordered_set.hpp b/include/boost/intrusive/unordered_set.hpp index 51023b8b..0a65570d 100644 --- a/include/boost/intrusive/unordered_set.hpp +++ b/include/boost/intrusive/unordered_set.hpp @@ -121,7 +121,7 @@ class unordered_set_impl public: //! @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 key_equal &equal_func = key_equal() , 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 &) template - BOOST_INTRUSIVE_FORCEINLINE unordered_set_impl( Iterator b + inline unordered_set_impl( Iterator b , Iterator e , const bucket_traits &b_traits , const hasher & hash_func = hasher() @@ -140,12 +140,12 @@ class unordered_set_impl {} //! @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)) {} //! @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(table_type::operator=(BOOST_MOVE_BASE(table_type, x))); } #ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED @@ -197,30 +197,30 @@ class unordered_set_impl //! @copydoc ::boost::intrusive::hashtable::clone_from(hashtable&&,Cloner,Disposer) template - 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); } //! @copydoc ::boost::intrusive::hashtable::insert_unique(reference) - BOOST_INTRUSIVE_FORCEINLINE std::pair insert(reference value) + inline std::pair insert(reference value) { return table_type::insert_unique(value); } //! @copydoc ::boost::intrusive::hashtable::insert_unique(Iterator,Iterator) template - BOOST_INTRUSIVE_FORCEINLINE void insert(Iterator b, Iterator e) + inline void insert(Iterator b, Iterator e) { table_type::insert_unique(b, e); } //! @copydoc ::boost::intrusive::hashtable::insert_unique_check(const key_type&,insert_commit_data&) - BOOST_INTRUSIVE_FORCEINLINE std::pair insert_check(const key_type &key, insert_commit_data &commit_data) + inline std::pair insert_check(const key_type &key, insert_commit_data &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&) template - BOOST_INTRUSIVE_FORCEINLINE std::pair insert_check + inline std::pair insert_check (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); } //! @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); } #ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED @@ -501,7 +501,7 @@ class unordered_set typedef typename Base::hasher hasher; typedef typename Base::key_equal key_equal; - BOOST_INTRUSIVE_FORCEINLINE + inline explicit unordered_set ( const bucket_traits &b_traits , const hasher & hash_func = hasher() , const key_equal &equal_func = key_equal() @@ -510,7 +510,7 @@ class unordered_set {} template - BOOST_INTRUSIVE_FORCEINLINE + inline unordered_set ( Iterator b, Iterator e , const bucket_traits &b_traits @@ -520,19 +520,19 @@ class unordered_set : 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)) {} - 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(this->Base::operator=(BOOST_MOVE_BASE(Base, x))); } template - 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); } template - 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); } }; @@ -622,7 +622,7 @@ class unordered_multiset_impl public: //! @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 key_equal &equal_func = key_equal() , 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 &) template - BOOST_INTRUSIVE_FORCEINLINE unordered_multiset_impl ( Iterator b + inline unordered_multiset_impl ( Iterator b , Iterator e , const bucket_traits &b_traits , const hasher & hash_func = hasher() @@ -642,13 +642,13 @@ class unordered_multiset_impl //! Effects: 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)) {} //! Effects: 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(table_type::operator=(BOOST_MOVE_BASE(table_type, x))); } #ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED @@ -701,16 +701,16 @@ class unordered_multiset_impl //! @copydoc ::boost::intrusive::hashtable::clone_from(hashtable&&,Cloner,Disposer) template - 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); } //! @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); } //! @copydoc ::boost::intrusive::hashtable::insert_equal(Iterator,Iterator) template - BOOST_INTRUSIVE_FORCEINLINE void insert(Iterator b, Iterator e) + inline void insert(Iterator b, Iterator e) { table_type::insert_equal(b, e); } #ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED @@ -956,7 +956,7 @@ class unordered_multiset typedef typename Base::hasher hasher; typedef typename Base::key_equal key_equal; - BOOST_INTRUSIVE_FORCEINLINE + inline explicit unordered_multiset( const bucket_traits &b_traits , const hasher & hash_func = hasher() , const key_equal &equal_func = key_equal() @@ -965,7 +965,7 @@ class unordered_multiset {} template - BOOST_INTRUSIVE_FORCEINLINE + inline unordered_multiset( Iterator b , Iterator e , const bucket_traits &b_traits @@ -975,19 +975,19 @@ class unordered_multiset : 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)) {} - 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(this->Base::operator=(BOOST_MOVE_BASE(Base, x))); } template - 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); } template - 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); } }; diff --git a/include/boost/intrusive/unordered_set_hook.hpp b/include/boost/intrusive/unordered_set_hook.hpp index cfa4f259..e0c306a3 100644 --- a/include/boost/intrusive/unordered_set_hook.hpp +++ b/include/boost/intrusive/unordered_set_hook.hpp @@ -82,22 +82,22 @@ struct unordered_node_traits static const bool store_hash = StoreHash; 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::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; } - 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_; } - 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; } - 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_; } - 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; } }; @@ -108,10 +108,10 @@ struct unordered_group_adapter typedef typename NodeTraits::node_ptr 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); } - 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); } }; @@ -127,19 +127,19 @@ struct unordered_algorithms typedef typename NodeTraits::node_ptr 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); 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); 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); group_algorithms::unlink(n);