diff options
author | robot-contrib <robot-contrib@yandex-team.com> | 2024-07-24 12:28:38 +0300 |
---|---|---|
committer | robot-contrib <robot-contrib@yandex-team.com> | 2024-07-24 12:40:11 +0300 |
commit | cf9351508de68ab7f57292389d1cc0b2dea61d61 (patch) | |
tree | b19211a085f82ed36e3bc7e21e74040f7add1509 /contrib | |
parent | 2cda5506bf4b2fb1c7870fd352b1d4f8dd1c76bf (diff) | |
download | ydb-cf9351508de68ab7f57292389d1cc0b2dea61d61.tar.gz |
Update contrib/restricted/boost/intrusive to 1.85.0
d0bc972b8d03404c917d9653386f945a43392d56
Diffstat (limited to 'contrib')
36 files changed, 534 insertions, 526 deletions
diff --git a/contrib/restricted/boost/intrusive/include/boost/intrusive/avltree.hpp b/contrib/restricted/boost/intrusive/include/boost/intrusive/avltree.hpp index 747d41cc38..4eda39e699 100644 --- a/contrib/restricted/boost/intrusive/include/boost/intrusive/avltree.hpp +++ b/contrib/restricted/boost/intrusive/include/boost/intrusive/avltree.hpp @@ -18,7 +18,6 @@ #include <boost/intrusive/detail/minimal_less_equal_header.hpp> #include <boost/intrusive/detail/minimal_pair_header.hpp> -#include <boost/static_assert.hpp> #include <boost/intrusive/avl_set_hook.hpp> #include <boost/intrusive/detail/avltree_node.hpp> #include <boost/intrusive/bstree.hpp> @@ -533,48 +532,48 @@ class avltree typedef typename Base::const_reverse_iterator const_reverse_iterator; //Assert if passed value traits are compatible with the type - BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value)); + BOOST_INTRUSIVE_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::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<class Iterator> - BOOST_INTRUSIVE_FORCEINLINE avltree( bool unique, Iterator b, Iterator e + inline avltree( bool unique, Iterator b, Iterator e , const key_compare &cmp = key_compare() , const 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<avltree &>(this->Base::operator=(BOOST_MOVE_BASE(Base, x))); } template <class Cloner, class Disposer> - BOOST_INTRUSIVE_FORCEINLINE void clone_from(const avltree &src, Cloner cloner, Disposer disposer) + inline void clone_from(const avltree &src, Cloner cloner, Disposer disposer) { Base::clone_from(src, cloner, disposer); } template <class Cloner, class Disposer> - BOOST_INTRUSIVE_FORCEINLINE void clone_from(BOOST_RV_REF(avltree) src, Cloner cloner, Disposer disposer) + inline void clone_from(BOOST_RV_REF(avltree) src, Cloner cloner, Disposer disposer) { Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer); } - BOOST_INTRUSIVE_FORCEINLINE static avltree &container_from_end_iterator(iterator end_iterator) BOOST_NOEXCEPT + inline static avltree &container_from_end_iterator(iterator end_iterator) BOOST_NOEXCEPT { return static_cast<avltree &>(Base::container_from_end_iterator(end_iterator)); } - BOOST_INTRUSIVE_FORCEINLINE static const avltree &container_from_end_iterator(const_iterator end_iterator) BOOST_NOEXCEPT + inline static const avltree &container_from_end_iterator(const_iterator end_iterator) BOOST_NOEXCEPT { return static_cast<const avltree &>(Base::container_from_end_iterator(end_iterator)); } - BOOST_INTRUSIVE_FORCEINLINE static avltree &container_from_iterator(iterator it) BOOST_NOEXCEPT + inline static avltree &container_from_iterator(iterator it) BOOST_NOEXCEPT { return static_cast<avltree &>(Base::container_from_iterator(it)); } - BOOST_INTRUSIVE_FORCEINLINE static const avltree &container_from_iterator(const_iterator it) BOOST_NOEXCEPT + inline static const avltree &container_from_iterator(const_iterator it) BOOST_NOEXCEPT { return static_cast<const avltree &>(Base::container_from_iterator(it)); } }; diff --git a/contrib/restricted/boost/intrusive/include/boost/intrusive/avltree_algorithms.hpp b/contrib/restricted/boost/intrusive/include/boost/intrusive/avltree_algorithms.hpp index 0fd158d595..8195490650 100644 --- a/contrib/restricted/boost/intrusive/include/boost/intrusive/avltree_algorithms.hpp +++ b/contrib/restricted/boost/intrusive/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<F> base_t; - BOOST_INTRUSIVE_FORCEINLINE avltree_node_cloner(F f) + inline avltree_node_cloner(F f) : base_t(f) {} diff --git a/contrib/restricted/boost/intrusive/include/boost/intrusive/bstree.hpp b/contrib/restricted/boost/intrusive/include/boost/intrusive/bstree.hpp index 51687ebd27..8196d36b3f 100644 --- a/contrib/restricted/boost/intrusive/include/boost/intrusive/bstree.hpp +++ b/contrib/restricted/boost/intrusive/include/boost/intrusive/bstree.hpp @@ -16,7 +16,6 @@ #include <boost/intrusive/intrusive_fwd.hpp> #include <boost/intrusive/detail/assert.hpp> -#include <boost/static_assert.hpp> #include <boost/intrusive/intrusive_fwd.hpp> #include <boost/intrusive/bs_set_hook.hpp> #include <boost/intrusive/detail/tree_node.hpp> @@ -105,7 +104,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; @@ -113,7 +112,7 @@ struct bstbase3 static bstbase3 &get_tree_base_from_end_iterator(const const_iterator &end_iterator) { - BOOST_STATIC_ASSERT(has_container_from_iterator); + BOOST_INTRUSIVE_STATIC_ASSERT(has_container_from_iterator); node_ptr p = end_iterator.pointed_node(); header_holder_type* h = header_holder_type::get_holder(p); holder_t *holder = get_parent_from_member<holder_t, header_holder_type>(h, &holder_t::root); @@ -121,73 +120,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 <ValueTraits>::const_value_traits_ptr const_value_traits_ptr; - BOOST_INTRUSIVE_FORCEINLINE const_value_traits_ptr priv_value_traits_ptr() const + inline const_value_traits_ptr priv_value_traits_ptr() const { return pointer_traits<const_value_traits_ptr>::pointer_to(this->get_value_traits()); } - 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 +198,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 @@ -207,13 +206,13 @@ struct bstbase3 static iterator s_iterator_to(reference value) BOOST_NOEXCEPT { - BOOST_STATIC_ASSERT((!stateful_value_traits)); + BOOST_INTRUSIVE_STATIC_ASSERT((!stateful_value_traits)); return iterator (value_traits::to_node_ptr(value), const_value_traits_ptr()); } static const_iterator s_iterator_to(const_reference value) BOOST_NOEXCEPT { - BOOST_STATIC_ASSERT((!stateful_value_traits)); + BOOST_INTRUSIVE_STATIC_ASSERT((!stateful_value_traits)); return const_iterator (value_traits::to_node_ptr(*pointer_traits<pointer>::const_cast_from(pointer_traits<const_pointer>::pointer_to(value))), const_value_traits_ptr()); } @@ -223,7 +222,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<pointer>::const_cast_from(pointer_traits<const_pointer>::pointer_to(value))), this->priv_value_traits_ptr()); } - BOOST_INTRUSIVE_FORCEINLINE static void init_node(reference value) + inline static void init_node(reference value) { node_algorithms::init(value_traits::to_node_ptr(value)); } }; @@ -314,17 +313,17 @@ struct bstbase2 typedef BOOST_INTRUSIVE_IMPDEF(typename pointer_traits<const_pointer>::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<class KeyType, class KeyTypeKeyCompare> @@ -342,7 +341,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<class KeyType, class KeyTypeKeyCompare> @@ -352,7 +351,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<class KeyType, class KeyTypeKeyCompare> @@ -367,13 +366,13 @@ struct bstbase2 { typedef detail::key_nodeptr_comp<KeyTypeKeyCompare, value_traits, key_of_value> type; }; template<class KeyTypeKeyCompare> - BOOST_INTRUSIVE_FORCEINLINE typename key_node_comp_ret<KeyTypeKeyCompare>::type key_node_comp(KeyTypeKeyCompare comp) const + inline typename key_node_comp_ret<KeyTypeKeyCompare>::type key_node_comp(KeyTypeKeyCompare comp) const { return detail::key_nodeptr_comp<KeyTypeKeyCompare, value_traits, key_of_value>(comp, &this->get_value_traits()); } //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<class KeyType, class KeyTypeKeyCompare> @@ -383,7 +382,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<class KeyType, class KeyTypeKeyCompare> @@ -394,7 +393,7 @@ struct bstbase2 } //equal_range - BOOST_INTRUSIVE_FORCEINLINE std::pair<iterator,iterator> equal_range(const key_type &key) + inline std::pair<iterator,iterator> equal_range(const key_type &key) { return this->equal_range(key, this->key_comp()); } template<class KeyType, class KeyTypeKeyCompare> @@ -406,7 +405,7 @@ struct bstbase2 , iterator(ret.second, this->priv_value_traits_ptr())); } - BOOST_INTRUSIVE_FORCEINLINE std::pair<const_iterator, const_iterator> + inline std::pair<const_iterator, const_iterator> equal_range(const key_type &key) const { return this->equal_range(key, this->key_comp()); } @@ -421,7 +420,7 @@ struct bstbase2 } //lower_bound_range - BOOST_INTRUSIVE_FORCEINLINE std::pair<iterator,iterator> lower_bound_range(const key_type &key) + inline std::pair<iterator,iterator> lower_bound_range(const key_type &key) { return this->lower_bound_range(key, this->key_comp()); } template<class KeyType, class KeyTypeKeyCompare> @@ -433,7 +432,7 @@ struct bstbase2 , iterator(ret.second, this->priv_value_traits_ptr())); } - BOOST_INTRUSIVE_FORCEINLINE std::pair<const_iterator, const_iterator> + inline std::pair<const_iterator, const_iterator> lower_bound_range(const key_type &key) const { return this->lower_bound_range(key, this->key_comp()); } @@ -448,7 +447,7 @@ struct bstbase2 } //bounded_range - BOOST_INTRUSIVE_FORCEINLINE std::pair<iterator,iterator> bounded_range + inline std::pair<iterator,iterator> bounded_range (const key_type &lower_key, const key_type &upper_key, bool left_closed, bool right_closed) { return this->bounded_range(lower_key, upper_key, this->key_comp(), left_closed, right_closed); } @@ -463,7 +462,7 @@ struct bstbase2 , iterator(ret.second, this->priv_value_traits_ptr())); } - BOOST_INTRUSIVE_FORCEINLINE std::pair<const_iterator,const_iterator> bounded_range + inline std::pair<const_iterator,const_iterator> bounded_range (const key_type &lower_key, const key_type &upper_key, bool left_closed, bool right_closed) const { return this->bounded_range(lower_key, upper_key, this->key_comp(), left_closed, right_closed); } @@ -479,11 +478,11 @@ struct bstbase2 } //insert_unique_check - BOOST_INTRUSIVE_FORCEINLINE std::pair<iterator, bool> insert_unique_check + inline std::pair<iterator, bool> insert_unique_check (const key_type &key, insert_commit_data &commit_data) { return this->insert_unique_check(key, this->key_comp(), commit_data); } - BOOST_INTRUSIVE_FORCEINLINE std::pair<iterator, bool> insert_unique_check + inline std::pair<iterator, bool> insert_unique_check (const_iterator hint, const key_type &key, insert_commit_data &commit_data) { return this->insert_unique_check(hint, key, this->key_comp(), commit_data); } @@ -528,7 +527,7 @@ struct bstbase_hack typedef typename get_algo <AlgoType, node_traits>::type algo_type; - BOOST_INTRUSIVE_FORCEINLINE bstbase_hack(const key_compare & comp, const ValueTraits &vtraits) + inline bstbase_hack(const key_compare & comp, const ValueTraits &vtraits) : base_type(comp, vtraits) { this->sz_traits().set_size(size_type(0)); @@ -536,10 +535,10 @@ struct bstbase_hack typedef detail::size_holder<ConstantTimeSize, SizeType> size_traits; - BOOST_INTRUSIVE_FORCEINLINE size_traits &sz_traits() + inline size_traits &sz_traits() { return static_cast<size_traits &>(*this); } - BOOST_INTRUSIVE_FORCEINLINE const size_traits &sz_traits() const + inline const size_traits &sz_traits() const { return static_cast<const size_traits &>(*this); } }; @@ -551,13 +550,13 @@ struct bstbase_hack<ValueTraits, VoidOrKeyOfValue, VoidOrKeyComp, false, SizeTyp typedef bstbase2< ValueTraits, VoidOrKeyOfValue, VoidOrKeyComp, AlgoType, HeaderHolder> 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<false, SizeType> size_traits; - BOOST_INTRUSIVE_FORCEINLINE size_traits sz_traits() const + inline size_traits sz_traits() const { return size_traits(); } }; @@ -579,7 +578,7 @@ struct bstbase <AlgoType, node_traits>::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) {} @@ -666,7 +665,7 @@ class bstree_impl static const bool safemode_or_autounlink = is_safe_autounlink<value_traits::link_mode>::value; //Constant-time size is incompatible with auto-unlink hooks! - BOOST_STATIC_ASSERT(!(constant_time_size && ((int)value_traits::link_mode == (int)auto_unlink))); + BOOST_INTRUSIVE_STATIC_ASSERT(!(constant_time_size && ((int)value_traits::link_mode == (int)auto_unlink))); protected: @@ -742,7 +741,7 @@ class bstree_impl //! <b>Effects</b>: Equivalent to swap //! - BOOST_INTRUSIVE_FORCEINLINE bstree_impl& operator=(BOOST_RV_REF(bstree_impl) x) + inline bstree_impl& operator=(BOOST_RV_REF(bstree_impl) x) { this->swap(x); return *this; } #ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED @@ -1961,7 +1960,7 @@ class bstree_impl //! functor a compilation error will be issued. static void remove_node(reference value) BOOST_NOEXCEPT { - BOOST_STATIC_ASSERT((!constant_time_size)); + BOOST_INTRUSIVE_STATIC_ASSERT((!constant_time_size)); node_ptr to_remove(value_traits::to_node_ptr(value)); node_algorithms::unlink(to_remove); BOOST_IF_CONSTEXPR(safemode_or_autounlink) @@ -2184,48 +2183,48 @@ class bstree typedef typename Base::const_iterator const_iterator; //Assert if passed value traits are compatible with the type - BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value)); + BOOST_INTRUSIVE_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::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<class Iterator> - BOOST_INTRUSIVE_FORCEINLINE bstree( bool unique, Iterator b, Iterator e + inline bstree( bool unique, Iterator b, Iterator e , const key_compare &cmp = key_compare() , const 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<bstree &>(this->Base::operator=(BOOST_MOVE_BASE(Base, x))); } template <class Cloner, class Disposer> - BOOST_INTRUSIVE_FORCEINLINE void clone_from(const bstree &src, Cloner cloner, Disposer disposer) + inline void clone_from(const bstree &src, Cloner cloner, Disposer disposer) { Base::clone_from(src, cloner, disposer); } template <class Cloner, class Disposer> - BOOST_INTRUSIVE_FORCEINLINE void clone_from(BOOST_RV_REF(bstree) src, Cloner cloner, Disposer disposer) + inline void clone_from(BOOST_RV_REF(bstree) src, Cloner cloner, Disposer disposer) { Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer); } - BOOST_INTRUSIVE_FORCEINLINE static bstree &container_from_end_iterator(iterator end_iterator) BOOST_NOEXCEPT + inline static bstree &container_from_end_iterator(iterator end_iterator) BOOST_NOEXCEPT { return static_cast<bstree &>(Base::container_from_end_iterator(end_iterator)); } - BOOST_INTRUSIVE_FORCEINLINE static const bstree &container_from_end_iterator(const_iterator end_iterator) BOOST_NOEXCEPT + inline static const bstree &container_from_end_iterator(const_iterator end_iterator) BOOST_NOEXCEPT { return static_cast<const bstree &>(Base::container_from_end_iterator(end_iterator)); } - BOOST_INTRUSIVE_FORCEINLINE static bstree &container_from_iterator(iterator it) BOOST_NOEXCEPT + inline static bstree &container_from_iterator(iterator it) BOOST_NOEXCEPT { return static_cast<bstree &>(Base::container_from_iterator(it)); } - BOOST_INTRUSIVE_FORCEINLINE static const bstree &container_from_iterator(const_iterator it) BOOST_NOEXCEPT + inline static const bstree &container_from_iterator(const_iterator it) BOOST_NOEXCEPT { return static_cast<const bstree &>(Base::container_from_iterator(it)); } }; diff --git a/contrib/restricted/boost/intrusive/include/boost/intrusive/bstree_algorithms.hpp b/contrib/restricted/boost/intrusive/include/boost/intrusive/bstree_algorithms.hpp index 5113a584b8..45e6b18199 100644 --- a/contrib/restricted/boost/intrusive/include/boost/intrusive/bstree_algorithms.hpp +++ b/contrib/restricted/boost/intrusive/include/boost/intrusive/bstree_algorithms.hpp @@ -38,7 +38,7 @@ namespace intrusive { template <class NodePtr> 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<NodeTraits> template<class Disposer> struct dispose_subtree_disposer { - BOOST_INTRUSIVE_FORCEINLINE dispose_subtree_disposer(Disposer &disp, node_ptr subtree) + inline dispose_subtree_disposer(Disposer &disp, node_ptr subtree) : disposer_(&disp), subtree_(subtree) {} - 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<NodeTraits> //! <b>Complexity</b>: Constant time. //! //! <b>Throws</b>: Nothing. - BOOST_INTRUSIVE_FORCEINLINE static node_ptr begin_node(const_node_ptr header) BOOST_NOEXCEPT + inline static node_ptr begin_node(const_node_ptr header) BOOST_NOEXCEPT { return node_traits::get_left(header); } //! <b>Requires</b>: 'header' is the header node of a tree. @@ -223,7 +223,7 @@ class bstree_algorithms : public bstree_algorithms_base<NodeTraits> //! <b>Complexity</b>: Constant time. //! //! <b>Throws</b>: Nothing. - BOOST_INTRUSIVE_FORCEINLINE static node_ptr end_node(const_node_ptr header) BOOST_NOEXCEPT + inline static node_ptr end_node(const_node_ptr header) BOOST_NOEXCEPT { return detail::uncast(header); } //! <b>Requires</b>: 'header' is the header node of a tree. @@ -233,7 +233,7 @@ class bstree_algorithms : public bstree_algorithms_base<NodeTraits> //! <b>Complexity</b>: Constant time. //! //! <b>Throws</b>: Nothing. - BOOST_INTRUSIVE_FORCEINLINE static node_ptr root_node(const_node_ptr header) BOOST_NOEXCEPT + inline static node_ptr root_node(const_node_ptr header) BOOST_NOEXCEPT { node_ptr p = node_traits::get_parent(header); return p ? p : detail::uncast(header); @@ -247,7 +247,7 @@ class bstree_algorithms : public bstree_algorithms_base<NodeTraits> //! <b>Complexity</b>: Constant time. //! //! <b>Throws</b>: Nothing. - BOOST_INTRUSIVE_FORCEINLINE static bool unique(const_node_ptr n) BOOST_NOEXCEPT + inline static bool unique(const_node_ptr n) BOOST_NOEXCEPT { return !NodeTraits::get_parent(n); } #if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) @@ -456,7 +456,7 @@ class bstree_algorithms : public bstree_algorithms_base<NodeTraits> //! new_node is not equivalent to node_to_be_replaced according to the //! 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<NodeTraits> //! //! <b>Throws</b>: If "comp" throws. template<class KeyType, class KeyNodePtrCompare> - BOOST_INTRUSIVE_FORCEINLINE static std::pair<node_ptr, node_ptr> equal_range + inline static std::pair<node_ptr, node_ptr> equal_range (const_node_ptr header, const KeyType &key, KeyNodePtrCompare comp) { return bounded_range(header, key, key, comp, true, true); @@ -919,7 +919,7 @@ class bstree_algorithms : public bstree_algorithms_base<NodeTraits> //! //! <b>Throws</b>: If "comp" throws. template<class KeyType, class KeyNodePtrCompare> - BOOST_INTRUSIVE_FORCEINLINE static node_ptr lower_bound + inline static node_ptr lower_bound (const_node_ptr header, const KeyType &key, KeyNodePtrCompare comp) { return lower_bound_loop(NodeTraits::get_parent(header), detail::uncast(header), key, comp); @@ -937,7 +937,7 @@ class bstree_algorithms : public bstree_algorithms_base<NodeTraits> //! //! <b>Throws</b>: If "comp" throws. template<class KeyType, class KeyNodePtrCompare> - BOOST_INTRUSIVE_FORCEINLINE static node_ptr upper_bound + inline static node_ptr upper_bound (const_node_ptr header, const KeyType &key, KeyNodePtrCompare comp) { return upper_bound_loop(NodeTraits::get_parent(header), detail::uncast(header), key, comp); @@ -960,7 +960,7 @@ class bstree_algorithms : public bstree_algorithms_base<NodeTraits> //! <b>Notes</b>: This function has only sense if a "insert_unique_check" has been //! 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<NodeTraits> //! <b>Complexity</b>: Amortized constant time. //! //! <b>Throws</b>: Nothing. - BOOST_INTRUSIVE_FORCEINLINE static void erase(node_ptr header, node_ptr z) BOOST_NOEXCEPT + inline static void erase(node_ptr header, node_ptr z) BOOST_NOEXCEPT { data_for_rebalance ignored; erase(header, z, ignored); @@ -1341,7 +1341,7 @@ class bstree_algorithms : public bstree_algorithms_base<NodeTraits> //! //! <b>Throws</b>: If the comparison throws. template<class NodePtrCompare> - BOOST_INTRUSIVE_FORCEINLINE static bool transfer_unique + inline static bool transfer_unique (node_ptr header1, NodePtrCompare comp, node_ptr header2, node_ptr z) { data_for_rebalance ignored; @@ -1358,7 +1358,7 @@ class bstree_algorithms : public bstree_algorithms_base<NodeTraits> //! //! <b>Throws</b>: If the comparison throws. template<class NodePtrCompare> - BOOST_INTRUSIVE_FORCEINLINE static void transfer_equal + inline static void transfer_equal (node_ptr header1, NodePtrCompare comp, node_ptr header2, node_ptr z) { data_for_rebalance ignored; @@ -1635,7 +1635,7 @@ class bstree_algorithms : public bstree_algorithms_base<NodeTraits> //! <b>Complexity</b>: Constant. //! //! <b>Throws</b>: Nothing. - BOOST_INTRUSIVE_FORCEINLINE static bool is_left_child(node_ptr p) BOOST_NOEXCEPT + inline static bool is_left_child(node_ptr p) BOOST_NOEXCEPT { return NodeTraits::get_left(NodeTraits::get_parent(p)) == p; } //! <b>Requires</b>: p is a node of a tree. @@ -1645,7 +1645,7 @@ class bstree_algorithms : public bstree_algorithms_base<NodeTraits> //! <b>Complexity</b>: Constant. //! //! <b>Throws</b>: Nothing. - BOOST_INTRUSIVE_FORCEINLINE static bool is_right_child(node_ptr p) BOOST_NOEXCEPT + inline static bool is_right_child(node_ptr p) BOOST_NOEXCEPT { return NodeTraits::get_right(NodeTraits::get_parent(p)) == p; } static void insert_before_check diff --git a/contrib/restricted/boost/intrusive/include/boost/intrusive/circular_list_algorithms.hpp b/contrib/restricted/boost/intrusive/include/boost/intrusive/circular_list_algorithms.hpp index ab34c7e309..2c99aa051b 100644 --- a/contrib/restricted/boost/intrusive/include/boost/intrusive/circular_list_algorithms.hpp +++ b/contrib/restricted/boost/intrusive/include/boost/intrusive/circular_list_algorithms.hpp @@ -80,7 +80,7 @@ class circular_list_algorithms //! <b>Complexity</b>: Constant //! //! <b>Throws</b>: Nothing. - BOOST_INTRUSIVE_FORCEINLINE static bool inited(const_node_ptr this_node) BOOST_NOEXCEPT + inline static bool inited(const_node_ptr this_node) BOOST_NOEXCEPT { return !NodeTraits::get_next(this_node); } //! <b>Effects</b>: Constructs an empty list, making this_node the only @@ -102,7 +102,7 @@ class circular_list_algorithms //! <b>Complexity</b>: Constant //! //! <b>Throws</b>: Nothing. - BOOST_INTRUSIVE_FORCEINLINE static bool is_empty(const_node_ptr this_node) BOOST_NOEXCEPT + inline static bool is_empty(const_node_ptr this_node) BOOST_NOEXCEPT { return NodeTraits::get_next(this_node) == this_node; } diff --git a/contrib/restricted/boost/intrusive/include/boost/intrusive/circular_slist_algorithms.hpp b/contrib/restricted/boost/intrusive/include/boost/intrusive/circular_slist_algorithms.hpp index 5ce4e8cdba..bc4beaa7e7 100644 --- a/contrib/restricted/boost/intrusive/include/boost/intrusive/circular_slist_algorithms.hpp +++ b/contrib/restricted/boost/intrusive/include/boost/intrusive/circular_slist_algorithms.hpp @@ -146,7 +146,7 @@ class circular_slist_algorithms //! <b>Complexity</b>: Constant //! //! <b>Throws</b>: Nothing. - BOOST_INTRUSIVE_FORCEINLINE static void init_header(node_ptr this_node) BOOST_NOEXCEPT + inline static void init_header(node_ptr this_node) BOOST_NOEXCEPT { NodeTraits::set_next(this_node, this_node); } //! <b>Requires</b>: 'p' is the first node of a list. @@ -156,7 +156,7 @@ class circular_slist_algorithms //! <b>Complexity</b>: Constant time. //! //! <b>Throws</b>: Nothing. - BOOST_INTRUSIVE_FORCEINLINE static node_ptr end_node(const_node_ptr p) BOOST_NOEXCEPT + inline static node_ptr end_node(const_node_ptr p) BOOST_NOEXCEPT { return detail::uncast(p); } //! <b>Effects</b>: Returns true if this_node_points to an empty list. @@ -164,7 +164,7 @@ class circular_slist_algorithms //! <b>Complexity</b>: Constant //! //! <b>Throws</b>: Nothing. - BOOST_INTRUSIVE_FORCEINLINE static bool is_empty(const_node_ptr this_node) BOOST_NOEXCEPT + inline static bool is_empty(const_node_ptr this_node) BOOST_NOEXCEPT { return NodeTraits::get_next(this_node) == this_node; } //! <b>Effects</b>: Returns true if this_node points to a sentinel node. @@ -172,7 +172,7 @@ class circular_slist_algorithms //! <b>Complexity</b>: Constant //! //! <b>Throws</b>: Nothing. - BOOST_INTRUSIVE_FORCEINLINE static bool is_sentinel(const_node_ptr this_node) BOOST_NOEXCEPT + inline static bool is_sentinel(const_node_ptr this_node) BOOST_NOEXCEPT { return NodeTraits::get_next(this_node) == node_ptr(); } //! <b>Effects</b>: Marks this node as a "sentinel" node, a special state that is different from "empty", @@ -181,7 +181,7 @@ class circular_slist_algorithms //! <b>Complexity</b>: Constant //! //! <b>Throws</b>: Nothing. - BOOST_INTRUSIVE_FORCEINLINE static void set_sentinel(node_ptr this_node) BOOST_NOEXCEPT + inline static void set_sentinel(node_ptr this_node) BOOST_NOEXCEPT { NodeTraits::set_next(this_node, node_ptr()); } //! <b>Requires</b>: this_node and prev_init_node must be in the same circular list. @@ -193,7 +193,7 @@ class circular_slist_algorithms //! <b>Complexity</b>: Linear to the number of elements between prev_init_node and this_node. //! //! <b>Throws</b>: Nothing. - BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_previous_node(node_ptr prev_init_node, node_ptr this_node) BOOST_NOEXCEPT + inline static node_ptr get_previous_node(node_ptr prev_init_node, node_ptr this_node) BOOST_NOEXCEPT { return base_t::get_previous_node(prev_init_node, this_node); } //! <b>Requires</b>: this_node must be in a circular list or be an empty circular list. @@ -203,7 +203,7 @@ class circular_slist_algorithms //! <b>Complexity</b>: Linear to the number of elements in the circular list. //! //! <b>Throws</b>: Nothing. - BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_previous_node(node_ptr this_node) BOOST_NOEXCEPT + inline static node_ptr get_previous_node(node_ptr this_node) BOOST_NOEXCEPT { return base_t::get_previous_node(this_node, this_node); } //! <b>Requires</b>: this_node must be in a circular list or be an empty circular list. @@ -213,7 +213,7 @@ class circular_slist_algorithms //! <b>Complexity</b>: Linear to the number of elements in the circular list. //! //! <b>Throws</b>: Nothing. - BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_previous_previous_node(node_ptr this_node) BOOST_NOEXCEPT + inline static node_ptr get_previous_previous_node(node_ptr this_node) BOOST_NOEXCEPT { return get_previous_previous_node(this_node, this_node); } //! <b>Requires</b>: this_node and p must be in the same circular list. @@ -276,7 +276,7 @@ class circular_slist_algorithms //! <b>Complexity</b>: Linear to the number of elements in the circular list. //! //! <b>Throws</b>: Nothing. - BOOST_INTRUSIVE_FORCEINLINE static void link_before (node_ptr nxt_node, node_ptr this_node) BOOST_NOEXCEPT + inline static void link_before (node_ptr nxt_node, node_ptr this_node) BOOST_NOEXCEPT { base_t::link_after(get_previous_node(nxt_node), this_node); } //! <b>Requires</b>: this_node and other_node must be nodes inserted @@ -453,7 +453,7 @@ class circular_slist_algorithms //! //! <b>Throws</b>: Nothing. template<class Disposer> - BOOST_INTRUSIVE_FORCEINLINE static std::size_t detach_and_dispose(node_ptr p, Disposer disposer) BOOST_NOEXCEPT + inline static std::size_t detach_and_dispose(node_ptr p, Disposer disposer) BOOST_NOEXCEPT { return base_t::unlink_after_and_dispose(p, p, disposer); } }; diff --git a/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/common_slist_algorithms.hpp b/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/common_slist_algorithms.hpp index 8310231e31..0965079ba9 100644 --- a/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/common_slist_algorithms.hpp +++ b/contrib/restricted/boost/intrusive/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 //! //! <b>Throws</b>: Nothing. template<class Disposer> - BOOST_INTRUSIVE_FORCEINLINE static void unlink_after_and_dispose(node_ptr bb, Disposer disposer) BOOST_NOEXCEPT + inline static void unlink_after_and_dispose(node_ptr bb, Disposer disposer) BOOST_NOEXCEPT { node_ptr i = node_traits::get_next(bb); node_traits::set_next(bb, node_traits::get_next(i)); diff --git a/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/default_header_holder.hpp b/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/default_header_holder.hpp index 42f35d2be7..ba665e79ba 100644 --- a/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/default_header_holder.hpp +++ b/contrib/restricted/boost/intrusive/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/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/ebo_functor_holder.hpp b/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/ebo_functor_holder.hpp index 8883166783..1213112c74 100644 --- a/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/ebo_functor_holder.hpp +++ b/contrib/restricted/boost/intrusive/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<class Arg1, class Arg2> - BOOST_INTRUSIVE_FORCEINLINE ebo_functor_holder(BOOST_FWD_REF(Arg1) arg1, BOOST_FWD_REF(Arg2) arg2) + inline ebo_functor_holder(BOOST_FWD_REF(Arg1) arg1, BOOST_FWD_REF(Arg2) arg2) : t_(::boost::forward<Arg1>(arg1), ::boost::forward<Arg2>(arg2)) {} - 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<T, Tag, false> 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<class Arg1, class Arg2> - BOOST_INTRUSIVE_FORCEINLINE ebo_functor_holder(BOOST_FWD_REF(Arg1) arg1, BOOST_FWD_REF(Arg2) arg2) + inline ebo_functor_holder(BOOST_FWD_REF(Arg1) arg1, BOOST_FWD_REF(Arg2) arg2) : T(::boost::forward<Arg1>(arg1), ::boost::forward<Arg2>(arg2)) {} - BOOST_INTRUSIVE_FORCEINLINE ebo_functor_holder(const ebo_functor_holder &x) + inline ebo_functor_holder(const ebo_functor_holder &x) : T(static_cast<const T&>(x)) {} - 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/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/equal_to_value.hpp b/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/equal_to_value.hpp index c5d9e5305c..48b1f411c3 100644 --- a/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/equal_to_value.hpp +++ b/contrib/restricted/boost/intrusive/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/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/exception_disposer.hpp b/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/exception_disposer.hpp index 0e21faebaa..f76e89172c 100644 --- a/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/exception_disposer.hpp +++ b/contrib/restricted/boost/intrusive/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/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/generic_hook.hpp b/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/generic_hook.hpp index 6e43f90d9c..e7b62c6500 100644 --- a/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/generic_hook.hpp +++ b/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/generic_hook.hpp @@ -27,7 +27,6 @@ #include <boost/intrusive/detail/assert.hpp> #include <boost/intrusive/detail/node_holder.hpp> #include <boost/intrusive/detail/algo_type.hpp> -#include <boost/static_assert.hpp> namespace boost { namespace intrusive { @@ -41,7 +40,7 @@ struct link_dispatch {}; template<class Hook> -BOOST_INTRUSIVE_FORCEINLINE void destructor_impl(Hook &hook, detail::link_dispatch<safe_link>) +inline void destructor_impl(Hook &hook, detail::link_dispatch<safe_link>) { //If this assertion raises, you might have destroyed an object //while it was still inserted in a container that is alive. //If so, remove the object from the container before destroying it. @@ -49,11 +48,11 @@ BOOST_INTRUSIVE_FORCEINLINE void destructor_impl(Hook &hook, detail::link_dispat } template<class Hook> -BOOST_INTRUSIVE_FORCEINLINE void destructor_impl(Hook &hook, detail::link_dispatch<auto_unlink>) +inline void destructor_impl(Hook &hook, detail::link_dispatch<auto_unlink>) { hook.unlink(); } template<class Hook> -BOOST_INTRUSIVE_FORCEINLINE void destructor_impl(Hook &, detail::link_dispatch<normal_link>) +inline void destructor_impl(Hook &, detail::link_dispatch<normal_link>) {} } //namespace detail { @@ -161,54 +160,54 @@ 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<node_ptr>::pointer_to(static_cast<node&>(*this)); } - BOOST_INTRUSIVE_FORCEINLINE const_node_ptr this_ptr() const BOOST_NOEXCEPT + inline const_node_ptr this_ptr() const BOOST_NOEXCEPT { return pointer_traits<const_node_ptr>::pointer_to(static_cast<const node&>(*this)); } 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<hooktags::link_mode>()); } - BOOST_INTRUSIVE_FORCEINLINE void swap_nodes(generic_hook &other) BOOST_NOEXCEPT + inline void swap_nodes(generic_hook &other) BOOST_NOEXCEPT { node_algorithms::swap_nodes (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 )); + BOOST_INTRUSIVE_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 )); + BOOST_INTRUSIVE_STATIC_ASSERT(( (int)hooktags::link_mode == (int)auto_unlink )); node_ptr n(this->this_ptr()); if(!node_algorithms::inited(n)){ node_algorithms::unlink(n); diff --git a/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/hook_traits.hpp b/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/hook_traits.hpp index 06713487fc..c33ede0dcd 100644 --- a/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/hook_traits.hpp +++ b/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/hook_traits.hpp @@ -28,7 +28,6 @@ #include <boost/intrusive/detail/mpl.hpp> #include <boost/move/detail/to_raw_pointer.hpp> #include <boost/intrusive/detail/node_holder.hpp> -#include <boost/assert.hpp> namespace boost { namespace intrusive { @@ -47,8 +46,6 @@ struct bhtraits_base template rebind_pointer<T>::type pointer; typedef typename pointer_traits<node_ptr>:: template rebind_pointer<const T>::type const_pointer; - //typedef typename pointer_traits<pointer>::reference reference; - //typedef typename pointer_traits<const_pointer>::reference const_reference; typedef T & reference; typedef 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>::pointer_to (static_cast<reference>(static_cast<node_holder_reference>(*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<const_pointer>::pointer_to (static_cast<const_reference>(static_cast<const_node_holder_reference>(*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<node_ptr>::pointer_to (static_cast<node_reference>(static_cast<node_holder_reference>(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<const_node_ptr>::pointer_to (static_cast<const_node_reference>(static_cast<const_node_holder_reference>(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<node_ptr>::pointer_to (static_cast<node_reference>(static_cast<hook_reference>(value.*P))); } - BOOST_INTRUSIVE_FORCEINLINE static const_node_ptr to_node_ptr(const_reference value) + inline static const_node_ptr to_node_ptr(const_reference value) { return pointer_traits<const_node_ptr>::pointer_to (static_cast<const_node_reference>(static_cast<const_hook_reference>(value.*P))); } - BOOST_INTRUSIVE_FORCEINLINE static pointer to_value_ptr(node_ptr n) + inline static pointer to_value_ptr(node_ptr n) { return pointer_traits<pointer>::pointer_to (*detail::parent_from_member<T, Hook> (static_cast<Hook*>(boost::movelib::to_raw_pointer(n)), P)); } - BOOST_INTRUSIVE_FORCEINLINE static const_pointer to_value_ptr(const_node_ptr n) + inline static const_pointer to_value_ptr(const_node_ptr n) { return pointer_traits<const_pointer>::pointer_to (*detail::parent_from_member<T, Hook> @@ -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<node*>(boost::movelib::to_raw_pointer(Functor::to_hook_ptr(value))); } - static const_node_ptr to_node_ptr(const_reference value) + inline static const_node_ptr to_node_ptr(const_reference value) { return static_cast<const node*>(boost::movelib::to_raw_pointer(Functor::to_hook_ptr(value))); } - 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<hook_type*>(&*n)); } - static const_hook_ptr to_hook_ptr(const_node_ptr n) + inline static const_hook_ptr to_hook_ptr(const_node_ptr n) { return const_hook_ptr(&*static_cast<const hook_type*>(&*n)); } }; diff --git a/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/iiterator.hpp b/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/iiterator.hpp index 5ab1de2bb1..75b6d83845 100644 --- a/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/iiterator.hpp +++ b/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/iiterator.hpp @@ -84,15 +84,15 @@ template<class NodePtr, class StoredPointer, bool StatefulValueTraits = true> 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<class NodePtr, class StoredPointer> struct iiterator_members<NodePtr, StoredPointer, false> { - 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/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/iterator.hpp b/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/iterator.hpp index ec91cd4f2c..d0ca41c332 100644 --- a/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/iterator.hpp +++ b/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/iterator.hpp @@ -181,7 +181,7 @@ struct iterator_disable_if_tag_difference_type //////////////////// template<class InputIt> -BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_tag<InputIt, std::input_iterator_tag>::type +inline typename iterator_enable_if_tag<InputIt, std::input_iterator_tag>::type iterator_advance(InputIt& it, typename iter_difference<InputIt>::type n) { while(n--) @@ -197,7 +197,7 @@ typename iterator_enable_if_tag<InputIt, std::forward_iterator_tag>::type } template<class InputIt> -BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_tag<InputIt, std::bidirectional_iterator_tag>::type +inline typename iterator_enable_if_tag<InputIt, std::bidirectional_iterator_tag>::type iterator_advance(InputIt& it, typename iter_difference<InputIt>::type n) { for (; 0 < n; --n) @@ -207,14 +207,14 @@ BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_tag<InputIt, std::bidire } template<class InputIt, class Distance> -BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_tag<InputIt, std::random_access_iterator_tag>::type +inline typename iterator_enable_if_tag<InputIt, std::random_access_iterator_tag>::type iterator_advance(InputIt& it, Distance n) { it += n; } template<class InputIt, class Distance> -BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_tag<InputIt, std::random_access_iterator_tag, InputIt>::type +inline typename iterator_enable_if_tag<InputIt, std::random_access_iterator_tag, InputIt>::type make_iterator_advance(InputIt it, Distance n) { (iterator_advance)(it, n); @@ -222,14 +222,14 @@ BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_tag<InputIt, std::random } template<class It> -BOOST_INTRUSIVE_FORCEINLINE +inline void iterator_uadvance(It& it, typename iter_size<It>::type n) { (iterator_advance)(it, (typename iterator_traits<It>::difference_type)n); } template<class It> -BOOST_INTRUSIVE_FORCEINLINE +inline It make_iterator_uadvance(It it, typename iter_size<It>::type n) { (iterator_uadvance)(it, n); @@ -253,7 +253,7 @@ typename iterator_disable_if_tag_difference_type } template<class InputIt> -BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_tag_difference_type +inline typename iterator_enable_if_tag_difference_type <InputIt, std::random_access_iterator_tag>::type iterator_distance(InputIt first, InputIt last) { @@ -266,7 +266,7 @@ BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_tag_difference_type //////////////////////////////////////// template<class It> -BOOST_INTRUSIVE_FORCEINLINE typename iter_size<It>::type +inline typename iter_size<It>::type iterator_udistance(It first, It last) { return (typename iter_size<It>::type)(iterator_distance)(first, last); @@ -277,14 +277,14 @@ BOOST_INTRUSIVE_FORCEINLINE typename iter_size<It>::type //////////////////////////////////////// template<class InputIt> -BOOST_INTRUSIVE_FORCEINLINE InputIt iterator_next(InputIt it, typename iter_difference<InputIt>::type n) +inline InputIt iterator_next(InputIt it, typename iter_difference<InputIt>::type n) { (iterator_advance)(it, n); return it; } template<class InputIt> -BOOST_INTRUSIVE_FORCEINLINE InputIt iterator_unext(InputIt it, typename iterator_traits<InputIt>::size_type n) +inline InputIt iterator_unext(InputIt it, typename iterator_traits<InputIt>::size_type n) { (iterator_uadvance)(it, n); return it; @@ -295,11 +295,11 @@ BOOST_INTRUSIVE_FORCEINLINE InputIt iterator_unext(InputIt it, typename iterator //////////////////////////////////////// template<class I> -BOOST_INTRUSIVE_FORCEINLINE typename iterator_traits<I>::pointer iterator_arrow_result(const I &i) +inline typename iterator_traits<I>::pointer iterator_arrow_result(const I &i) { return i.operator->(); } template<class T> -BOOST_INTRUSIVE_FORCEINLINE T * iterator_arrow_result(T *p) +inline T * iterator_arrow_result(T *p) { return p; } } //namespace intrusive diff --git a/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/key_nodeptr_comp.hpp b/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/key_nodeptr_comp.hpp index 1029a3404a..4e7f7c27da 100644 --- a/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/key_nodeptr_comp.hpp +++ b/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/key_nodeptr_comp.hpp @@ -78,40 +78,40 @@ public: static const bool value = same_type || is_convertible<P1, const_node_ptr>::value; }; - BOOST_INTRUSIVE_FORCEINLINE base_t base() const + inline base_t base() const { return static_cast<const base_t&>(*this); } - 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<class T1> - BOOST_INTRUSIVE_FORCEINLINE bool operator()(const T1 &t1, typename enable_if_c< is_same_or_nodeptr_convertible<T1>::value, sfinae_type* >::type = 0) const + inline bool operator()(const T1 &t1, typename enable_if_c< is_same_or_nodeptr_convertible<T1>::value, sfinae_type* >::type = 0) const { return base().get()(key_of_value()(*traits_->to_value_ptr(t1))); } //operator() 2 arg //pred(pnode, pnode) template<class T1, class T2> - BOOST_INTRUSIVE_FORCEINLINE bool operator() + inline bool operator() (const T1 &t1, const T2 &t2, typename enable_if_c< is_same_or_nodeptr_convertible<T1>::value && is_same_or_nodeptr_convertible<T2>::value, sfinae_type* >::type = 0) const { return base()(*traits_->to_value_ptr(t1), *traits_->to_value_ptr(t2)); } //pred(pnode, key) template<class T1, class T2> - BOOST_INTRUSIVE_FORCEINLINE bool operator() + inline bool operator() (const T1 &t1, const T2 &t2, typename enable_if_c< is_same_or_nodeptr_convertible<T1>::value && !is_same_or_nodeptr_convertible<T2>::value, sfinae_type* >::type = 0) const { return base()(*traits_->to_value_ptr(t1), t2); } //pred(key, pnode) template<class T1, class T2> - BOOST_INTRUSIVE_FORCEINLINE bool operator() + inline bool operator() (const T1 &t1, const T2 &t2, typename enable_if_c< !is_same_or_nodeptr_convertible<T1>::value && is_same_or_nodeptr_convertible<T2>::value, sfinae_type* >::type = 0) const { return base()(t1, *traits_->to_value_ptr(t2)); } //pred(key, key) template<class T1, class T2> - BOOST_INTRUSIVE_FORCEINLINE bool operator() + inline bool operator() (const T1 &t1, const T2 &t2, typename enable_if_c< !is_same_or_nodeptr_convertible<T1>::value && !is_same_or_nodeptr_convertible<T2>::value, sfinae_type* >::type = 0) const { return base()(t1, t2); } diff --git a/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/list_iterator.hpp b/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/list_iterator.hpp index f301a4b8e7..0a10e84872 100644 --- a/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/list_iterator.hpp +++ b/contrib/restricted/boost/intrusive/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<list_iterator&> (*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<list_iterator&> (*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_<stateful_value_traits>()); } - BOOST_INTRUSIVE_FORCEINLINE list_iterator<ValueTraits, false> unconst() const + inline list_iterator<ValueTraits, false> unconst() const { return list_iterator<ValueTraits, false>(this->pointed_node(), this->get_value_traits()); } 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<node_ptr, const_value_traits_ptr, stateful_value_traits> members_; diff --git a/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/mpl.hpp b/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/mpl.hpp index d86fa4f3c9..cf6c745578 100644 --- a/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/mpl.hpp +++ b/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/mpl.hpp @@ -66,6 +66,12 @@ using boost::move_detail::eval_if_c; using boost::move_detail::eval_if; using boost::move_detail::unvoid_ref; using boost::move_detail::add_const_if_c; +using boost::move_detail::is_integral; +using boost::move_detail::make_unsigned; +using boost::move_detail::is_enum; +using boost::move_detail::is_floating_point; +using boost::move_detail::is_scalar; +using boost::move_detail::is_unsigned; template<std::size_t S> struct ls_zeros diff --git a/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/node_cloner_disposer.hpp b/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/node_cloner_disposer.hpp index 97e8d15326..a836699f32 100644 --- a/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/node_cloner_disposer.hpp +++ b/contrib/restricted/boost/intrusive/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_traits::link_mode>::value; - BOOST_INTRUSIVE_FORCEINLINE node_disposer(F f, const ValueTraits *cont) + inline node_disposer(F f, const ValueTraits *cont) : base_t(f), traits_(cont) {} - 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/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/parent_from_member.hpp b/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/parent_from_member.hpp index 275229ab47..8f1156e354 100644 --- a/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/parent_from_member.hpp +++ b/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/parent_from_member.hpp @@ -26,8 +26,7 @@ #if defined(_MSC_VER) #define BOOST_INTRUSIVE_MSVC_ABI_PTR_TO_MEMBER - #include <boost/static_assert.hpp> -#endif + #endif namespace boost { namespace intrusive { @@ -49,7 +48,7 @@ BOOST_INTRUSIVE_FORCEINLINE std::ptrdiff_t offset_from_pointer_to_member(const M //MSVC ABI can use up to 3 int32 to represent pointer to member data //with virtual base classes, in those cases there is no simple to //obtain the address of the parent. So static assert to avoid runtime errors - BOOST_STATIC_ASSERT( sizeof(caster) == sizeof(int) ); + BOOST_INTRUSIVE_STATIC_ASSERT( sizeof(caster) == sizeof(int) ); caster.ptr_to_member = ptr_to_member; return std::ptrdiff_t(caster.offset); @@ -91,25 +90,15 @@ BOOST_INTRUSIVE_FORCEINLINE std::ptrdiff_t offset_from_pointer_to_member(const M template<class Parent, class Member> BOOST_INTRUSIVE_FORCEINLINE Parent *parent_from_member(Member *member, const Member Parent::* ptr_to_member) { - return static_cast<Parent*> - ( - static_cast<void*> - ( - static_cast<char*>(static_cast<void*>(member)) - offset_from_pointer_to_member(ptr_to_member) - ) - ); + return reinterpret_cast<Parent*> + (reinterpret_cast<std::size_t>(member) - static_cast<std::size_t>(offset_from_pointer_to_member(ptr_to_member))); } template<class Parent, class Member> BOOST_INTRUSIVE_FORCEINLINE const Parent *parent_from_member(const Member *member, const Member Parent::* ptr_to_member) { - return static_cast<const Parent*> - ( - static_cast<const void*> - ( - static_cast<const char*>(static_cast<const void*>(member)) - offset_from_pointer_to_member(ptr_to_member) - ) - ); + return reinterpret_cast<const Parent*> + ( reinterpret_cast<std::size_t>(member) - static_cast<std::size_t>(offset_from_pointer_to_member(ptr_to_member)) ); } } //namespace detail { diff --git a/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/simple_disposers.hpp b/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/simple_disposers.hpp index 6b9bd4bc63..41d2e24788 100644 --- a/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/simple_disposers.hpp +++ b/contrib/restricted/boost/intrusive/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/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/size_holder.hpp b/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/size_holder.hpp index bd14dc5049..ba5f418f9d 100644 --- a/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/size_holder.hpp +++ b/contrib/restricted/boost/intrusive/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<false, SizeType, Tag> 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/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/slist_iterator.hpp b/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/slist_iterator.hpp index 9c5ee27470..64387c4a75 100644 --- a/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/slist_iterator.hpp +++ b/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/slist_iterator.hpp @@ -27,7 +27,6 @@ #include <boost/intrusive/detail/std_fwd.hpp> #include <boost/intrusive/detail/iiterator.hpp> #include <boost/intrusive/detail/mpl.hpp> -#include <boost/static_assert.hpp> namespace boost { namespace intrusive { @@ -63,75 +62,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_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<slist_iterator&>(*this); } - BOOST_INTRUSIVE_FORCEINLINE const_value_traits_ptr get_value_traits() const + inline const_value_traits_ptr get_value_traits() const { return members_.get_ptr(); } - 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<slist_iterator&> (*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_<stateful_value_traits>()); } - BOOST_INTRUSIVE_FORCEINLINE slist_iterator<ValueTraits, false> unconst() const + inline slist_iterator<ValueTraits, false> unconst() const { return slist_iterator<ValueTraits, false>(this->pointed_node(), this->get_value_traits()); } 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<node_ptr, const_value_traits_ptr, stateful_value_traits> members_; diff --git a/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/tree_iterator.hpp b/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/tree_iterator.hpp index ba1375f8c8..f97cecb31f 100644 --- a/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/tree_iterator.hpp +++ b/contrib/restricted/boost/intrusive/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_<stateful_value_traits>()); } - BOOST_INTRUSIVE_FORCEINLINE const_value_traits_ptr get_value_traits() const + inline const_value_traits_ptr get_value_traits() const { return members_.get_ptr(); } tree_iterator end_iterator_from_it() const @@ -167,10 +167,10 @@ class tree_iterator { return tree_iterator<value_traits, false>(this->pointed_node(), this->get_value_traits()); } 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<node_ptr, const_value_traits_ptr, stateful_value_traits> members_; diff --git a/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/tree_value_compare.hpp b/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/tree_value_compare.hpp index c78da0acd6..d8b88f62de 100644 --- a/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/tree_value_compare.hpp +++ b/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/tree_value_compare.hpp @@ -59,67 +59,67 @@ struct tree_value_compare typedef boost::intrusive::detail::ebo_functor_holder<KeyCompare> 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<const key_compare &>(*this); } - BOOST_INTRUSIVE_FORCEINLINE Ret operator()(const key_type &key) const + inline Ret operator()(const key_type &key) const { return this->key_comp()(key); } - 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<class U> - BOOST_INTRUSIVE_FORCEINLINE Ret operator()( const U &nonkey + inline Ret operator()( const U &nonkey , typename disable_if_smartref_to<U, ValuePtr>::type* = 0) const { 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<class U> - BOOST_INTRUSIVE_FORCEINLINE Ret operator()( const key_type &key1, const U &nonkey2 + inline Ret operator()( const key_type &key1, const U &nonkey2 , typename disable_if_smartref_to<U, ValuePtr>::type* = 0) const { return this->key_comp()(key1, nonkey2); } template<class U> - BOOST_INTRUSIVE_FORCEINLINE Ret operator()( const U &nonkey1, const key_type &key2 + inline Ret operator()( const U &nonkey1, const key_type &key2 , typename disable_if_smartref_to<U, ValuePtr>::type* = 0) const { return this->key_comp()(nonkey1, key2); } template<class U> - BOOST_INTRUSIVE_FORCEINLINE Ret operator()( const value_type &value1, const U &nonvalue2 + inline Ret operator()( const value_type &value1, const U &nonvalue2 , typename disable_if_smartref_to<U, ValuePtr>::type* = 0) const { return this->key_comp()(KeyOfValue()(value1), nonvalue2); } template<class U> - BOOST_INTRUSIVE_FORCEINLINE Ret operator()( const U &nonvalue1, const value_type &value2 + inline Ret operator()( const U &nonvalue1, const value_type &value2 , typename disable_if_smartref_to<U, ValuePtr>::type* = 0) const { return this->key_comp()(nonvalue1, KeyOfValue()(value2)); } }; @@ -137,45 +137,45 @@ struct tree_value_compare<ValuePtr, KeyCompare, KeyOfValue, Ret, true> typedef boost::intrusive::detail::ebo_functor_holder<KeyCompare> base_t; - 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<const key_compare &>(*this); } - BOOST_INTRUSIVE_FORCEINLINE Ret operator()(const key_type &key) const + inline Ret operator()(const key_type &key) const { return this->key_comp()(key); } template<class U> - BOOST_INTRUSIVE_FORCEINLINE Ret operator()( const U &nonkey + inline Ret operator()( const U &nonkey , typename disable_if_smartref_to<U, ValuePtr>::type* = 0) const { 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<class U> - BOOST_INTRUSIVE_FORCEINLINE Ret operator()( const key_type &key1, const U &nonkey2 + inline Ret operator()( const key_type &key1, const U &nonkey2 , typename disable_if_smartref_to<U, ValuePtr>::type* = 0) const { return this->key_comp()(key1, nonkey2); } template<class U> - BOOST_INTRUSIVE_FORCEINLINE Ret operator()(const U &nonkey1, const key_type &key2 + inline Ret operator()(const U &nonkey1, const key_type &key2 , typename disable_if_smartref_to<U, ValuePtr>::type* = 0) const { return this->key_comp()(nonkey1, key2); } }; diff --git a/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/workaround.hpp b/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/workaround.hpp index 0011fb5bfb..f925a87a8b 100644 --- a/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/workaround.hpp +++ b/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/workaround.hpp @@ -48,8 +48,11 @@ #elif defined(BOOST_MSVC) && (_MSC_VER < 1900 || defined(_DEBUG)) //"__forceinline" and MSVC seems to have some bugs in old versions and in debug mode #define BOOST_INTRUSIVE_FORCEINLINE inline -#elif defined(BOOST_GCC) && ((__GNUC__ <= 5) || defined(__MINGW32__)) +#elif defined(BOOST_CLANG) || (defined(BOOST_GCC) && ((__GNUC__ <= 5) || defined(__MINGW32__))) //Older GCCs have problems with forceinline + //Clang can have code bloat issues with forceinline, see + //https://lists.boost.org/boost-users/2023/04/91445.php and + //https://github.com/llvm/llvm-project/issues/62202 #define BOOST_INTRUSIVE_FORCEINLINE inline #else #define BOOST_INTRUSIVE_FORCEINLINE BOOST_FORCEINLINE @@ -81,4 +84,32 @@ # define BOOST_INTRUSIVE_CATCH_END } #endif +#ifndef BOOST_NO_CXX11_STATIC_ASSERT +# ifndef BOOST_NO_CXX11_VARIADIC_MACROS +# define BOOST_INTRUSIVE_STATIC_ASSERT( ... ) static_assert(__VA_ARGS__, #__VA_ARGS__) +# else +# define BOOST_INTRUSIVE_STATIC_ASSERT( B ) static_assert(B, #B) +# endif +#else +namespace boost { +namespace intrusive { +namespace detail { + +template<bool B> +struct STATIC_ASSERTION_FAILURE; + +template<> +struct STATIC_ASSERTION_FAILURE<true>{}; + +template<unsigned> struct static_assert_test {}; + +}}} + +#define BOOST_INTRUSIVE_STATIC_ASSERT(B) \ + typedef ::boost::intrusive::detail::static_assert_test<\ + (unsigned)sizeof(::boost::intrusive::detail::STATIC_ASSERTION_FAILURE<bool(B)>)>\ + BOOST_JOIN(boost_intrusive_static_assert_typedef_, __LINE__) BOOST_ATTRIBUTE_UNUSED + +#endif + #endif //#ifndef BOOST_INTRUSIVE_DETAIL_WORKAROUND_HPP diff --git a/contrib/restricted/boost/intrusive/include/boost/intrusive/linear_slist_algorithms.hpp b/contrib/restricted/boost/intrusive/include/boost/intrusive/linear_slist_algorithms.hpp index a616d7ed71..0574f82481 100644 --- a/contrib/restricted/boost/intrusive/include/boost/intrusive/linear_slist_algorithms.hpp +++ b/contrib/restricted/boost/intrusive/include/boost/intrusive/linear_slist_algorithms.hpp @@ -151,8 +151,8 @@ class linear_slist_algorithms //! <b>Complexity</b>: Constant //! //! <b>Throws</b>: Nothing. - BOOST_INTRUSIVE_FORCEINLINE static void init_header(node_ptr this_node) BOOST_NOEXCEPT - { NodeTraits::set_next(this_node, node_ptr ()); } + inline static void init_header(node_ptr this_node) BOOST_NOEXCEPT + { NodeTraits::set_next(this_node, node_ptr()); } //! <b>Requires</b>: 'p' is the first node of a list. //! @@ -161,7 +161,7 @@ class linear_slist_algorithms //! <b>Complexity</b>: Constant time. //! //! <b>Throws</b>: Nothing. - BOOST_INTRUSIVE_FORCEINLINE static node_ptr end_node(const_node_ptr) BOOST_NOEXCEPT + inline static node_ptr end_node(const_node_ptr) BOOST_NOEXCEPT { return node_ptr(); } //! <b>Effects</b>: Returns true if this_node_points to an empty list. @@ -169,7 +169,7 @@ class linear_slist_algorithms //! <b>Complexity</b>: Constant //! //! <b>Throws</b>: Nothing. - BOOST_INTRUSIVE_FORCEINLINE static bool is_empty(const_node_ptr this_node) BOOST_NOEXCEPT + inline static bool is_empty(const_node_ptr this_node) BOOST_NOEXCEPT { return !NodeTraits::get_next(this_node); } //! <b>Effects</b>: Returns true if this_node points to a sentinel node. @@ -177,7 +177,7 @@ class linear_slist_algorithms //! <b>Complexity</b>: Constant //! //! <b>Throws</b>: Nothing. - BOOST_INTRUSIVE_FORCEINLINE static bool is_sentinel(const_node_ptr this_node) BOOST_NOEXCEPT + inline static bool is_sentinel(const_node_ptr this_node) BOOST_NOEXCEPT { return NodeTraits::get_next(this_node) == this_node; } //! <b>Effects</b>: Marks this node as a "sentinel" node, a special state that is different from "empty", @@ -186,7 +186,7 @@ class linear_slist_algorithms //! <b>Complexity</b>: Constant //! //! <b>Throws</b>: Nothing. - BOOST_INTRUSIVE_FORCEINLINE static void set_sentinel(node_ptr this_node) BOOST_NOEXCEPT + inline static void set_sentinel(node_ptr this_node) BOOST_NOEXCEPT { NodeTraits::set_next(this_node, this_node); } //! <b>Requires</b>: this_node and prev_init_node must be in the same linear list. @@ -198,7 +198,7 @@ class linear_slist_algorithms //! <b>Complexity</b>: Linear to the number of elements between prev_init_node and this_node. //! //! <b>Throws</b>: Nothing. - BOOST_INTRUSIVE_FORCEINLINE static node_ptr + inline static node_ptr get_previous_node(node_ptr prev_init_node, node_ptr this_node) BOOST_NOEXCEPT { return base_t::get_previous_node(prev_init_node, this_node); } @@ -230,7 +230,7 @@ class linear_slist_algorithms //! <b>Complexity</b>: Constant //! //! <b>Throws</b>: Nothing. - BOOST_INTRUSIVE_FORCEINLINE static void swap_trailing_nodes(node_ptr this_node, node_ptr other_node) BOOST_NOEXCEPT + inline static void swap_trailing_nodes(node_ptr this_node, node_ptr other_node) BOOST_NOEXCEPT { node_ptr this_nxt = NodeTraits::get_next(this_node); node_ptr other_nxt = NodeTraits::get_next(other_node); @@ -400,7 +400,7 @@ class linear_slist_algorithms //! //! <b>Throws</b>: Nothing. template<class Disposer> - BOOST_INTRUSIVE_FORCEINLINE static std::size_t detach_and_dispose(node_ptr p, Disposer disposer) BOOST_NOEXCEPT + inline static std::size_t detach_and_dispose(node_ptr p, Disposer disposer) BOOST_NOEXCEPT { return base_t::unlink_after_and_dispose(p, node_ptr(), disposer); } }; diff --git a/contrib/restricted/boost/intrusive/include/boost/intrusive/list.hpp b/contrib/restricted/boost/intrusive/include/boost/intrusive/list.hpp index 62291b4809..9871d97394 100644 --- a/contrib/restricted/boost/intrusive/include/boost/intrusive/list.hpp +++ b/contrib/restricted/boost/intrusive/include/boost/intrusive/list.hpp @@ -37,7 +37,6 @@ #include <boost/intrusive/detail/algorithm.hpp> #include <boost/move/utility_core.hpp> -#include <boost/static_assert.hpp> #include <boost/intrusive/detail/value_functors.hpp> #include <cstddef> //std::size_t, etc. @@ -123,14 +122,14 @@ class list_impl static const bool safemode_or_autounlink = is_safe_autounlink<value_traits::link_mode>::value; //Constant-time size is incompatible with auto-unlink hooks! - BOOST_STATIC_ASSERT(!(constant_time_size && + BOOST_INTRUSIVE_STATIC_ASSERT(!(constant_time_size && ((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 +140,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 <ValueTraits>::const_value_traits_ptr const_value_traits_ptr; - BOOST_INTRUSIVE_FORCEINLINE const_value_traits_ptr priv_value_traits_ptr() const BOOST_NOEXCEPT + inline const_value_traits_ptr priv_value_traits_ptr() const BOOST_NOEXCEPT { return pointer_traits<const_value_traits_ptr>::pointer_to(this->priv_value_traits()); } /// @endcond @@ -364,7 +363,7 @@ class list_impl //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Constant. - BOOST_INTRUSIVE_FORCEINLINE reference front() BOOST_NOEXCEPT + inline reference front() BOOST_NOEXCEPT { return *priv_value_traits().to_value_ptr(node_traits::get_next(this->get_root_node())); } //! <b>Effects</b>: Returns a const_reference to the first element of the list. @@ -372,7 +371,7 @@ class list_impl //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Constant. - BOOST_INTRUSIVE_FORCEINLINE const_reference front() const BOOST_NOEXCEPT + inline const_reference front() const BOOST_NOEXCEPT { return *priv_value_traits().to_value_ptr(node_traits::get_next(this->get_root_node())); } //! <b>Effects</b>: Returns a reference to the last element of the list. @@ -380,7 +379,7 @@ class list_impl //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Constant. - BOOST_INTRUSIVE_FORCEINLINE reference back() BOOST_NOEXCEPT + inline reference back() BOOST_NOEXCEPT { return *priv_value_traits().to_value_ptr(node_traits::get_previous(this->get_root_node())); } //! <b>Effects</b>: Returns a const_reference to the last element of the list. @@ -388,7 +387,7 @@ class list_impl //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Constant. - BOOST_INTRUSIVE_FORCEINLINE const_reference back() const BOOST_NOEXCEPT + inline const_reference back() const BOOST_NOEXCEPT { return *priv_value_traits().to_value_ptr(detail::uncast(node_traits::get_previous(this->get_root_node()))); } //! <b>Effects</b>: Returns an iterator to the first element contained in the list. @@ -396,7 +395,7 @@ class list_impl //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Constant. - BOOST_INTRUSIVE_FORCEINLINE iterator begin() BOOST_NOEXCEPT + inline iterator begin() BOOST_NOEXCEPT { return iterator(node_traits::get_next(this->get_root_node()), this->priv_value_traits_ptr()); } //! <b>Effects</b>: Returns a const_iterator to the first element contained in the list. @@ -404,7 +403,7 @@ class list_impl //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Constant. - BOOST_INTRUSIVE_FORCEINLINE const_iterator begin() const BOOST_NOEXCEPT + inline const_iterator begin() const BOOST_NOEXCEPT { return this->cbegin(); } //! <b>Effects</b>: Returns a const_iterator to the first element contained in the list. @@ -412,7 +411,7 @@ class list_impl //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Constant. - BOOST_INTRUSIVE_FORCEINLINE const_iterator cbegin() const BOOST_NOEXCEPT + inline const_iterator cbegin() const BOOST_NOEXCEPT { return const_iterator(node_traits::get_next(this->get_root_node()), this->priv_value_traits_ptr()); } //! <b>Effects</b>: Returns an iterator to the end of the list. @@ -420,7 +419,7 @@ class list_impl //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Constant. - BOOST_INTRUSIVE_FORCEINLINE iterator end() BOOST_NOEXCEPT + inline iterator end() BOOST_NOEXCEPT { return iterator(this->get_root_node(), this->priv_value_traits_ptr()); } //! <b>Effects</b>: Returns a const_iterator to the end of the list. @@ -428,7 +427,7 @@ class list_impl //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Constant. - BOOST_INTRUSIVE_FORCEINLINE const_iterator end() const BOOST_NOEXCEPT + inline const_iterator end() const BOOST_NOEXCEPT { return this->cend(); } //! <b>Effects</b>: Returns a constant iterator to the end of the list. @@ -436,7 +435,7 @@ class list_impl //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Constant. - BOOST_INTRUSIVE_FORCEINLINE const_iterator cend() const BOOST_NOEXCEPT + inline const_iterator cend() const BOOST_NOEXCEPT { return const_iterator(detail::uncast(this->get_root_node()), this->priv_value_traits_ptr()); } //! <b>Effects</b>: Returns a reverse_iterator pointing to the beginning @@ -445,7 +444,7 @@ class list_impl //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Constant. - BOOST_INTRUSIVE_FORCEINLINE reverse_iterator rbegin() BOOST_NOEXCEPT + inline reverse_iterator rbegin() BOOST_NOEXCEPT { return reverse_iterator(this->end()); } //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning @@ -454,7 +453,7 @@ class list_impl //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Constant. - BOOST_INTRUSIVE_FORCEINLINE const_reverse_iterator rbegin() const BOOST_NOEXCEPT + inline const_reverse_iterator rbegin() const BOOST_NOEXCEPT { return this->crbegin(); } //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning @@ -463,7 +462,7 @@ class list_impl //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Constant. - BOOST_INTRUSIVE_FORCEINLINE const_reverse_iterator crbegin() const BOOST_NOEXCEPT + inline const_reverse_iterator crbegin() const BOOST_NOEXCEPT { return const_reverse_iterator(end()); } //! <b>Effects</b>: Returns a reverse_iterator pointing to the end @@ -472,7 +471,7 @@ class list_impl //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Constant. - BOOST_INTRUSIVE_FORCEINLINE reverse_iterator rend() BOOST_NOEXCEPT + inline reverse_iterator rend() BOOST_NOEXCEPT { return reverse_iterator(begin()); } //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the end @@ -481,7 +480,7 @@ class list_impl //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Constant. - BOOST_INTRUSIVE_FORCEINLINE const_reverse_iterator rend() const BOOST_NOEXCEPT + inline const_reverse_iterator rend() const BOOST_NOEXCEPT { return this->crend(); } //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the end @@ -490,7 +489,7 @@ class list_impl //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Constant. - BOOST_INTRUSIVE_FORCEINLINE const_reverse_iterator crend() const BOOST_NOEXCEPT + inline const_reverse_iterator crend() const BOOST_NOEXCEPT { return const_reverse_iterator(this->begin()); } //! <b>Precondition</b>: end_iterator must be a valid end iterator @@ -501,7 +500,7 @@ class list_impl //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Constant. - BOOST_INTRUSIVE_FORCEINLINE static list_impl &container_from_end_iterator(iterator end_iterator) BOOST_NOEXCEPT + inline static list_impl &container_from_end_iterator(iterator end_iterator) BOOST_NOEXCEPT { return list_impl::priv_container_from_end_iterator(end_iterator); } //! <b>Precondition</b>: end_iterator must be a valid end const_iterator @@ -512,7 +511,7 @@ class list_impl //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Constant. - BOOST_INTRUSIVE_FORCEINLINE static const list_impl &container_from_end_iterator(const_iterator end_iterator) BOOST_NOEXCEPT + inline static const list_impl &container_from_end_iterator(const_iterator end_iterator) BOOST_NOEXCEPT { return list_impl::priv_container_from_end_iterator(end_iterator); } //! <b>Effects</b>: Returns the number of the elements contained in the list. @@ -523,7 +522,7 @@ class list_impl //! if constant-time size option is disabled. Constant time otherwise. //! //! <b>Note</b>: Does not affect the validity of iterators and references. - BOOST_INTRUSIVE_FORCEINLINE size_type size() const BOOST_NOEXCEPT + inline size_type size() const BOOST_NOEXCEPT { BOOST_IF_CONSTEXPR(constant_time_size) return this->priv_size_traits().get_size(); @@ -538,7 +537,7 @@ class list_impl //! <b>Complexity</b>: Constant. //! //! <b>Note</b>: Does not affect the validity of iterators and references. - BOOST_INTRUSIVE_FORCEINLINE bool empty() const BOOST_NOEXCEPT + inline bool empty() const BOOST_NOEXCEPT { return node_algorithms::unique(this->get_root_node()); } //! <b>Effects</b>: Swaps the elements of x and *this. @@ -563,7 +562,7 @@ class list_impl //! <b>Complexity</b>: Linear to the number of shifts. //! //! <b>Note</b>: Does not affect the validity of iterators and references. - BOOST_INTRUSIVE_FORCEINLINE void shift_backwards(size_type n = 1) BOOST_NOEXCEPT + inline void shift_backwards(size_type n = 1) BOOST_NOEXCEPT { node_algorithms::move_forward(this->get_root_node(), n); } //! <b>Effects</b>: Moves forward all the elements, so that the second @@ -575,7 +574,7 @@ class list_impl //! <b>Complexity</b>: Linear to the number of shifts. //! //! <b>Note</b>: Does not affect the validity of iterators and references. - BOOST_INTRUSIVE_FORCEINLINE void shift_forward(size_type n = 1) BOOST_NOEXCEPT + inline void shift_forward(size_type n = 1) BOOST_NOEXCEPT { node_algorithms::move_backwards(this->get_root_node(), n); } //! <b>Effects</b>: Erases the element pointed by i of the list. @@ -590,7 +589,7 @@ class list_impl //! //! <b>Note</b>: 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()); } //! <b>Requires</b>: b and e must be valid iterators to elements in *this. @@ -608,7 +607,7 @@ class list_impl //! //! <b>Note</b>: 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()); @@ -1187,14 +1186,14 @@ class list_impl //! <b>Effects</b>: Removes adjacent duplicate elements or adjacent //! elements that are equal from the list. No destructors are called. //! - //! <b>Throws</b>: If std::equal_to<value_type throws. Basic guarantee. + //! <b>Throws</b>: If the comparison operator throws. Basic guarantee. //! //! <b>Complexity</b>: Linear time (size()-1 comparisons calls to pred()). //! //! <b>Note</b>: The relative order of elements that are not removed is unchanged, //! and iterators to elements that are not removed remain valid. void unique() - { this->unique_and_dispose(std::equal_to<value_type>(), detail::null_disposer()); } + { this->unique_and_dispose(value_equal<value_type>(), detail::null_disposer()); } //! <b>Effects</b>: Removes adjacent duplicate elements or adjacent //! elements that satisfy some binary predicate from the list. @@ -1216,7 +1215,7 @@ class list_impl //! elements that are equal from the list. //! Disposer::operator()(pointer) is called for every removed element. //! - //! <b>Throws</b>: If std::equal_to<value_type throws. Basic guarantee. + //! <b>Throws</b>: If the equality operator throws. Basic guarantee. //! //! <b>Complexity</b>: Linear time (size()-1) comparisons equality comparisons. //! @@ -1224,7 +1223,7 @@ class list_impl //! and iterators to elements that are not removed remain valid. template<class Disposer> void unique_and_dispose(Disposer disposer) - { this->unique_and_dispose(std::equal_to<value_type>(), disposer); } + { this->unique_and_dispose(value_equal<value_type>(), disposer); } //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. //! @@ -1272,7 +1271,7 @@ class list_impl //! is stateless. static iterator s_iterator_to(reference value) BOOST_NOEXCEPT { - BOOST_STATIC_ASSERT((!stateful_value_traits)); + BOOST_INTRUSIVE_STATIC_ASSERT((!stateful_value_traits)); BOOST_INTRUSIVE_INVARIANT_ASSERT(!node_algorithms::inited(value_traits::to_node_ptr(value))); return iterator(value_traits::to_node_ptr(value), const_value_traits_ptr()); } @@ -1290,7 +1289,7 @@ class list_impl //! is stateless. static const_iterator s_iterator_to(const_reference value) BOOST_NOEXCEPT { - BOOST_STATIC_ASSERT((!stateful_value_traits)); + BOOST_INTRUSIVE_STATIC_ASSERT((!stateful_value_traits)); reference r =*detail::uncast(pointer_traits<const_pointer>::pointer_to(value)); BOOST_INTRUSIVE_INVARIANT_ASSERT(!node_algorithms::inited(value_traits::to_node_ptr(r))); return const_iterator(value_traits::to_node_ptr(r), const_value_traits_ptr()); @@ -1371,22 +1370,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 @@ -1394,7 +1393,7 @@ class list_impl private: static list_impl &priv_container_from_end_iterator(const const_iterator &end_iterator) BOOST_NOEXCEPT { - BOOST_STATIC_ASSERT((has_container_from_iterator)); + BOOST_INTRUSIVE_STATIC_ASSERT((has_container_from_iterator)); node_ptr p = end_iterator.pointed_node(); header_holder_type* h = header_holder_type::get_holder(p); root_plus_size* r = detail::parent_from_member @@ -1466,7 +1465,7 @@ class list #endif >::type Base; //Assert if passed value traits are compatible with the type - BOOST_STATIC_ASSERT((detail::is_same<typename Base::value_traits::value_type, T>::value)); + BOOST_INTRUSIVE_STATIC_ASSERT((detail::is_same<typename Base::value_traits::value_type, T>::value)); BOOST_MOVABLE_BUT_NOT_COPYABLE(list) public: @@ -1474,38 +1473,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<class Iterator> - BOOST_INTRUSIVE_FORCEINLINE list(Iterator b, Iterator e, const value_traits &v_traits = value_traits()) + inline list(Iterator b, Iterator e, const value_traits &v_traits = value_traits()) : Base(b, e, v_traits) {} - 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<list &>(this->Base::operator=(BOOST_MOVE_BASE(Base, x))); } template <class Cloner, class Disposer> - BOOST_INTRUSIVE_FORCEINLINE void clone_from(const list &src, Cloner cloner, Disposer disposer) + inline void clone_from(const list &src, Cloner cloner, Disposer disposer) { Base::clone_from(src, cloner, disposer); } template <class Cloner, class Disposer> - BOOST_INTRUSIVE_FORCEINLINE void clone_from(BOOST_RV_REF(list) src, Cloner cloner, Disposer disposer) + inline void clone_from(BOOST_RV_REF(list) src, Cloner cloner, Disposer disposer) { Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer); } - BOOST_INTRUSIVE_FORCEINLINE static list &container_from_end_iterator(iterator end_iterator) BOOST_NOEXCEPT + inline static list &container_from_end_iterator(iterator end_iterator) BOOST_NOEXCEPT { return static_cast<list &>(Base::container_from_end_iterator(end_iterator)); } - BOOST_INTRUSIVE_FORCEINLINE static const list &container_from_end_iterator(const_iterator end_iterator) BOOST_NOEXCEPT + inline static const list &container_from_end_iterator(const_iterator end_iterator) BOOST_NOEXCEPT { return static_cast<const list &>(Base::container_from_end_iterator(end_iterator)); } }; diff --git a/contrib/restricted/boost/intrusive/include/boost/intrusive/pack_options.hpp b/contrib/restricted/boost/intrusive/include/boost/intrusive/pack_options.hpp index 66761d7625..20e093e947 100644 --- a/contrib/restricted/boost/intrusive/include/boost/intrusive/pack_options.hpp +++ b/contrib/restricted/boost/intrusive/include/boost/intrusive/pack_options.hpp @@ -14,7 +14,7 @@ #define BOOST_INTRUSIVE_PACK_OPTIONS_HPP #include <boost/intrusive/detail/config_begin.hpp> - +#include <boost/intrusive/detail/workaround.hpp> #if defined(BOOST_HAS_PRAGMA_ONCE) # pragma once #endif @@ -338,7 +338,7 @@ struct pack_options //! //! typedef pack_options< empty_default, typename my_pointer<void*> >::type::my_pointer_type type; //! -//! BOOST_STATIC_ASSERT(( boost::is_same<type, void>::value )); +//! BOOST_INTRUSIVE_STATIC_ASSERT(( boost::is_same<type, void>::value )); //! //! \endcode #define BOOST_INTRUSIVE_OPTION_TYPE(OPTION_NAME, TYPE, TYPEDEF_EXPR, TYPEDEF_NAME) @@ -368,7 +368,7 @@ struct pack_options //! //! const bool is_incremental = pack_options< empty_default, incremental<true> >::type::is_incremental; //! -//! BOOST_STATIC_ASSERT(( is_incremental == true )); +//! BOOST_INTRUSIVE_STATIC_ASSERT(( is_incremental == true )); //! //! \endcode #define BOOST_INTRUSIVE_OPTION_CONSTANT(OPTION_NAME, TYPE, VALUE, CONSTANT_NAME) diff --git a/contrib/restricted/boost/intrusive/include/boost/intrusive/pointer_traits.hpp b/contrib/restricted/boost/intrusive/include/boost/intrusive/pointer_traits.hpp index 1b2ed05763..48d984eef6 100644 --- a/contrib/restricted/boost/intrusive/include/boost/intrusive/pointer_traits.hpp +++ b/contrib/restricted/boost/intrusive/include/boost/intrusive/pointer_traits.hpp @@ -130,7 +130,7 @@ struct pointer_traits //! //! <b>Note</b>: For non-conforming compilers only the existence of a member function called //! <code>pointer_to</code> is checked. - 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 //! <b>Note</b>: For non-conforming compilers only the existence of a member function called //! <code>static_cast_from</code> is checked. template<class UPtr> - 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 //! <b>Note</b>: For non-conforming compilers only the existence of a member function called //! <code>const_cast_from</code> is checked. template<class UPtr> - 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 //! <b>Note</b>: For non-conforming compilers only the existence of a member function called //! <code>dynamic_cast_from</code> is checked. template<class UPtr> - 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 <class T> - BOOST_INTRUSIVE_FORCEINLINE static T* to_raw_pointer(T* p) BOOST_NOEXCEPT + inline static T* to_raw_pointer(T* p) BOOST_NOEXCEPT { return p; } template <class Pointer> - BOOST_INTRUSIVE_FORCEINLINE static typename pointer_traits<Pointer>::element_type* + inline static typename pointer_traits<Pointer>::element_type* to_raw_pointer(const Pointer &p) BOOST_NOEXCEPT { 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<class UPtr> - BOOST_INTRUSIVE_FORCEINLINE static pointer priv_static_cast_from(boost::intrusive::detail::true_, const UPtr &uptr) BOOST_NOEXCEPT + inline static pointer priv_static_cast_from(boost::intrusive::detail::true_, const UPtr &uptr) BOOST_NOEXCEPT { return Ptr::static_cast_from(uptr); } template<class UPtr> - BOOST_INTRUSIVE_FORCEINLINE static pointer priv_static_cast_from(boost::intrusive::detail::false_, const UPtr &uptr) BOOST_NOEXCEPT + inline static pointer priv_static_cast_from(boost::intrusive::detail::false_, const UPtr &uptr) BOOST_NOEXCEPT { return uptr ? pointer_to(*static_cast<element_type*>(to_raw_pointer(uptr))) : pointer(); } //priv_const_cast_from template<class UPtr> - BOOST_INTRUSIVE_FORCEINLINE static pointer priv_const_cast_from(boost::intrusive::detail::true_, const UPtr &uptr) BOOST_NOEXCEPT + inline static pointer priv_const_cast_from(boost::intrusive::detail::true_, const UPtr &uptr) BOOST_NOEXCEPT { return Ptr::const_cast_from(uptr); } template<class UPtr> - BOOST_INTRUSIVE_FORCEINLINE static pointer priv_const_cast_from(boost::intrusive::detail::false_, const UPtr &uptr) BOOST_NOEXCEPT + inline static pointer priv_const_cast_from(boost::intrusive::detail::false_, const UPtr &uptr) BOOST_NOEXCEPT { return uptr ? pointer_to(const_cast<element_type&>(*uptr)) : pointer(); } //priv_dynamic_cast_from template<class UPtr> - BOOST_INTRUSIVE_FORCEINLINE static pointer priv_dynamic_cast_from(boost::intrusive::detail::true_, const UPtr &uptr) BOOST_NOEXCEPT + inline static pointer priv_dynamic_cast_from(boost::intrusive::detail::true_, const UPtr &uptr) BOOST_NOEXCEPT { return Ptr::dynamic_cast_from(uptr); } template<class UPtr> - BOOST_INTRUSIVE_FORCEINLINE static pointer priv_dynamic_cast_from(boost::intrusive::detail::false_, const UPtr &uptr) BOOST_NOEXCEPT + inline static pointer priv_dynamic_cast_from(boost::intrusive::detail::false_, const UPtr &uptr) BOOST_NOEXCEPT { return uptr ? pointer_to(dynamic_cast<element_type&>(*uptr)) : pointer(); } ///@endcond }; @@ -296,25 +296,25 @@ struct pointer_traits<T*> //! <b>Returns</b>: addressof(r) //! - BOOST_INTRUSIVE_FORCEINLINE static pointer pointer_to(reference r) BOOST_NOEXCEPT + inline static pointer pointer_to(reference r) BOOST_NOEXCEPT { return boost::intrusive::detail::addressof(r); } //! <b>Returns</b>: static_cast<pointer>(uptr) //! template<class U> - BOOST_INTRUSIVE_FORCEINLINE static pointer static_cast_from(U *uptr) BOOST_NOEXCEPT + inline static pointer static_cast_from(U *uptr) BOOST_NOEXCEPT { return static_cast<pointer>(uptr); } //! <b>Returns</b>: const_cast<pointer>(uptr) //! template<class U> - BOOST_INTRUSIVE_FORCEINLINE static pointer const_cast_from(U *uptr) BOOST_NOEXCEPT + inline static pointer const_cast_from(U *uptr) BOOST_NOEXCEPT { return const_cast<pointer>(uptr); } //! <b>Returns</b>: dynamic_cast<pointer>(uptr) //! template<class U> - BOOST_INTRUSIVE_FORCEINLINE static pointer dynamic_cast_from(U *uptr) BOOST_NOEXCEPT + inline static pointer dynamic_cast_from(U *uptr) BOOST_NOEXCEPT { return dynamic_cast<pointer>(uptr); } }; diff --git a/contrib/restricted/boost/intrusive/include/boost/intrusive/rbtree.hpp b/contrib/restricted/boost/intrusive/include/boost/intrusive/rbtree.hpp index 922fce51b0..04fce1eecf 100644 --- a/contrib/restricted/boost/intrusive/include/boost/intrusive/rbtree.hpp +++ b/contrib/restricted/boost/intrusive/include/boost/intrusive/rbtree.hpp @@ -29,7 +29,6 @@ #include <boost/intrusive/link_mode.hpp> #include <boost/move/utility_core.hpp> -#include <boost/static_assert.hpp> #if defined(BOOST_HAS_PRAGMA_ONCE) # pragma once @@ -536,48 +535,48 @@ class rbtree typedef typename Base::const_reverse_iterator const_reverse_iterator; //Assert if passed value traits are compatible with the type - BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value)); + BOOST_INTRUSIVE_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::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<class Iterator> - BOOST_INTRUSIVE_FORCEINLINE rbtree( bool unique, Iterator b, Iterator e + inline rbtree( bool unique, Iterator b, Iterator e , const key_compare &cmp = key_compare() , const 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<rbtree &>(this->Base::operator=(BOOST_MOVE_BASE(Base, x))); } template <class Cloner, class Disposer> - BOOST_INTRUSIVE_FORCEINLINE void clone_from(const rbtree &src, Cloner cloner, Disposer disposer) + inline void clone_from(const rbtree &src, Cloner cloner, Disposer disposer) { Base::clone_from(src, cloner, disposer); } template <class Cloner, class Disposer> - BOOST_INTRUSIVE_FORCEINLINE void clone_from(BOOST_RV_REF(rbtree) src, Cloner cloner, Disposer disposer) + inline void clone_from(BOOST_RV_REF(rbtree) src, Cloner cloner, Disposer disposer) { Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer); } - BOOST_INTRUSIVE_FORCEINLINE static rbtree &container_from_end_iterator(iterator end_iterator) BOOST_NOEXCEPT + inline static rbtree &container_from_end_iterator(iterator end_iterator) BOOST_NOEXCEPT { return static_cast<rbtree &>(Base::container_from_end_iterator(end_iterator)); } - BOOST_INTRUSIVE_FORCEINLINE static const rbtree &container_from_end_iterator(const_iterator end_iterator) BOOST_NOEXCEPT + inline static const rbtree &container_from_end_iterator(const_iterator end_iterator) BOOST_NOEXCEPT { return static_cast<const rbtree &>(Base::container_from_end_iterator(end_iterator)); } - BOOST_INTRUSIVE_FORCEINLINE static rbtree &container_from_iterator(iterator it) BOOST_NOEXCEPT + inline static rbtree &container_from_iterator(iterator it) BOOST_NOEXCEPT { return static_cast<rbtree &>(Base::container_from_iterator(it)); } - BOOST_INTRUSIVE_FORCEINLINE static const rbtree &container_from_iterator(const_iterator it) BOOST_NOEXCEPT + inline static const rbtree &container_from_iterator(const_iterator it) BOOST_NOEXCEPT { return static_cast<const rbtree &>(Base::container_from_iterator(it)); } }; diff --git a/contrib/restricted/boost/intrusive/include/boost/intrusive/sgtree.hpp b/contrib/restricted/boost/intrusive/include/boost/intrusive/sgtree.hpp index 9e687da10f..aaee1651c1 100644 --- a/contrib/restricted/boost/intrusive/include/boost/intrusive/sgtree.hpp +++ b/contrib/restricted/boost/intrusive/include/boost/intrusive/sgtree.hpp @@ -21,7 +21,6 @@ #include <boost/intrusive/detail/config_begin.hpp> #include <boost/intrusive/intrusive_fwd.hpp> #include <boost/intrusive/detail/assert.hpp> -#include <boost/static_assert.hpp> #include <boost/intrusive/bs_set_hook.hpp> #include <boost/intrusive/bstree.hpp> #include <boost/intrusive/detail/tree_node.hpp> @@ -275,7 +274,7 @@ class sgtree_impl typedef typename alpha_traits::multiply_by_alpha_t multiply_by_alpha_t; BOOST_MOVABLE_BUT_NOT_COPYABLE(sgtree_impl) - BOOST_STATIC_ASSERT(((int)value_traits::link_mode != (int)auto_unlink)); + BOOST_INTRUSIVE_STATIC_ASSERT(((int)value_traits::link_mode != (int)auto_unlink)); enum { safemode_or_autounlink = (int)value_traits::link_mode == (int)auto_unlink || @@ -914,7 +913,7 @@ class sgtree_impl { //The alpha factor CAN't be changed if the fixed, floating operation-less //1/sqrt(2) alpha factor option is activated - BOOST_STATIC_ASSERT((floating_point)); + BOOST_INTRUSIVE_STATIC_ASSERT((floating_point)); BOOST_INTRUSIVE_INVARIANT_ASSERT((new_alpha > 0.5f && new_alpha < 1.0f)); if(new_alpha >= 0.5f && new_alpha < 1.0f){ float old_alpha = this->get_alpha_traits().get_alpha(); @@ -1018,48 +1017,48 @@ class sgtree typedef typename Base::const_reverse_iterator const_reverse_iterator; //Assert if passed value traits are compatible with the type - BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value)); + BOOST_INTRUSIVE_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::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<class Iterator> - BOOST_INTRUSIVE_FORCEINLINE sgtree( bool unique, Iterator b, Iterator e + inline sgtree( bool unique, Iterator b, Iterator e , const key_compare &cmp = key_compare() , const 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<sgtree &>(this->Base::operator=(BOOST_MOVE_BASE(Base, x))); } template <class Cloner, class Disposer> - BOOST_INTRUSIVE_FORCEINLINE void clone_from(const sgtree &src, Cloner cloner, Disposer disposer) + inline void clone_from(const sgtree &src, Cloner cloner, Disposer disposer) { Base::clone_from(src, cloner, disposer); } template <class Cloner, class Disposer> - BOOST_INTRUSIVE_FORCEINLINE void clone_from(BOOST_RV_REF(sgtree) src, Cloner cloner, Disposer disposer) + inline void clone_from(BOOST_RV_REF(sgtree) src, Cloner cloner, Disposer disposer) { Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer); } - BOOST_INTRUSIVE_FORCEINLINE static sgtree &container_from_end_iterator(iterator end_iterator) BOOST_NOEXCEPT + inline static sgtree &container_from_end_iterator(iterator end_iterator) BOOST_NOEXCEPT { return static_cast<sgtree &>(Base::container_from_end_iterator(end_iterator)); } - BOOST_INTRUSIVE_FORCEINLINE static const sgtree &container_from_end_iterator(const_iterator end_iterator) BOOST_NOEXCEPT + inline static const sgtree &container_from_end_iterator(const_iterator end_iterator) BOOST_NOEXCEPT { return static_cast<const sgtree &>(Base::container_from_end_iterator(end_iterator)); } - BOOST_INTRUSIVE_FORCEINLINE static sgtree &container_from_iterator(iterator it) BOOST_NOEXCEPT + inline static sgtree &container_from_iterator(iterator it) BOOST_NOEXCEPT { return static_cast<sgtree &>(Base::container_from_iterator(it)); } - BOOST_INTRUSIVE_FORCEINLINE static const sgtree &container_from_iterator(const_iterator it) BOOST_NOEXCEPT + inline static const sgtree &container_from_iterator(const_iterator it) BOOST_NOEXCEPT { return static_cast<const sgtree &>(Base::container_from_iterator(it)); } }; diff --git a/contrib/restricted/boost/intrusive/include/boost/intrusive/sgtree_algorithms.hpp b/contrib/restricted/boost/intrusive/include/boost/intrusive/sgtree_algorithms.hpp index 726dbb9970..ea0d2c54bd 100644 --- a/contrib/restricted/boost/intrusive/include/boost/intrusive/sgtree_algorithms.hpp +++ b/contrib/restricted/boost/intrusive/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<class H_Alpha> - BOOST_INTRUSIVE_FORCEINLINE static void insert_unique_commit + inline static void insert_unique_commit (node_ptr header, node_ptr new_value, const insert_commit_data &commit_data ,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/contrib/restricted/boost/intrusive/include/boost/intrusive/slist.hpp b/contrib/restricted/boost/intrusive/include/boost/intrusive/slist.hpp index 7319bf3132..f39e7dfc2c 100644 --- a/contrib/restricted/boost/intrusive/include/boost/intrusive/slist.hpp +++ b/contrib/restricted/boost/intrusive/include/boost/intrusive/slist.hpp @@ -41,7 +41,6 @@ #include <boost/intrusive/detail/node_cloner_disposer.hpp> #include <boost/move/utility_core.hpp> -#include <boost/static_assert.hpp> #include <cstddef> //std::size_t @@ -166,53 +165,53 @@ class slist_impl static const bool safemode_or_autounlink = is_safe_autounlink<value_traits::link_mode>::value; //Constant-time size is incompatible with auto-unlink hooks! - BOOST_STATIC_ASSERT(!(constant_time_size && ((int)value_traits::link_mode == (int)auto_unlink))); + BOOST_INTRUSIVE_STATIC_ASSERT(!(constant_time_size && ((int)value_traits::link_mode == (int)auto_unlink))); //Linear singly linked lists are incompatible with auto-unlink hooks! - BOOST_STATIC_ASSERT(!(linear && ((int)value_traits::link_mode == (int)auto_unlink))); + BOOST_INTRUSIVE_STATIC_ASSERT(!(linear && ((int)value_traits::link_mode == (int)auto_unlink))); //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_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_<cache_last>()); } - BOOST_INTRUSIVE_FORCEINLINE const_node_ptr get_last_node() const + inline const_node_ptr get_last_node() const { return this->get_last_node(detail::bool_<cache_last>()); } - BOOST_INTRUSIVE_FORCEINLINE void set_last_node(node_ptr n) + inline void set_last_node(node_ptr n) { return this->set_last_node(n, detail::bool_<cache_last>()); } - BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_last_node(detail::bool_<false>) + inline static node_ptr get_last_node(detail::bool_<false>) { //This function shall not be used if cache_last is not true BOOST_INTRUSIVE_INVARIANT_ASSERT(cache_last); return node_ptr(); } - BOOST_INTRUSIVE_FORCEINLINE static void set_last_node(node_ptr , detail::bool_<false>) + inline static void set_last_node(node_ptr , detail::bool_<false>) { //This function shall not be used if cache_last is not true BOOST_INTRUSIVE_INVARIANT_ASSERT(cache_last); } - BOOST_INTRUSIVE_FORCEINLINE node_ptr get_last_node(detail::bool_<true>) + inline node_ptr get_last_node(detail::bool_<true>) { return node_ptr(data_.root_plus_size_.last_); } - BOOST_INTRUSIVE_FORCEINLINE const_node_ptr get_last_node(detail::bool_<true>) const + inline const_node_ptr get_last_node(detail::bool_<true>) const { return const_node_ptr(data_.root_plus_size_.last_); } - BOOST_INTRUSIVE_FORCEINLINE void set_last_node(node_ptr n, detail::bool_<true>) + inline void set_last_node(node_ptr n, detail::bool_<true>) { data_.root_plus_size_.last_ = n; } void set_default_constructed_state() @@ -241,22 +240,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 <ValueTraits>::const_value_traits_ptr const_value_traits_ptr; - BOOST_INTRUSIVE_FORCEINLINE const_value_traits_ptr priv_value_traits_ptr() const + inline const_value_traits_ptr priv_value_traits_ptr() const { return pointer_traits<const_value_traits_ptr>::pointer_to(this->priv_value_traits()); } /// @endcond @@ -449,7 +448,7 @@ class slist_impl //! This function is only available is cache_last<> is true. void push_back(reference value) BOOST_NOEXCEPT { - BOOST_STATIC_ASSERT((cache_last)); + BOOST_INTRUSIVE_STATIC_ASSERT((cache_last)); node_ptr n = priv_value_traits().to_node_ptr(value); BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(!safemode_or_autounlink || node_algorithms::inited(n)); node_algorithms::link_after(this->get_last_node(), n); @@ -501,7 +500,7 @@ class slist_impl //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Constant. - BOOST_INTRUSIVE_FORCEINLINE reference front() BOOST_NOEXCEPT + inline reference front() BOOST_NOEXCEPT { return *this->priv_value_traits().to_value_ptr(node_traits::get_next(this->get_root_node())); } //! <b>Effects</b>: Returns a const_reference to the first element of the list. @@ -509,7 +508,7 @@ class slist_impl //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Constant. - BOOST_INTRUSIVE_FORCEINLINE const_reference front() const BOOST_NOEXCEPT + inline const_reference front() const BOOST_NOEXCEPT { return *this->priv_value_traits().to_value_ptr(detail::uncast(node_traits::get_next(this->get_root_node()))); } //! <b>Effects</b>: Returns a reference to the last element of the list. @@ -522,7 +521,7 @@ class slist_impl //! This function is only available is cache_last<> is true. reference back() BOOST_NOEXCEPT { - BOOST_STATIC_ASSERT((cache_last)); + BOOST_INTRUSIVE_STATIC_ASSERT((cache_last)); return *this->priv_value_traits().to_value_ptr(this->get_last_node()); } @@ -534,9 +533,9 @@ class slist_impl //! //! <b>Note</b>: 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)); + BOOST_INTRUSIVE_STATIC_ASSERT((cache_last)); return *this->priv_value_traits().to_value_ptr(this->get_last_node()); } @@ -545,7 +544,7 @@ class slist_impl //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Constant. - BOOST_INTRUSIVE_FORCEINLINE iterator begin() BOOST_NOEXCEPT + inline iterator begin() BOOST_NOEXCEPT { return iterator (node_traits::get_next(this->get_root_node()), this->priv_value_traits_ptr()); } //! <b>Effects</b>: Returns a const_iterator to the first element contained in the list. @@ -553,7 +552,7 @@ class slist_impl //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Constant. - BOOST_INTRUSIVE_FORCEINLINE const_iterator begin() const BOOST_NOEXCEPT + inline const_iterator begin() const BOOST_NOEXCEPT { return const_iterator (node_traits::get_next(this->get_root_node()), this->priv_value_traits_ptr()); } //! <b>Effects</b>: Returns a const_iterator to the first element contained in the list. @@ -561,7 +560,7 @@ class slist_impl //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Constant. - BOOST_INTRUSIVE_FORCEINLINE const_iterator cbegin() const BOOST_NOEXCEPT + inline const_iterator cbegin() const BOOST_NOEXCEPT { return const_iterator(node_traits::get_next(this->get_root_node()), this->priv_value_traits_ptr()); } //! <b>Effects</b>: Returns an iterator to the end of the list. @@ -569,7 +568,7 @@ class slist_impl //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Constant. - BOOST_INTRUSIVE_FORCEINLINE iterator end() BOOST_NOEXCEPT + inline iterator end() BOOST_NOEXCEPT { return iterator(this->get_end_node(), this->priv_value_traits_ptr()); } //! <b>Effects</b>: Returns a const_iterator to the end of the list. @@ -577,7 +576,7 @@ class slist_impl //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Constant. - BOOST_INTRUSIVE_FORCEINLINE const_iterator end() const BOOST_NOEXCEPT + inline const_iterator end() const BOOST_NOEXCEPT { return const_iterator(detail::uncast(this->get_end_node()), this->priv_value_traits_ptr()); } //! <b>Effects</b>: Returns a const_iterator to the end of the list. @@ -585,7 +584,7 @@ class slist_impl //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Constant. - BOOST_INTRUSIVE_FORCEINLINE const_iterator cend() const BOOST_NOEXCEPT + inline const_iterator cend() const BOOST_NOEXCEPT { return this->end(); } //! <b>Effects</b>: Returns an iterator that points to a position @@ -594,7 +593,7 @@ class slist_impl //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Constant. - BOOST_INTRUSIVE_FORCEINLINE iterator before_begin() BOOST_NOEXCEPT + inline iterator before_begin() BOOST_NOEXCEPT { return iterator(this->get_root_node(), this->priv_value_traits_ptr()); } //! <b>Effects</b>: Returns an iterator that points to a position @@ -603,7 +602,7 @@ class slist_impl //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Constant. - BOOST_INTRUSIVE_FORCEINLINE const_iterator before_begin() const BOOST_NOEXCEPT + inline const_iterator before_begin() const BOOST_NOEXCEPT { return const_iterator(detail::uncast(this->get_root_node()), this->priv_value_traits_ptr()); } //! <b>Effects</b>: Returns an iterator that points to a position @@ -612,7 +611,7 @@ class slist_impl //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Constant. - BOOST_INTRUSIVE_FORCEINLINE const_iterator cbefore_begin() const BOOST_NOEXCEPT + inline const_iterator cbefore_begin() const BOOST_NOEXCEPT { return this->before_begin(); } //! <b>Effects</b>: Returns an iterator to the last element contained in the list. @@ -622,7 +621,7 @@ class slist_impl //! <b>Complexity</b>: Constant. //! //! <b>Note</b>: This function is present only if cached_last<> option is true. - BOOST_INTRUSIVE_FORCEINLINE iterator last() BOOST_NOEXCEPT + inline iterator last() BOOST_NOEXCEPT { //This function shall not be used if cache_last is not true BOOST_INTRUSIVE_INVARIANT_ASSERT(cache_last); @@ -636,7 +635,7 @@ class slist_impl //! <b>Complexity</b>: Constant. //! //! <b>Note</b>: This function is present only if cached_last<> option is true. - BOOST_INTRUSIVE_FORCEINLINE const_iterator last() const BOOST_NOEXCEPT + inline const_iterator last() const BOOST_NOEXCEPT { //This function shall not be used if cache_last is not true BOOST_INTRUSIVE_INVARIANT_ASSERT(cache_last); @@ -650,7 +649,7 @@ class slist_impl //! <b>Complexity</b>: Constant. //! //! <b>Note</b>: This function is present only if cached_last<> option is true. - BOOST_INTRUSIVE_FORCEINLINE const_iterator clast() const BOOST_NOEXCEPT + inline const_iterator clast() const BOOST_NOEXCEPT { return const_iterator(this->get_last_node(), this->priv_value_traits_ptr()); } //! <b>Precondition</b>: end_iterator must be a valid end iterator @@ -661,7 +660,7 @@ class slist_impl //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Constant. - BOOST_INTRUSIVE_FORCEINLINE static slist_impl &container_from_end_iterator(iterator end_iterator) BOOST_NOEXCEPT + inline static slist_impl &container_from_end_iterator(iterator end_iterator) BOOST_NOEXCEPT { return slist_impl::priv_container_from_end_iterator(end_iterator); } //! <b>Precondition</b>: end_iterator must be a valid end const_iterator @@ -672,7 +671,7 @@ class slist_impl //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Constant. - BOOST_INTRUSIVE_FORCEINLINE static const slist_impl &container_from_end_iterator(const_iterator end_iterator) BOOST_NOEXCEPT + inline static const slist_impl &container_from_end_iterator(const_iterator end_iterator) BOOST_NOEXCEPT { return slist_impl::priv_container_from_end_iterator(end_iterator); } //! <b>Effects</b>: Returns the number of the elements contained in the list. @@ -683,7 +682,7 @@ class slist_impl //! if constant_time_size is false. Constant time otherwise. //! //! <b>Note</b>: Does not affect the validity of iterators and references. - BOOST_INTRUSIVE_FORCEINLINE size_type size() const BOOST_NOEXCEPT + inline size_type size() const BOOST_NOEXCEPT { BOOST_IF_CONSTEXPR(constant_time_size) return this->priv_size_traits().get_size(); @@ -698,7 +697,7 @@ class slist_impl //! <b>Complexity</b>: Constant. //! //! <b>Note</b>: Does not affect the validity of iterators and references. - BOOST_INTRUSIVE_FORCEINLINE bool empty() const BOOST_NOEXCEPT + inline bool empty() const BOOST_NOEXCEPT { return node_algorithms::is_empty(this->get_root_node()); } //! <b>Effects</b>: Swaps the elements of x and *this. @@ -1061,7 +1060,7 @@ class slist_impl static iterator s_insert_after(const_iterator const prev_p, reference value) BOOST_NOEXCEPT { - BOOST_STATIC_ASSERT(((!cache_last)&&(!constant_time_size)&&(!stateful_value_traits))); + BOOST_INTRUSIVE_STATIC_ASSERT(((!cache_last)&&(!constant_time_size)&&(!stateful_value_traits))); node_ptr const n = value_traits::to_node_ptr(value); BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(!safemode_or_autounlink || node_algorithms::inited(n)); node_algorithms::link_after(prev_p.pointed_node(), n); @@ -1071,7 +1070,7 @@ class slist_impl template<class Disposer> static iterator s_erase_after_and_dispose(const_iterator prev, Disposer disposer) BOOST_NOEXCEPT { - BOOST_STATIC_ASSERT(((!cache_last)&&(!constant_time_size)&&(!stateful_value_traits))); + BOOST_INTRUSIVE_STATIC_ASSERT(((!cache_last)&&(!constant_time_size)&&(!stateful_value_traits))); const_iterator it(prev); ++it; node_ptr to_erase(it.pointed_node()); @@ -1087,7 +1086,7 @@ class slist_impl template<class Disposer> static iterator s_erase_after_and_dispose(const_iterator before_f, const_iterator l, Disposer disposer) BOOST_NOEXCEPT { - BOOST_STATIC_ASSERT(((!cache_last)&&(!constant_time_size)&&(!stateful_value_traits))); + BOOST_INTRUSIVE_STATIC_ASSERT(((!cache_last)&&(!constant_time_size)&&(!stateful_value_traits))); node_ptr bfp(before_f.pointed_node()), lp(l.pointed_node()); node_ptr fp(node_traits::get_next(bfp)); node_algorithms::unlink_after(bfp, lp); @@ -1754,7 +1753,7 @@ class slist_impl //! is stateless. static iterator s_iterator_to(reference value) BOOST_NOEXCEPT { - BOOST_STATIC_ASSERT((!stateful_value_traits)); + BOOST_INTRUSIVE_STATIC_ASSERT((!stateful_value_traits)); return iterator (value_traits::to_node_ptr(value), const_value_traits_ptr()); } @@ -1771,7 +1770,7 @@ class slist_impl //! is stateless. static const_iterator s_iterator_to(const_reference value) BOOST_NOEXCEPT { - BOOST_STATIC_ASSERT((!stateful_value_traits)); + BOOST_INTRUSIVE_STATIC_ASSERT((!stateful_value_traits)); reference r =*detail::uncast(pointer_traits<const_pointer>::pointer_to(value)); return const_iterator(value_traits::to_node_ptr(r), const_value_traits_ptr()); } @@ -2112,8 +2111,8 @@ class slist_impl { //Obtaining the container from the end iterator is not possible with linear //singly linked lists (because "end" is represented by the null pointer) - BOOST_STATIC_ASSERT(!linear); - BOOST_STATIC_ASSERT((has_container_from_iterator)); + BOOST_INTRUSIVE_STATIC_ASSERT(!linear); + BOOST_INTRUSIVE_STATIC_ASSERT((has_container_from_iterator)); node_ptr p = end_iterator.pointed_node(); header_holder_type* h = header_holder_type::get_holder(p); header_holder_plus_last_t* hpl = detail::parent_from_member< header_holder_plus_last_t, header_holder_type> @@ -2185,7 +2184,7 @@ class slist #endif >::type Base; //Assert if passed value traits are compatible with the type - BOOST_STATIC_ASSERT((detail::is_same<typename Base::value_traits::value_type, T>::value)); + BOOST_INTRUSIVE_STATIC_ASSERT((detail::is_same<typename Base::value_traits::value_type, T>::value)); BOOST_MOVABLE_BUT_NOT_COPYABLE(slist) public: @@ -2195,45 +2194,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<class Iterator> - BOOST_INTRUSIVE_FORCEINLINE slist(Iterator b, Iterator e, const value_traits &v_traits = value_traits()) + inline slist(Iterator b, Iterator e, const value_traits &v_traits = value_traits()) : Base(b, e, v_traits) {} - 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<slist &>(this->Base::operator=(BOOST_MOVE_BASE(Base, x))); } template <class Cloner, class Disposer> - BOOST_INTRUSIVE_FORCEINLINE void clone_from(const slist &src, Cloner cloner, Disposer disposer) + inline void clone_from(const slist &src, Cloner cloner, Disposer disposer) { Base::clone_from(src, cloner, disposer); } template <class Cloner, class Disposer> - BOOST_INTRUSIVE_FORCEINLINE void clone_from(BOOST_RV_REF(slist) src, Cloner cloner, Disposer disposer) + inline void clone_from(BOOST_RV_REF(slist) src, Cloner cloner, Disposer disposer) { Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer); } - BOOST_INTRUSIVE_FORCEINLINE static slist &container_from_end_iterator(iterator end_iterator) BOOST_NOEXCEPT + inline static slist &container_from_end_iterator(iterator end_iterator) BOOST_NOEXCEPT { return static_cast<slist &>(Base::container_from_end_iterator(end_iterator)); } - BOOST_INTRUSIVE_FORCEINLINE static const slist &container_from_end_iterator(const_iterator end_iterator) BOOST_NOEXCEPT + inline static const slist &container_from_end_iterator(const_iterator end_iterator) BOOST_NOEXCEPT { return static_cast<const slist &>(Base::container_from_end_iterator(end_iterator)); } }; diff --git a/contrib/restricted/boost/intrusive/include/boost/intrusive/splaytree.hpp b/contrib/restricted/boost/intrusive/include/boost/intrusive/splaytree.hpp index 44e5c78670..e25647c6ab 100644 --- a/contrib/restricted/boost/intrusive/include/boost/intrusive/splaytree.hpp +++ b/contrib/restricted/boost/intrusive/include/boost/intrusive/splaytree.hpp @@ -18,7 +18,6 @@ #include <boost/intrusive/detail/minimal_less_equal_header.hpp> #include <boost/intrusive/detail/minimal_pair_header.hpp> //std::pair -#include <boost/static_assert.hpp> #include <boost/intrusive/bstree.hpp> #include <boost/intrusive/detail/tree_node.hpp> #include <boost/intrusive/detail/mpl.hpp> @@ -611,48 +610,48 @@ class splaytree typedef typename Base::const_reverse_iterator const_reverse_iterator; //Assert if passed value traits are compatible with the type - BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value)); + BOOST_INTRUSIVE_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::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<class Iterator> - BOOST_INTRUSIVE_FORCEINLINE splaytree( bool unique, Iterator b, Iterator e + inline splaytree( bool unique, Iterator b, Iterator e , const key_compare &cmp = key_compare() , const 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<splaytree &>(this->Base::operator=(BOOST_MOVE_BASE(Base, x))); } template <class Cloner, class Disposer> - BOOST_INTRUSIVE_FORCEINLINE void clone_from(const splaytree &src, Cloner cloner, Disposer disposer) + inline void clone_from(const splaytree &src, Cloner cloner, Disposer disposer) { Base::clone_from(src, cloner, disposer); } template <class Cloner, class Disposer> - BOOST_INTRUSIVE_FORCEINLINE void clone_from(BOOST_RV_REF(splaytree) src, Cloner cloner, Disposer disposer) + inline void clone_from(BOOST_RV_REF(splaytree) src, Cloner cloner, Disposer disposer) { Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer); } - BOOST_INTRUSIVE_FORCEINLINE static splaytree &container_from_end_iterator(iterator end_iterator) BOOST_NOEXCEPT + inline static splaytree &container_from_end_iterator(iterator end_iterator) BOOST_NOEXCEPT { return static_cast<splaytree &>(Base::container_from_end_iterator(end_iterator)); } - BOOST_INTRUSIVE_FORCEINLINE static const splaytree &container_from_end_iterator(const_iterator end_iterator) BOOST_NOEXCEPT + inline static const splaytree &container_from_end_iterator(const_iterator end_iterator) BOOST_NOEXCEPT { return static_cast<const splaytree &>(Base::container_from_end_iterator(end_iterator)); } - BOOST_INTRUSIVE_FORCEINLINE static splaytree &container_from_iterator(iterator it) BOOST_NOEXCEPT + inline static splaytree &container_from_iterator(iterator it) BOOST_NOEXCEPT { return static_cast<splaytree &>(Base::container_from_iterator(it)); } - BOOST_INTRUSIVE_FORCEINLINE static const splaytree &container_from_iterator(const_iterator it) BOOST_NOEXCEPT + inline static const splaytree &container_from_iterator(const_iterator it) BOOST_NOEXCEPT { return static_cast<const splaytree &>(Base::container_from_iterator(it)); } }; diff --git a/contrib/restricted/boost/intrusive/ya.make b/contrib/restricted/boost/intrusive/ya.make index 0643da6a39..df73bcb529 100644 --- a/contrib/restricted/boost/intrusive/ya.make +++ b/contrib/restricted/boost/intrusive/ya.make @@ -9,16 +9,14 @@ LICENSE( LICENSE_TEXTS(.yandex_meta/licenses.list.txt) -VERSION(1.84.0) +VERSION(1.85.0) -ORIGINAL_SOURCE(https://github.com/boostorg/intrusive/archive/boost-1.84.0.tar.gz) +ORIGINAL_SOURCE(https://github.com/boostorg/intrusive/archive/boost-1.85.0.tar.gz) PEERDIR( contrib/restricted/boost/assert contrib/restricted/boost/config - contrib/restricted/boost/container_hash contrib/restricted/boost/move - contrib/restricted/boost/static_assert ) ADDINCL( |