diff options
author | Mark Benvenuto <mark.benvenuto@mongodb.com> | 2015-03-02 13:41:22 -0500 |
---|---|---|
committer | Mark Benvenuto <mark.benvenuto@mongodb.com> | 2015-03-03 14:03:32 -0500 |
commit | 95940768bcff61b59ed83dcc94c5afc001cef70f (patch) | |
tree | cee8de123935dedc9afa0711c8d764b5f9a926f0 /src/third_party/boost/boost/intrusive | |
parent | 65f0efbe658d288267bd9c1f9f2a77a22794aacd (diff) | |
download | mongo-95940768bcff61b59ed83dcc94c5afc001cef70f.tar.gz |
SERVER-8994: Remove Boost 1.49
Diffstat (limited to 'src/third_party/boost/boost/intrusive')
65 files changed, 0 insertions, 46139 deletions
diff --git a/src/third_party/boost/boost/intrusive/any_hook.hpp b/src/third_party/boost/boost/intrusive/any_hook.hpp deleted file mode 100644 index cccc820e7d3..00000000000 --- a/src/third_party/boost/boost/intrusive/any_hook.hpp +++ /dev/null @@ -1,344 +0,0 @@ -///////////////////////////////////////////////////////////////////////////// -// -// (C) Copyright Ion Gaztanaga 2006-2009 -// -// Distributed under the Boost Software License, Version 1.0. -// (See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) -// -// See http://www.boost.org/libs/intrusive for documentation. -// -///////////////////////////////////////////////////////////////////////////// - -#ifndef BOOST_INTRUSIVE_ANY_HOOK_HPP -#define BOOST_INTRUSIVE_ANY_HOOK_HPP - -#include <boost/intrusive/detail/config_begin.hpp> -#include <boost/intrusive/intrusive_fwd.hpp> -#include <boost/intrusive/detail/utilities.hpp> -#include <boost/intrusive/detail/any_node_and_algorithms.hpp> -#include <boost/intrusive/options.hpp> -#include <boost/intrusive/detail/generic_hook.hpp> -#include <boost/intrusive/pointer_traits.hpp> - -namespace boost { -namespace intrusive { - -/// @cond -template<class VoidPointer> -struct get_any_node_algo -{ - typedef any_algorithms<VoidPointer> type; -}; -/// @endcond - -//! Helper metafunction to define a \c \c any_base_hook that yields to the same -//! type when the same options (either explicitly or implicitly) are used. -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) || defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template<class ...Options> -#else -template<class O1 = none, class O2 = none, class O3 = none> -#endif -struct make_any_base_hook -{ - /// @cond - typedef typename pack_options - < hook_defaults, - #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) - O1, O2, O3 - #else - Options... - #endif - >::type packed_options; - - typedef detail::generic_hook - < get_any_node_algo<typename packed_options::void_pointer> - , typename packed_options::tag - , packed_options::link_mode - , detail::AnyBaseHook - > implementation_defined; - /// @endcond - typedef implementation_defined type; -}; - -//! Derive a class from this hook in order to store objects of that class -//! in an intrusive container. -//! -//! The hook admits the following options: \c tag<>, \c void_pointer<> and -//! \c link_mode<>. -//! -//! \c tag<> defines a tag to identify the node. -//! The same tag value can be used in different classes, but if a class is -//! derived from more than one \c any_base_hook, then each \c any_base_hook needs its -//! unique tag. -//! -//! \c link_mode<> will specify the linking mode of the hook (\c normal_link, \c safe_link). -//! -//! \c void_pointer<> is the pointer type that will be used internally in the hook -//! and the the container configured to use this hook. -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) || defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template<class ...Options> -#else -template<class O1, class O2, class O3> -#endif -class any_base_hook - : public make_any_base_hook - #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) - <O1, O2, O3> - #else - <Options...> - #endif - ::type -{ - #if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) - public: - //! <b>Effects</b>: If link_mode is or \c safe_link - //! initializes the node to an unlinked state. - //! - //! <b>Throws</b>: Nothing. - any_base_hook(); - - //! <b>Effects</b>: If link_mode is or \c safe_link - //! initializes the node to an unlinked state. The argument is ignored. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Rationale</b>: Providing a copy-constructor - //! makes classes using the hook STL-compliant without forcing the - //! user to do some additional work. \c swap can be used to emulate - //! move-semantics. - any_base_hook(const any_base_hook& ); - - //! <b>Effects</b>: Empty function. The argument is ignored. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Rationale</b>: Providing an assignment operator - //! makes classes using the hook STL-compliant without forcing the - //! user to do some additional work. \c swap can be used to emulate - //! move-semantics. - any_base_hook& operator=(const any_base_hook& ); - - //! <b>Effects</b>: If link_mode is \c normal_link, the destructor does - //! nothing (ie. no code is generated). If link_mode is \c safe_link and the - //! object is stored in a container an assertion is raised. - //! - //! <b>Throws</b>: Nothing. - ~any_base_hook(); - - //! <b>Precondition</b>: link_mode must be \c safe_link. - //! - //! <b>Returns</b>: true, if the node belongs to a container, false - //! otherwise. This function can be used to test whether \c container::iterator_to - //! will return a valid iterator. - //! - //! <b>Complexity</b>: Constant - bool is_linked() const; - #endif -}; - -//! Helper metafunction to define a \c \c any_member_hook that yields to the same -//! type when the same options (either explicitly or implicitly) are used. -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) || defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template<class ...Options> -#else -template<class O1 = none, class O2 = none, class O3 = none> -#endif -struct make_any_member_hook -{ - /// @cond - typedef typename pack_options - < hook_defaults, - #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) - O1, O2, O3 - #else - Options... - #endif - >::type packed_options; - - typedef detail::generic_hook - < get_any_node_algo<typename packed_options::void_pointer> - , member_tag - , packed_options::link_mode - , detail::NoBaseHook - > implementation_defined; - /// @endcond - typedef implementation_defined type; -}; - -//! Store this hook in a class to be inserted -//! in an intrusive container. -//! -//! The hook admits the following options: \c void_pointer<> and -//! \c link_mode<>. -//! -//! \c link_mode<> will specify the linking mode of the hook (\c normal_link or \c safe_link). -//! -//! \c void_pointer<> is the pointer type that will be used internally in the hook -//! and the the container configured to use this hook. -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) || defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template<class ...Options> -#else -template<class O1, class O2, class O3> -#endif -class any_member_hook - : public make_any_member_hook - #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) - <O1, O2, O3> - #else - <Options...> - #endif - ::type -{ - #if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) - public: - //! <b>Effects</b>: If link_mode is or \c safe_link - //! initializes the node to an unlinked state. - //! - //! <b>Throws</b>: Nothing. - any_member_hook(); - - //! <b>Effects</b>: If link_mode is or \c safe_link - //! initializes the node to an unlinked state. The argument is ignored. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Rationale</b>: Providing a copy-constructor - //! makes classes using the hook STL-compliant without forcing the - //! user to do some additional work. \c swap can be used to emulate - //! move-semantics. - any_member_hook(const any_member_hook& ); - - //! <b>Effects</b>: Empty function. The argument is ignored. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Rationale</b>: Providing an assignment operator - //! makes classes using the hook STL-compliant without forcing the - //! user to do some additional work. \c swap can be used to emulate - //! move-semantics. - any_member_hook& operator=(const any_member_hook& ); - - //! <b>Effects</b>: If link_mode is \c normal_link, the destructor does - //! nothing (ie. no code is generated). If link_mode is \c safe_link and the - //! object is stored in a container an assertion is raised. - //! - //! <b>Throws</b>: Nothing. - ~any_member_hook(); - - //! <b>Precondition</b>: link_mode must be \c safe_link. - //! - //! <b>Returns</b>: true, if the node belongs to a container, false - //! otherwise. This function can be used to test whether \c container::iterator_to - //! will return a valid iterator. - //! - //! <b>Complexity</b>: Constant - bool is_linked() const; - #endif -}; - -/// @cond - -namespace detail{ - -template<class ValueTraits> -struct any_to_get_base_pointer_type -{ - typedef typename pointer_traits<typename ValueTraits::boost_intrusive_tags::node_traits::node_ptr>::template - rebind_pointer<void>::type type; -}; - -template<class ValueTraits> -struct any_to_get_member_pointer_type -{ - typedef typename pointer_traits - <typename ValueTraits::node_ptr>::template rebind_pointer<void>::type type; -}; - -//!This option setter specifies that the container -//!must use the specified base hook -template<class BaseHook, template <class> class NodeTraits> -struct any_to_some_hook -{ - typedef typename BaseHook::template pack<none>::value_traits old_value_traits; - template<class Base> - struct pack : public Base - { - struct value_traits : public old_value_traits - { - static const bool is_any_hook = true; - typedef typename detail::eval_if_c - < detail::internal_base_hook_bool_is_true<old_value_traits>::value - , any_to_get_base_pointer_type<old_value_traits> - , any_to_get_member_pointer_type<old_value_traits> - >::type void_pointer; - typedef NodeTraits<void_pointer> node_traits; - }; - }; -}; - -} //namespace detail{ - -/// @endcond - -//!This option setter specifies that -//!any hook should behave as an slist hook -template<class BaseHook> -struct any_to_slist_hook -/// @cond - : public detail::any_to_some_hook<BaseHook, any_slist_node_traits> -/// @endcond -{}; - -//!This option setter specifies that -//!any hook should behave as an list hook -template<class BaseHook> -struct any_to_list_hook -/// @cond - : public detail::any_to_some_hook<BaseHook, any_list_node_traits> -/// @endcond -{}; - -//!This option setter specifies that -//!any hook should behave as a set hook -template<class BaseHook> -struct any_to_set_hook -/// @cond - : public detail::any_to_some_hook<BaseHook, any_rbtree_node_traits> -/// @endcond -{}; - -//!This option setter specifies that -//!any hook should behave as an avl_set hook -template<class BaseHook> -struct any_to_avl_set_hook -/// @cond - : public detail::any_to_some_hook<BaseHook, any_avltree_node_traits> -/// @endcond -{}; - -//!This option setter specifies that any -//!hook should behave as a bs_set hook -template<class BaseHook> -struct any_to_bs_set_hook -/// @cond - : public detail::any_to_some_hook<BaseHook, any_tree_node_traits> -/// @endcond -{}; - -//!This option setter specifies that any hook -//!should behave as an unordered set hook -template<class BaseHook> -struct any_to_unordered_set_hook -/// @cond - : public detail::any_to_some_hook<BaseHook, any_unordered_node_traits> -/// @endcond -{}; - - -} //namespace intrusive -} //namespace boost - -#include <boost/intrusive/detail/config_end.hpp> - -#endif //BOOST_INTRUSIVE_ANY_HOOK_HPP diff --git a/src/third_party/boost/boost/intrusive/avl_set.hpp b/src/third_party/boost/boost/intrusive/avl_set.hpp deleted file mode 100644 index 92baf473ce9..00000000000 --- a/src/third_party/boost/boost/intrusive/avl_set.hpp +++ /dev/null @@ -1,2358 +0,0 @@ -///////////////////////////////////////////////////////////////////////////// -// -// (C) Copyright Ion Gaztanaga 2007-2009 -// -// Distributed under the Boost Software License, Version 1.0. -// (See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) -// -// See http://www.boost.org/libs/intrusive for documentation. -// -///////////////////////////////////////////////////////////////////////////// -#ifndef BOOST_INTRUSIVE_AVL_SET_HPP -#define BOOST_INTRUSIVE_AVL_SET_HPP - -#include <boost/intrusive/detail/config_begin.hpp> -#include <boost/intrusive/intrusive_fwd.hpp> -#include <boost/intrusive/avltree.hpp> -#include <boost/intrusive/detail/mpl.hpp> -#include <boost/move/move.hpp> -#include <iterator> - -namespace boost { -namespace intrusive { - -//! The class template avl_set is an intrusive container, that mimics most of -//! the interface of std::set as described in the C++ standard. -//! -//! The template parameter \c T is the type to be managed by the container. -//! The user can specify additional options and if no options are provided -//! default options are used. -//! -//! The container supports the following options: -//! \c base_hook<>/member_hook<>/value_traits<>, -//! \c constant_time_size<>, \c size_type<> and -//! \c compare<>. -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -class avl_set_impl -{ - /// @cond - typedef avltree_impl<Config> tree_type; - //! This class is - //! movable - BOOST_MOVABLE_BUT_NOT_COPYABLE(avl_set_impl) - - typedef tree_type implementation_defined; - /// @endcond - - public: - typedef typename implementation_defined::value_type value_type; - typedef typename implementation_defined::value_traits value_traits; - typedef typename implementation_defined::pointer pointer; - typedef typename implementation_defined::const_pointer const_pointer; - typedef typename implementation_defined::reference reference; - typedef typename implementation_defined::const_reference const_reference; - typedef typename implementation_defined::difference_type difference_type; - typedef typename implementation_defined::size_type size_type; - typedef typename implementation_defined::value_compare value_compare; - typedef typename implementation_defined::key_compare key_compare; - typedef typename implementation_defined::iterator iterator; - typedef typename implementation_defined::const_iterator const_iterator; - typedef typename implementation_defined::reverse_iterator reverse_iterator; - typedef typename implementation_defined::const_reverse_iterator const_reverse_iterator; - typedef typename implementation_defined::insert_commit_data insert_commit_data; - typedef typename implementation_defined::node_traits node_traits; - typedef typename implementation_defined::node node; - typedef typename implementation_defined::node_ptr node_ptr; - typedef typename implementation_defined::const_node_ptr const_node_ptr; - typedef typename implementation_defined::node_algorithms node_algorithms; - - static const bool constant_time_size = Config::constant_time_size; - - /// @cond - private: - tree_type tree_; - /// @endcond - - public: - //! <b>Effects</b>: Constructs an empty avl_set. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: If value_traits::node_traits::node - //! constructor throws (this does not happen with predefined Boost.Intrusive hooks) - //! or the copy constructor of the value_compare object throws. - avl_set_impl( const value_compare &cmp = value_compare() - , const value_traits &v_traits = value_traits()) - : tree_(cmp, v_traits) - {} - - //! <b>Requires</b>: Dereferencing iterator must yield an lvalue of type value_type. - //! cmp must be a comparison function that induces a strict weak ordering. - //! - //! <b>Effects</b>: Constructs an empty avl_set and inserts elements from - //! [b, e). - //! - //! <b>Complexity</b>: Linear in N if [b, e) is already sorted using - //! comp and otherwise N * log N, where N is std::distance(last, first). - //! - //! <b>Throws</b>: If value_traits::node_traits::node - //! constructor throws (this does not happen with predefined Boost.Intrusive hooks) - //! or the copy constructor/operator() of the value_compare object throws. - template<class Iterator> - avl_set_impl( Iterator b, Iterator e - , const value_compare &cmp = value_compare() - , const value_traits &v_traits = value_traits()) - : tree_(true, b, e, cmp, v_traits) - {} - - //! <b>Effects</b>: to-do - //! - avl_set_impl(BOOST_RV_REF(avl_set_impl) x) - : tree_(::boost::move(x.tree_)) - {} - - //! <b>Effects</b>: to-do - //! - avl_set_impl& operator=(BOOST_RV_REF(avl_set_impl) x) - { tree_ = ::boost::move(x.tree_); return *this; } - - //! <b>Effects</b>: Detaches all elements from this. The objects in the avl_set - //! are not deleted (i.e. no destructors are called). - //! - //! <b>Complexity</b>: Linear to the number of elements on the container. - //! if it's a safe-mode or auto-unlink value_type. Constant time otherwise. - //! - //! <b>Throws</b>: Nothing. - ~avl_set_impl() - {} - - //! <b>Effects</b>: Returns an iterator pointing to the beginning of the avl_set. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - iterator begin() - { return tree_.begin(); } - - //! <b>Effects</b>: Returns a const_iterator pointing to the beginning of the avl_set. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_iterator begin() const - { return tree_.begin(); } - - //! <b>Effects</b>: Returns a const_iterator pointing to the beginning of the avl_set. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_iterator cbegin() const - { return tree_.cbegin(); } - - //! <b>Effects</b>: Returns an iterator pointing to the end of the avl_set. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - iterator end() - { return tree_.end(); } - - //! <b>Effects</b>: Returns a const_iterator pointing to the end of the avl_set. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_iterator end() const - { return tree_.end(); } - - //! <b>Effects</b>: Returns a const_iterator pointing to the end of the avl_set. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_iterator cend() const - { return tree_.cend(); } - - //! <b>Effects</b>: Returns a reverse_iterator pointing to the beginning of the - //! reversed avl_set. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - reverse_iterator rbegin() - { return tree_.rbegin(); } - - //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning - //! of the reversed avl_set. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_reverse_iterator rbegin() const - { return tree_.rbegin(); } - - //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning - //! of the reversed avl_set. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_reverse_iterator crbegin() const - { return tree_.crbegin(); } - - //! <b>Effects</b>: Returns a reverse_iterator pointing to the end - //! of the reversed avl_set. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - reverse_iterator rend() - { return tree_.rend(); } - - //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the end - //! of the reversed avl_set. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_reverse_iterator rend() const - { return tree_.rend(); } - - //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the end - //! of the reversed avl_set. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_reverse_iterator crend() const - { return tree_.crend(); } - - //! <b>Precondition</b>: end_iterator must be a valid end iterator - //! of avl_set. - //! - //! <b>Effects</b>: Returns a const reference to the avl_set associated to the end iterator - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - static avl_set_impl &container_from_end_iterator(iterator end_iterator) - { - return *detail::parent_from_member<avl_set_impl, tree_type> - ( &tree_type::container_from_end_iterator(end_iterator) - , &avl_set_impl::tree_); - } - - //! <b>Precondition</b>: end_iterator must be a valid end const_iterator - //! of avl_set. - //! - //! <b>Effects</b>: Returns a const reference to the set associated to the end iterator - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - static const avl_set_impl &container_from_end_iterator(const_iterator end_iterator) - { - return *detail::parent_from_member<avl_set_impl, tree_type> - ( &tree_type::container_from_end_iterator(end_iterator) - , &avl_set_impl::tree_); - } - - //! <b>Precondition</b>: it must be a valid iterator of set. - //! - //! <b>Effects</b>: Returns a reference to the set associated to the iterator - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Logarithmic. - static avl_set_impl &container_from_iterator(iterator it) - { - return *detail::parent_from_member<avl_set_impl, tree_type> - ( &tree_type::container_from_iterator(it) - , &avl_set_impl::tree_); - } - - //! <b>Precondition</b>: it must be a valid const_iterator of set. - //! - //! <b>Effects</b>: Returns a const reference to the set associated to the iterator - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Logarithmic. - static const avl_set_impl &container_from_iterator(const_iterator it) - { - return *detail::parent_from_member<avl_set_impl, tree_type> - ( &tree_type::container_from_iterator(it) - , &avl_set_impl::tree_); - } - - //! <b>Effects</b>: Returns the key_compare object used by the avl_set. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: If key_compare copy-constructor throws. - key_compare key_comp() const - { return tree_.value_comp(); } - - //! <b>Effects</b>: Returns the value_compare object used by the avl_set. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: If value_compare copy-constructor throws. - value_compare value_comp() const - { return tree_.value_comp(); } - - //! <b>Effects</b>: Returns true is the container is empty. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - bool empty() const - { return tree_.empty(); } - - //! <b>Effects</b>: Returns the number of elements stored in the avl_set. - //! - //! <b>Complexity</b>: Linear to elements contained in *this if, - //! constant-time size option is enabled. Constant-time otherwise. - //! - //! <b>Throws</b>: Nothing. - size_type size() const - { return tree_.size(); } - - //! <b>Effects</b>: Swaps the contents of two sets. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: If the swap() call for the comparison functor - //! found using ADL throws. Strong guarantee. - void swap(avl_set_impl& other) - { tree_.swap(other.tree_); } - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! Cloner should yield to nodes equivalent to the original nodes. - //! - //! <b>Effects</b>: Erases all the elements from *this - //! calling Disposer::operator()(pointer), clones all the - //! elements from src calling Cloner::operator()(const_reference ) - //! and inserts them on *this. Copies the predicate from the source container. - //! - //! If cloner throws, all cloned elements are unlinked and disposed - //! calling Disposer::operator()(pointer). - //! - //! <b>Complexity</b>: Linear to erased plus inserted elements. - //! - //! <b>Throws</b>: If cloner throws or predicate copy assignment throws. Basic guarantee. - template <class Cloner, class Disposer> - void clone_from(const avl_set_impl &src, Cloner cloner, Disposer disposer) - { tree_.clone_from(src.tree_, cloner, disposer); } - - //! <b>Requires</b>: value must be an lvalue - //! - //! <b>Effects</b>: Treaps to inserts value into the avl_set. - //! - //! <b>Returns</b>: If the value - //! is not already present inserts it and returns a pair containing the - //! iterator to the new value and true. If there is an equivalent value - //! returns a pair containing an iterator to the already present value - //! and false. - //! - //! <b>Complexity</b>: Average complexity for insert element is at - //! most logarithmic. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. Strong guarantee. - //! - //! <b>Note</b>: Does not affect the validity of iterators and references. - //! No copy-constructors are called. - std::pair<iterator, bool> insert(reference value) - { return tree_.insert_unique(value); } - - //! <b>Requires</b>: value must be an lvalue - //! - //! <b>Effects</b>: Treaps to to insert x into the avl_set, using "hint" - //! as a hint to where it will be inserted. - //! - //! <b>Returns</b>: An iterator that points to the position where the - //! new element was inserted into the avl_set. - //! - //! <b>Complexity</b>: Logarithmic in general, but it's amortized - //! constant time if t is inserted immediately before hint. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. Strong guarantee. - //! - //! <b>Note</b>: Does not affect the validity of iterators and references. - //! No copy-constructors are called. - iterator insert(const_iterator hint, reference value) - { return tree_.insert_unique(hint, value); } - - //! <b>Requires</b>: key_value_comp must be a comparison function that induces - //! the same strict weak ordering as value_compare. The difference is that - //! key_value_comp compares an arbitrary key with the contained values. - //! - //! <b>Effects</b>: Checks if a value can be inserted in the avl_set, using - //! a user provided key instead of the value itself. - //! - //! <b>Returns</b>: If there is an equivalent value - //! returns a pair containing an iterator to the already present value - //! and false. If the value can be inserted returns true in the returned - //! pair boolean and fills "commit_data" that is meant to be used with - //! the "insert_commit" function. - //! - //! <b>Complexity</b>: Average complexity is at most logarithmic. - //! - //! <b>Throws</b>: If the key_value_comp ordering function throws. Strong guarantee. - //! - //! <b>Notes</b>: This function is used to improve performance when constructing - //! a value_type is expensive: if there is an equivalent value - //! the constructed object must be discarded. Many times, the part of the - //! node that is used to impose the order is much cheaper to construct - //! than the value_type and this function offers the possibility to use that - //! part to check if the insertion will be successful. - //! - //! If the check is successful, the user can construct the value_type and use - //! "insert_commit" to insert the object in constant-time. This gives a total - //! logarithmic complexity to the insertion: check(O(log(N)) + commit(O(1)). - //! - //! "commit_data" remains valid for a subsequent "insert_commit" only if no more - //! objects are inserted or erased from the avl_set. - template<class KeyType, class KeyValueCompare> - std::pair<iterator, bool> insert_check - (const KeyType &key, KeyValueCompare key_value_comp, insert_commit_data &commit_data) - { return tree_.insert_unique_check(key, key_value_comp, commit_data); } - - //! <b>Requires</b>: key_value_comp must be a comparison function that induces - //! the same strict weak ordering as value_compare. The difference is that - //! key_value_comp compares an arbitrary key with the contained values. - //! - //! <b>Effects</b>: Checks if a value can be inserted in the avl_set, using - //! a user provided key instead of the value itself, using "hint" - //! as a hint to where it will be inserted. - //! - //! <b>Returns</b>: If there is an equivalent value - //! returns a pair containing an iterator to the already present value - //! and false. If the value can be inserted returns true in the returned - //! pair boolean and fills "commit_data" that is meant to be used with - //! the "insert_commit" function. - //! - //! <b>Complexity</b>: Logarithmic in general, but it's amortized - //! constant time if t is inserted immediately before hint. - //! - //! <b>Throws</b>: If the key_value_comp ordering function throws. Strong guarantee. - //! - //! <b>Notes</b>: This function is used to improve performance when constructing - //! a value_type is expensive: if there is an equivalent value - //! the constructed object must be discarded. Many times, the part of the - //! constructing that is used to impose the order is much cheaper to construct - //! than the value_type and this function offers the possibility to use that key - //! to check if the insertion will be successful. - //! - //! If the check is successful, the user can construct the value_type and use - //! "insert_commit" to insert the object in constant-time. This can give a total - //! constant-time complexity to the insertion: check(O(1)) + commit(O(1)). - //! - //! "commit_data" remains valid for a subsequent "insert_commit" only if no more - //! objects are inserted or erased from the avl_set. - template<class KeyType, class KeyValueCompare> - std::pair<iterator, bool> insert_check - (const_iterator hint, const KeyType &key - ,KeyValueCompare key_value_comp, insert_commit_data &commit_data) - { return tree_.insert_unique_check(hint, key, key_value_comp, commit_data); } - - //! <b>Requires</b>: value must be an lvalue of type value_type. commit_data - //! must have been obtained from a previous call to "insert_check". - //! No objects should have been inserted or erased from the avl_set between - //! the "insert_check" that filled "commit_data" and the call to "insert_commit". - //! - //! <b>Effects</b>: Inserts the value in the avl_set using the information obtained - //! from the "commit_data" that a previous "insert_check" filled. - //! - //! <b>Returns</b>: An iterator to the newly inserted object. - //! - //! <b>Complexity</b>: Constant time. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Notes</b>: This function has only sense if a "insert_check" has been - //! previously executed to fill "commit_data". No value should be inserted or - //! erased between the "insert_check" and "insert_commit" calls. - iterator insert_commit(reference value, const insert_commit_data &commit_data) - { return tree_.insert_unique_commit(value, commit_data); } - - //! <b>Requires</b>: Dereferencing iterator must yield an lvalue - //! of type value_type. - //! - //! <b>Effects</b>: Inserts a range into the avl_set. - //! - //! <b>Complexity</b>: Insert range is in general O(N * log(N)), where N is the - //! size of the range. However, it is linear in N if the range is already sorted - //! by value_comp(). - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. Basic guarantee. - //! - //! <b>Note</b>: Does not affect the validity of iterators and references. - //! No copy-constructors are called. - template<class Iterator> - void insert(Iterator b, Iterator e) - { tree_.insert_unique(b, e); } - - //! <b>Requires</b>: value must be an lvalue, "pos" must be - //! a valid iterator (or end) and must be the succesor of value - //! once inserted according to the predicate. "value" must not be equal to any - //! inserted key according to the predicate. - //! - //! <b>Effects</b>: Inserts x into the tree before "pos". - //! - //! <b>Complexity</b>: Constant time. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: This function does not check preconditions so if "pos" is not - //! the successor of "value" or "value" is not unique tree ordering and uniqueness - //! invariants will be broken respectively. - //! This is a low-level function to be used only for performance reasons - //! by advanced users. - iterator insert_before(const_iterator pos, reference value) - { return tree_.insert_before(pos, value); } - - //! <b>Requires</b>: value must be an lvalue, and it must be greater than - //! any inserted key according to the predicate. - //! - //! <b>Effects</b>: Inserts x into the tree in the last position. - //! - //! <b>Complexity</b>: Constant time. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: This function does not check preconditions so if value is - //! less than or equal to the greatest inserted key tree ordering invariant will be broken. - //! This function is slightly more efficient than using "insert_before". - //! This is a low-level function to be used only for performance reasons - //! by advanced users. - void push_back(reference value) - { tree_.push_back(value); } - - //! <b>Requires</b>: value must be an lvalue, and it must be less - //! than any inserted key according to the predicate. - //! - //! <b>Effects</b>: Inserts x into the tree in the first position. - //! - //! <b>Complexity</b>: Constant time. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: This function does not check preconditions so if value is - //! greater than or equal to the the mimum inserted key tree ordering or uniqueness - //! invariants will be broken. - //! This function is slightly more efficient than using "insert_before". - //! This is a low-level function to be used only for performance reasons - //! by advanced users. - void push_front(reference value) - { tree_.push_front(value); } - - //! <b>Effects</b>: Erases the element pointed to by pos. - //! - //! <b>Complexity</b>: Average complexity is constant time. - //! - //! <b>Returns</b>: An iterator to the element after the erased element. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - iterator erase(const_iterator i) - { return tree_.erase(i); } - - //! <b>Effects</b>: Erases the range pointed to by b end e. - //! - //! <b>Complexity</b>: Average complexity for erase range is at most - //! O(log(size() + N)), where N is the number of elements in the range. - //! - //! <b>Returns</b>: An iterator to the element after the erased elements. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - iterator erase(const_iterator b, const_iterator e) - { return tree_.erase(b, e); } - - //! <b>Effects</b>: Erases all the elements with the given value. - //! - //! <b>Returns</b>: The number of erased elements. - //! - //! <b>Complexity</b>: O(log(size()) + this->count(value)). - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. Basic guarantee. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - size_type erase(const_reference value) - { return tree_.erase(value); } - - //! <b>Effects</b>: Erases all the elements that compare equal with - //! the given key and the given comparison functor. - //! - //! <b>Returns</b>: The number of erased elements. - //! - //! <b>Complexity</b>: O(log(size() + this->count(key, comp)). - //! - //! <b>Throws</b>: If the comp ordering function throws. Basic guarantee. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - template<class KeyType, class KeyValueCompare> - size_type erase(const KeyType& key, KeyValueCompare comp - /// @cond - , typename detail::enable_if_c<!detail::is_convertible<KeyValueCompare, const_iterator>::value >::type * = 0 - /// @endcond - ) - { return tree_.erase(key, comp); } - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! - //! <b>Effects</b>: Erases the element pointed to by pos. - //! Disposer::operator()(pointer) is called for the removed element. - //! - //! <b>Complexity</b>: Average complexity for erase element is constant time. - //! - //! <b>Returns</b>: An iterator to the element after the erased element. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators - //! to the erased elements. - template<class Disposer> - iterator erase_and_dispose(const_iterator i, Disposer disposer) - { return tree_.erase_and_dispose(i, disposer); } - - #if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) - template<class Disposer> - iterator erase_and_dispose(iterator i, Disposer disposer) - { return this->erase_and_dispose(const_iterator(i), disposer); } - #endif - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! - //! <b>Effects</b>: Erases the range pointed to by b end e. - //! Disposer::operator()(pointer) is called for the removed elements. - //! - //! <b>Complexity</b>: Average complexity for erase range is at most - //! O(log(size() + N)), where N is the number of elements in the range. - //! - //! <b>Returns</b>: An iterator to the element after the erased elements. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators - //! to the erased elements. - template<class Disposer> - iterator erase_and_dispose(const_iterator b, const_iterator e, Disposer disposer) - { return tree_.erase_and_dispose(b, e, disposer); } - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! - //! <b>Effects</b>: Erases all the elements with the given value. - //! Disposer::operator()(pointer) is called for the removed elements. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. - //! - //! <b>Complexity</b>: O(log(size() + this->count(value)). Basic guarantee. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - template<class Disposer> - size_type erase_and_dispose(const_reference value, Disposer disposer) - { return tree_.erase_and_dispose(value, disposer); } - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! - //! <b>Effects</b>: Erases all the elements with the given key. - //! according to the comparison functor "comp". - //! Disposer::operator()(pointer) is called for the removed elements. - //! - //! <b>Returns</b>: The number of erased elements. - //! - //! <b>Complexity</b>: O(log(size() + this->count(key, comp)). - //! - //! <b>Throws</b>: If comp ordering function throws. Basic guarantee. - //! - //! <b>Note</b>: Invalidates the iterators - //! to the erased elements. - template<class KeyType, class KeyValueCompare, class Disposer> - size_type erase_and_dispose(const KeyType& key, KeyValueCompare comp, Disposer disposer - /// @cond - , typename detail::enable_if_c<!detail::is_convertible<KeyValueCompare, const_iterator>::value >::type * = 0 - /// @endcond - ) - { return tree_.erase_and_dispose(key, comp, disposer); } - - //! <b>Effects</b>: Erases all the elements of the container. - //! - //! <b>Complexity</b>: Linear to the number of elements on the container. - //! if it's a safe-mode or auto-unlink value_type. Constant time otherwise. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - void clear() - { return tree_.clear(); } - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! - //! <b>Effects</b>: Erases all the elements of the container. - //! - //! <b>Complexity</b>: Linear to the number of elements on the container. - //! Disposer::operator()(pointer) is called for the removed elements. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - template<class Disposer> - void clear_and_dispose(Disposer disposer) - { return tree_.clear_and_dispose(disposer); } - - //! <b>Effects</b>: Returns the number of contained elements with the given key - //! - //! <b>Complexity</b>: Logarithmic to the number of elements contained plus lineal - //! to number of objects with the given key. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. - size_type count(const_reference value) const - { return tree_.find(value) != end(); } - - //! <b>Effects</b>: Returns the number of contained elements with the same key - //! compared with the given comparison functor. - //! - //! <b>Complexity</b>: Logarithmic to the number of elements contained plus lineal - //! to number of objects with the given key. - //! - //! <b>Throws</b>: If comp ordering function throws. - template<class KeyType, class KeyValueCompare> - size_type count(const KeyType& key, KeyValueCompare comp) const - { return tree_.find(key, comp) != end(); } - - //! <b>Effects</b>: Returns an iterator to the first element whose - //! key is not less than k or end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. - iterator lower_bound(const_reference value) - { return tree_.lower_bound(value); } - - //! <b>Requires</b>: comp must imply the same element order as - //! value_compare. Usually key is the part of the value_type - //! that is used in the ordering functor. - //! - //! <b>Effects</b>: Returns an iterator to the first element whose - //! key according to the comparison functor is not less than k or - //! end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If comp ordering function throws. - //! - //! <b>Note</b>: This function is used when constructing a value_type - //! is expensive and the value_type can be compared with a cheaper - //! key type. Usually this key is part of the value_type. - template<class KeyType, class KeyValueCompare> - iterator lower_bound(const KeyType& key, KeyValueCompare comp) - { return tree_.lower_bound(key, comp); } - - //! <b>Effects</b>: Returns a const iterator to the first element whose - //! key is not less than k or end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. - const_iterator lower_bound(const_reference value) const - { return tree_.lower_bound(value); } - - //! <b>Requires</b>: comp must imply the same element order as - //! value_compare. Usually key is the part of the value_type - //! that is used in the ordering functor. - //! - //! <b>Effects</b>: Returns a const_iterator to the first element whose - //! key according to the comparison functor is not less than k or - //! end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If comp ordering function throws. - //! - //! <b>Note</b>: This function is used when constructing a value_type - //! is expensive and the value_type can be compared with a cheaper - //! key type. Usually this key is part of the value_type. - template<class KeyType, class KeyValueCompare> - const_iterator lower_bound(const KeyType& key, KeyValueCompare comp) const - { return tree_.lower_bound(key, comp); } - - //! <b>Effects</b>: Returns an iterator to the first element whose - //! key is greater than k or end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. - iterator upper_bound(const_reference value) - { return tree_.upper_bound(value); } - - //! <b>Requires</b>: comp must imply the same element order as - //! value_compare. Usually key is the part of the value_type - //! that is used in the ordering functor. - //! - //! <b>Effects</b>: Returns an iterator to the first element whose - //! key according to the comparison functor is greater than key or - //! end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If comp ordering function throws. - //! - //! <b>Note</b>: This function is used when constructing a value_type - //! is expensive and the value_type can be compared with a cheaper - //! key type. Usually this key is part of the value_type. - template<class KeyType, class KeyValueCompare> - iterator upper_bound(const KeyType& key, KeyValueCompare comp) - { return tree_.upper_bound(key, comp); } - - //! <b>Effects</b>: Returns an iterator to the first element whose - //! key is greater than k or end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. - const_iterator upper_bound(const_reference value) const - { return tree_.upper_bound(value); } - - //! <b>Requires</b>: comp must imply the same element order as - //! value_compare. Usually key is the part of the value_type - //! that is used in the ordering functor. - //! - //! <b>Effects</b>: Returns a const_iterator to the first element whose - //! key according to the comparison functor is greater than key or - //! end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If comp ordering function throws. - //! - //! <b>Note</b>: This function is used when constructing a value_type - //! is expensive and the value_type can be compared with a cheaper - //! key type. Usually this key is part of the value_type. - template<class KeyType, class KeyValueCompare> - const_iterator upper_bound(const KeyType& key, KeyValueCompare comp) const - { return tree_.upper_bound(key, comp); } - - //! <b>Effects</b>: Finds an iterator to the first element whose value is - //! "value" or end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. - iterator find(const_reference value) - { return tree_.find(value); } - - //! <b>Requires</b>: comp must imply the same element order as - //! value_compare. Usually key is the part of the value_type - //! that is used in the ordering functor. - //! - //! <b>Effects</b>: Finds an iterator to the first element whose key is - //! "key" according to the comparison functor or end() if that element - //! does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If comp ordering function throws. - //! - //! <b>Note</b>: This function is used when constructing a value_type - //! is expensive and the value_type can be compared with a cheaper - //! key type. Usually this key is part of the value_type. - template<class KeyType, class KeyValueCompare> - iterator find(const KeyType& key, KeyValueCompare comp) - { return tree_.find(key, comp); } - - //! <b>Effects</b>: Finds a const_iterator to the first element whose value is - //! "value" or end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. - const_iterator find(const_reference value) const - { return tree_.find(value); } - - //! <b>Requires</b>: comp must imply the same element order as - //! value_compare. Usually key is the part of the value_type - //! that is used in the ordering functor. - //! - //! <b>Effects</b>: Finds a const_iterator to the first element whose key is - //! "key" according to the comparison functor or end() if that element - //! does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If comp ordering function throws. - //! - //! <b>Note</b>: This function is used when constructing a value_type - //! is expensive and the value_type can be compared with a cheaper - //! key type. Usually this key is part of the value_type. - template<class KeyType, class KeyValueCompare> - const_iterator find(const KeyType& key, KeyValueCompare comp) const - { return tree_.find(key, comp); } - - //! <b>Effects</b>: Finds a range containing all elements whose key is k or - //! an empty range that indicates the position where those elements would be - //! if they there is no elements with key k. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. - std::pair<iterator,iterator> equal_range(const_reference value) - { return tree_.equal_range(value); } - - //! <b>Requires</b>: comp must imply the same element order as - //! value_compare. Usually key is the part of the value_type - //! that is used in the ordering functor. - //! - //! <b>Effects</b>: Finds a range containing all elements whose key is k - //! according to the comparison functor or an empty range - //! that indicates the position where those elements would be - //! if they there is no elements with key k. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If comp ordering function throws. - //! - //! <b>Note</b>: This function is used when constructing a value_type - //! is expensive and the value_type can be compared with a cheaper - //! key type. Usually this key is part of the value_type. - template<class KeyType, class KeyValueCompare> - std::pair<iterator,iterator> equal_range(const KeyType& key, KeyValueCompare comp) - { return tree_.equal_range(key, comp); } - - //! <b>Effects</b>: Finds a range containing all elements whose key is k or - //! an empty range that indicates the position where those elements would be - //! if they there is no elements with key k. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. - std::pair<const_iterator, const_iterator> - equal_range(const_reference value) const - { return tree_.equal_range(value); } - - //! <b>Requires</b>: comp must imply the same element order as - //! value_compare. Usually key is the part of the value_type - //! that is used in the ordering functor. - //! - //! <b>Effects</b>: Finds a range containing all elements whose key is k - //! according to the comparison functor or an empty range - //! that indicates the position where those elements would be - //! if they there is no elements with key k. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If comp ordering function throws. - //! - //! <b>Note</b>: This function is used when constructing a value_type - //! is expensive and the value_type can be compared with a cheaper - //! key type. Usually this key is part of the value_type. - template<class KeyType, class KeyValueCompare> - std::pair<const_iterator, const_iterator> - equal_range(const KeyType& key, KeyValueCompare comp) const - { return tree_.equal_range(key, comp); } - - //! <b>Requires</b>: value must be an lvalue and shall be in a avl_set of - //! appropriate type. Otherwise the behavior is undefined. - //! - //! <b>Effects</b>: Returns: a valid iterator i belonging to the avl_set - //! that points to the value - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: This static function is available only if the <i>value traits</i> - //! is stateless. - static iterator s_iterator_to(reference value) - { return tree_type::s_iterator_to(value); } - - //! <b>Requires</b>: value must be an lvalue and shall be in a avl_set of - //! appropriate type. Otherwise the behavior is undefined. - //! - //! <b>Effects</b>: Returns: a valid const_iterator i belonging to the - //! avl_set that points to the value - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: This static function is available only if the <i>value traits</i> - //! is stateless. - static const_iterator s_iterator_to(const_reference value) - { return tree_type::s_iterator_to(value); } - - //! <b>Requires</b>: value must be an lvalue and shall be in a avl_set of - //! appropriate type. Otherwise the behavior is undefined. - //! - //! <b>Effects</b>: Returns: a valid iterator i belonging to the avl_set - //! that points to the value - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - iterator iterator_to(reference value) - { return tree_.iterator_to(value); } - - //! <b>Requires</b>: value must be an lvalue and shall be in a avl_set of - //! appropriate type. Otherwise the behavior is undefined. - //! - //! <b>Effects</b>: Returns: a valid const_iterator i belonging to the - //! avl_set that points to the value - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_iterator iterator_to(const_reference value) const - { return tree_.iterator_to(value); } - - //! <b>Requires</b>: value shall not be in a avl_set/avl_multiset. - //! - //! <b>Effects</b>: init_node puts the hook of a value in a well-known default - //! state. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant time. - //! - //! <b>Note</b>: This function puts the hook in the well-known default state - //! used by auto_unlink and safe hooks. - static void init_node(reference value) - { tree_type::init_node(value); } - - //! <b>Effects</b>: Unlinks the leftmost node from the tree. - //! - //! <b>Complexity</b>: Average complexity is constant time. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Notes</b>: This function breaks the tree and the tree can - //! only be used for more unlink_leftmost_without_rebalance calls. - //! This function is normally used to achieve a step by step - //! controlled destruction of the tree. - pointer unlink_leftmost_without_rebalance() - { return tree_.unlink_leftmost_without_rebalance(); } - - //! <b>Requires</b>: replace_this must be a valid iterator of *this - //! and with_this must not be inserted in any tree. - //! - //! <b>Effects</b>: Replaces replace_this in its position in the - //! tree with with_this. The tree does not need to be rebalanced. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: This function will break container ordering invariants if - //! with_this is not equivalent to *replace_this according to the - //! ordering rules. This function is faster than erasing and inserting - //! the node, since no rebalancing or comparison is needed. - void replace_node(iterator replace_this, reference with_this) - { tree_.replace_node(replace_this, with_this); } - - /// @cond - friend bool operator==(const avl_set_impl &x, const avl_set_impl &y) - { return x.tree_ == y.tree_; } - - friend bool operator<(const avl_set_impl &x, const avl_set_impl &y) - { return x.tree_ < y.tree_; } - /// @endcond -}; - -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -inline bool operator!= -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -(const avl_set_impl<T, Options...> &x, const avl_set_impl<T, Options...> &y) -#else -(const avl_set_impl<Config> &x, const avl_set_impl<Config> &y) -#endif -{ return !(x == y); } - -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -inline bool operator> -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -(const avl_set_impl<T, Options...> &x, const avl_set_impl<T, Options...> &y) -#else -(const avl_set_impl<Config> &x, const avl_set_impl<Config> &y) -#endif -{ return y < x; } - -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -inline bool operator<= -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -(const avl_set_impl<T, Options...> &x, const avl_set_impl<T, Options...> &y) -#else -(const avl_set_impl<Config> &x, const avl_set_impl<Config> &y) -#endif -{ return !(y < x); } - -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -inline bool operator>= -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -(const avl_set_impl<T, Options...> &x, const avl_set_impl<T, Options...> &y) -#else -(const avl_set_impl<Config> &x, const avl_set_impl<Config> &y) -#endif -{ return !(x < y); } - -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -inline void swap -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -(avl_set_impl<T, Options...> &x, avl_set_impl<T, Options...> &y) -#else -(avl_set_impl<Config> &x, avl_set_impl<Config> &y) -#endif -{ x.swap(y); } - -//! Helper metafunction to define a \c avl_set that yields to the same type when the -//! same options (either explicitly or implicitly) are used. -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) || defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template<class T, class ...Options> -#else -template<class T, class O1 = none, class O2 = none - , class O3 = none, class O4 = none> -#endif -struct make_avl_set -{ - /// @cond - typedef avl_set_impl - < typename make_avltree_opt - #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) - <T, O1, O2, O3, O4> - #else - <T, Options...> - #endif - ::type - > implementation_defined; - /// @endcond - typedef implementation_defined type; -}; - -#ifndef BOOST_INTRUSIVE_DOXYGEN_INVOKED - -#if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template<class T, class O1, class O2, class O3, class O4> -#else -template<class T, class ...Options> -#endif -class avl_set - : public make_avl_set - #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) - <T, O1, O2, O3, O4> - #else - <T, Options...> - #endif - ::type -{ - typedef typename make_avl_set - #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) - <T, O1, O2, O3, O4> - #else - <T, Options...> - #endif - ::type Base; - - BOOST_MOVABLE_BUT_NOT_COPYABLE(avl_set) - public: - typedef typename Base::value_compare value_compare; - typedef typename Base::value_traits value_traits; - typedef typename Base::iterator iterator; - typedef typename Base::const_iterator const_iterator; - - //Assert if passed value traits are compatible with the type - BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value)); - - avl_set( const value_compare &cmp = value_compare() - , const value_traits &v_traits = value_traits()) - : Base(cmp, v_traits) - {} - - template<class Iterator> - avl_set( Iterator b, Iterator e - , const value_compare &cmp = value_compare() - , const value_traits &v_traits = value_traits()) - : Base(b, e, cmp, v_traits) - {} - - avl_set(BOOST_RV_REF(avl_set) x) - : Base(::boost::move(static_cast<Base&>(x))) - {} - - avl_set& operator=(BOOST_RV_REF(avl_set) x) - { this->Base::operator=(::boost::move(static_cast<Base&>(x))); return *this; } - - static avl_set &container_from_end_iterator(iterator end_iterator) - { return static_cast<avl_set &>(Base::container_from_end_iterator(end_iterator)); } - - static const avl_set &container_from_end_iterator(const_iterator end_iterator) - { return static_cast<const avl_set &>(Base::container_from_end_iterator(end_iterator)); } - - static avl_set &container_from_iterator(iterator end_iterator) - { return static_cast<avl_set &>(Base::container_from_iterator(end_iterator)); } - - static const avl_set &container_from_iterator(const_iterator end_iterator) - { return static_cast<const avl_set &>(Base::container_from_iterator(end_iterator)); } -}; - -#endif - -//! The class template avl_multiset is an intrusive container, that mimics most of -//! the interface of std::avl_multiset as described in the C++ standard. -//! -//! The template parameter \c T is the type to be managed by the container. -//! The user can specify additional options and if no options are provided -//! default options are used. -//! -//! The container supports the following options: -//! \c base_hook<>/member_hook<>/value_traits<>, -//! \c constant_time_size<>, \c size_type<> and -//! \c compare<>. -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -class avl_multiset_impl -{ - /// @cond - typedef avltree_impl<Config> tree_type; - - //Movable - BOOST_MOVABLE_BUT_NOT_COPYABLE(avl_multiset_impl) - typedef tree_type implementation_defined; - /// @endcond - - public: - typedef typename implementation_defined::value_type value_type; - typedef typename implementation_defined::value_traits value_traits; - typedef typename implementation_defined::pointer pointer; - typedef typename implementation_defined::const_pointer const_pointer; - typedef typename implementation_defined::reference reference; - typedef typename implementation_defined::const_reference const_reference; - typedef typename implementation_defined::difference_type difference_type; - typedef typename implementation_defined::size_type size_type; - typedef typename implementation_defined::value_compare value_compare; - typedef typename implementation_defined::key_compare key_compare; - typedef typename implementation_defined::iterator iterator; - typedef typename implementation_defined::const_iterator const_iterator; - typedef typename implementation_defined::reverse_iterator reverse_iterator; - typedef typename implementation_defined::const_reverse_iterator const_reverse_iterator; - typedef typename implementation_defined::insert_commit_data insert_commit_data; - typedef typename implementation_defined::node_traits node_traits; - typedef typename implementation_defined::node node; - typedef typename implementation_defined::node_ptr node_ptr; - typedef typename implementation_defined::const_node_ptr const_node_ptr; - typedef typename implementation_defined::node_algorithms node_algorithms; - - static const bool constant_time_size = Config::constant_time_size; - - /// @cond - private: - tree_type tree_; - /// @endcond - - public: - //! <b>Effects</b>: Constructs an empty avl_multiset. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: If value_traits::node_traits::node - //! constructor throws (this does not happen with predefined Boost.Intrusive hooks) - //! or the copy constructor/operator() of the value_compare object throws. - avl_multiset_impl( const value_compare &cmp = value_compare() - , const value_traits &v_traits = value_traits()) - : tree_(cmp, v_traits) - {} - - //! <b>Requires</b>: Dereferencing iterator must yield an lvalue of type value_type. - //! cmp must be a comparison function that induces a strict weak ordering. - //! - //! <b>Effects</b>: Constructs an empty avl_multiset and inserts elements from - //! [b, e). - //! - //! <b>Complexity</b>: Linear in N if [b, e) is already sorted using - //! comp and otherwise N * log N, where N is the distance between first and last - //! - //! <b>Throws</b>: If value_traits::node_traits::node - //! constructor throws (this does not happen with predefined Boost.Intrusive hooks) - //! or the copy constructor/operator() of the value_compare object throws. - template<class Iterator> - avl_multiset_impl( Iterator b, Iterator e - , const value_compare &cmp = value_compare() - , const value_traits &v_traits = value_traits()) - : tree_(false, b, e, cmp, v_traits) - {} - - //! <b>Effects</b>: to-do - //! - avl_multiset_impl(BOOST_RV_REF(avl_multiset_impl) x) - : tree_(::boost::move(x.tree_)) - {} - - //! <b>Effects</b>: to-do - //! - avl_multiset_impl& operator=(BOOST_RV_REF(avl_multiset_impl) x) - { tree_ = ::boost::move(x.tree_); return *this; } - - //! <b>Effects</b>: Detaches all elements from this. The objects in the avl_multiset - //! are not deleted (i.e. no destructors are called). - //! - //! <b>Complexity</b>: Linear to the number of elements on the container. - //! if it's a safe-mode or auto-unlink value_type. Constant time otherwise. - //! - //! <b>Throws</b>: Nothing. - ~avl_multiset_impl() - {} - - //! <b>Effects</b>: Returns an iterator pointing to the beginning of the avl_multiset. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - iterator begin() - { return tree_.begin(); } - - //! <b>Effects</b>: Returns a const_iterator pointing to the beginning of the avl_multiset. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_iterator begin() const - { return tree_.begin(); } - - //! <b>Effects</b>: Returns a const_iterator pointing to the beginning of the avl_multiset. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_iterator cbegin() const - { return tree_.cbegin(); } - - //! <b>Effects</b>: Returns an iterator pointing to the end of the avl_multiset. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - iterator end() - { return tree_.end(); } - - //! <b>Effects</b>: Returns a const_iterator pointing to the end of the avl_multiset. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_iterator end() const - { return tree_.end(); } - - //! <b>Effects</b>: Returns a const_iterator pointing to the end of the avl_multiset. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_iterator cend() const - { return tree_.cend(); } - - //! <b>Effects</b>: Returns a reverse_iterator pointing to the beginning of the - //! reversed avl_multiset. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - reverse_iterator rbegin() - { return tree_.rbegin(); } - - //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning - //! of the reversed avl_multiset. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_reverse_iterator rbegin() const - { return tree_.rbegin(); } - - //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning - //! of the reversed avl_multiset. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_reverse_iterator crbegin() const - { return tree_.crbegin(); } - - //! <b>Effects</b>: Returns a reverse_iterator pointing to the end - //! of the reversed avl_multiset. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - reverse_iterator rend() - { return tree_.rend(); } - - //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the end - //! of the reversed avl_multiset. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_reverse_iterator rend() const - { return tree_.rend(); } - - //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the end - //! of the reversed avl_multiset. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_reverse_iterator crend() const - { return tree_.crend(); } - - //! <b>Precondition</b>: end_iterator must be a valid end iterator - //! of avl_multiset. - //! - //! <b>Effects</b>: Returns a const reference to the avl_multiset associated to the end iterator - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - static avl_multiset_impl &container_from_end_iterator(iterator end_iterator) - { - return *detail::parent_from_member<avl_multiset_impl, tree_type> - ( &tree_type::container_from_end_iterator(end_iterator) - , &avl_multiset_impl::tree_); - } - - //! <b>Precondition</b>: end_iterator must be a valid end const_iterator - //! of avl_multiset. - //! - //! <b>Effects</b>: Returns a const reference to the avl_multiset associated to the end iterator - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - static const avl_multiset_impl &container_from_end_iterator(const_iterator end_iterator) - { - return *detail::parent_from_member<avl_multiset_impl, tree_type> - ( &tree_type::container_from_end_iterator(end_iterator) - , &avl_multiset_impl::tree_); - } - - //! <b>Precondition</b>: it must be a valid iterator of multiset. - //! - //! <b>Effects</b>: Returns a const reference to the multiset associated to the iterator - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Logarithmic. - static avl_multiset_impl &container_from_iterator(iterator it) - { - return *detail::parent_from_member<avl_multiset_impl, tree_type> - ( &tree_type::container_from_iterator(it) - , &avl_multiset_impl::tree_); - } - - //! <b>Precondition</b>: it must be a valid const_iterator of multiset. - //! - //! <b>Effects</b>: Returns a const reference to the multiset associated to the iterator - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Logarithmic. - static const avl_multiset_impl &container_from_iterator(const_iterator it) - { - return *detail::parent_from_member<avl_multiset_impl, tree_type> - ( &tree_type::container_from_iterator(it) - , &avl_multiset_impl::tree_); - } - - //! <b>Effects</b>: Returns the key_compare object used by the avl_multiset. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: If key_compare copy-constructor throws. - key_compare key_comp() const - { return tree_.value_comp(); } - - //! <b>Effects</b>: Returns the value_compare object used by the avl_multiset. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: If value_compare copy-constructor throws. - value_compare value_comp() const - { return tree_.value_comp(); } - - //! <b>Effects</b>: Returns true is the container is empty. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - bool empty() const - { return tree_.empty(); } - - //! <b>Effects</b>: Returns the number of elements stored in the avl_multiset. - //! - //! <b>Complexity</b>: Linear to elements contained in *this if, - //! constant-time size option is enabled. Constant-time otherwise. - //! - //! <b>Throws</b>: Nothing. - size_type size() const - { return tree_.size(); } - - //! <b>Effects</b>: Swaps the contents of two avl_multisets. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: If the swap() call for the comparison functor - //! found using ADL throws. Strong guarantee. - void swap(avl_multiset_impl& other) - { tree_.swap(other.tree_); } - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! Cloner should yield to nodes equivalent to the original nodes. - //! - //! <b>Effects</b>: Erases all the elements from *this - //! calling Disposer::operator()(pointer), clones all the - //! elements from src calling Cloner::operator()(const_reference ) - //! and inserts them on *this. Copies the predicate from the source container. - //! - //! If cloner throws, all cloned elements are unlinked and disposed - //! calling Disposer::operator()(pointer). - //! - //! <b>Complexity</b>: Linear to erased plus inserted elements. - //! - //! <b>Throws</b>: If cloner throws or predicate copy assignment throws. Basic guarantee. - template <class Cloner, class Disposer> - void clone_from(const avl_multiset_impl &src, Cloner cloner, Disposer disposer) - { tree_.clone_from(src.tree_, cloner, disposer); } - - //! <b>Requires</b>: value must be an lvalue - //! - //! <b>Effects</b>: Inserts value into the avl_multiset. - //! - //! <b>Returns</b>: An iterator that points to the position where the new - //! element was inserted. - //! - //! <b>Complexity</b>: Average complexity for insert element is at - //! most logarithmic. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. Strong guarantee. - //! - //! <b>Note</b>: Does not affect the validity of iterators and references. - //! No copy-constructors are called. - iterator insert(reference value) - { return tree_.insert_equal(value); } - - //! <b>Requires</b>: value must be an lvalue - //! - //! <b>Effects</b>: Inserts x into the avl_multiset, using pos as a hint to - //! where it will be inserted. - //! - //! <b>Returns</b>: An iterator that points to the position where the new - //! element was inserted. - //! - //! <b>Complexity</b>: Logarithmic in general, but it is amortized - //! constant time if t is inserted immediately before hint. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. Strong guarantee. - //! - //! <b>Note</b>: Does not affect the validity of iterators and references. - //! No copy-constructors are called. - iterator insert(const_iterator hint, reference value) - { return tree_.insert_equal(hint, value); } - - //! <b>Requires</b>: Dereferencing iterator must yield an lvalue - //! of type value_type. - //! - //! <b>Effects</b>: Inserts a range into the avl_multiset. - //! - //! <b>Returns</b>: An iterator that points to the position where the new - //! element was inserted. - //! - //! <b>Complexity</b>: Insert range is in general O(N * log(N)), where N is the - //! size of the range. However, it is linear in N if the range is already sorted - //! by value_comp(). - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. Basic guarantee. - //! - //! <b>Note</b>: Does not affect the validity of iterators and references. - //! No copy-constructors are called. - template<class Iterator> - void insert(Iterator b, Iterator e) - { tree_.insert_equal(b, e); } - - //! <b>Requires</b>: value must be an lvalue, "pos" must be - //! a valid iterator (or end) and must be the succesor of value - //! once inserted according to the predicate. "value" must not be equal to any - //! inserted key according to the predicate. - //! - //! <b>Effects</b>: Inserts x into the tree before "pos". - //! - //! <b>Complexity</b>: Constant time. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: This function does not check preconditions so if "pos" is not - //! the successor of "value" or "value" is not unique tree ordering and uniqueness - //! invariants will be broken respectively. - //! This is a low-level function to be used only for performance reasons - //! by advanced users. - iterator insert_before(const_iterator pos, reference value) - { return tree_.insert_before(pos, value); } - - //! <b>Requires</b>: value must be an lvalue, and it must be greater than - //! any inserted key according to the predicate. - //! - //! <b>Effects</b>: Inserts x into the tree in the last position. - //! - //! <b>Complexity</b>: Constant time. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: This function does not check preconditions so if value is - //! less than or equal to the greatest inserted key tree ordering invariant will be broken. - //! This function is slightly more efficient than using "insert_before". - //! This is a low-level function to be used only for performance reasons - //! by advanced users. - void push_back(reference value) - { tree_.push_back(value); } - - //! <b>Requires</b>: value must be an lvalue, and it must be less - //! than any inserted key according to the predicate. - //! - //! <b>Effects</b>: Inserts x into the tree in the first position. - //! - //! <b>Complexity</b>: Constant time. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: This function does not check preconditions so if value is - //! greater than or equal to the the mimum inserted key tree ordering or uniqueness - //! invariants will be broken. - //! This function is slightly more efficient than using "insert_before". - //! This is a low-level function to be used only for performance reasons - //! by advanced users. - void push_front(reference value) - { tree_.push_front(value); } - - //! <b>Effects</b>: Erases the element pointed to by pos. - //! - //! <b>Complexity</b>: Average complexity is constant time. - //! - //! <b>Returns</b>: An iterator to the element after the erased element. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - iterator erase(const_iterator i) - { return tree_.erase(i); } - - //! <b>Effects</b>: Erases the range pointed to by b end e. - //! - //! <b>Returns</b>: An iterator to the element after the erased elements. - //! - //! <b>Complexity</b>: Average complexity for erase range is at most - //! O(log(size() + N)), where N is the number of elements in the range. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - iterator erase(const_iterator b, const_iterator e) - { return tree_.erase(b, e); } - - //! <b>Effects</b>: Erases all the elements with the given value. - //! - //! <b>Returns</b>: The number of erased elements. - //! - //! <b>Complexity</b>: O(log(size() + this->count(value)). - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. Basic guarantee. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - size_type erase(const_reference value) - { return tree_.erase(value); } - - //! <b>Effects</b>: Erases all the elements that compare equal with - //! the given key and the given comparison functor. - //! - //! <b>Returns</b>: The number of erased elements. - //! - //! <b>Complexity</b>: O(log(size() + this->count(key, comp)). - //! - //! <b>Throws</b>: If comp ordering function throws. Basic guarantee. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - template<class KeyType, class KeyValueCompare> - size_type erase(const KeyType& key, KeyValueCompare comp - /// @cond - , typename detail::enable_if_c<!detail::is_convertible<KeyValueCompare, const_iterator>::value >::type * = 0 - /// @endcond - ) - { return tree_.erase(key, comp); } - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! - //! <b>Returns</b>: An iterator to the element after the erased element. - //! - //! <b>Effects</b>: Erases the element pointed to by pos. - //! Disposer::operator()(pointer) is called for the removed element. - //! - //! <b>Complexity</b>: Average complexity for erase element is constant time. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators - //! to the erased elements. - template<class Disposer> - iterator erase_and_dispose(const_iterator i, Disposer disposer) - { return tree_.erase_and_dispose(i, disposer); } - - #if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) - template<class Disposer> - iterator erase_and_dispose(iterator i, Disposer disposer) - { return this->erase_and_dispose(const_iterator(i), disposer); } - #endif - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! - //! <b>Returns</b>: An iterator to the element after the erased elements. - //! - //! <b>Effects</b>: Erases the range pointed to by b end e. - //! Disposer::operator()(pointer) is called for the removed elements. - //! - //! <b>Complexity</b>: Average complexity for erase range is at most - //! O(log(size() + N)), where N is the number of elements in the range. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators - //! to the erased elements. - template<class Disposer> - iterator erase_and_dispose(const_iterator b, const_iterator e, Disposer disposer) - { return tree_.erase_and_dispose(b, e, disposer); } - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! - //! <b>Effects</b>: Erases all the elements with the given value. - //! Disposer::operator()(pointer) is called for the removed elements. - //! - //! <b>Returns</b>: The number of erased elements. - //! - //! <b>Complexity</b>: O(log(size() + this->count(value)). - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. Basic guarantee. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - template<class Disposer> - size_type erase_and_dispose(const_reference value, Disposer disposer) - { return tree_.erase_and_dispose(value, disposer); } - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! - //! <b>Effects</b>: Erases all the elements with the given key. - //! according to the comparison functor "comp". - //! Disposer::operator()(pointer) is called for the removed elements. - //! - //! <b>Returns</b>: The number of erased elements. - //! - //! <b>Complexity</b>: O(log(size() + this->count(key, comp)). - //! - //! <b>Throws</b>: If comp ordering function throws. Basic guarantee. - //! - //! <b>Note</b>: Invalidates the iterators - //! to the erased elements. - template<class KeyType, class KeyValueCompare, class Disposer> - size_type erase_and_dispose(const KeyType& key, KeyValueCompare comp, Disposer disposer - /// @cond - , typename detail::enable_if_c<!detail::is_convertible<KeyValueCompare, const_iterator>::value >::type * = 0 - /// @endcond - ) - { return tree_.erase_and_dispose(key, comp, disposer); } - - //! <b>Effects</b>: Erases all the elements of the container. - //! - //! <b>Complexity</b>: Linear to the number of elements on the container. - //! if it's a safe-mode or auto-unlink value_type. Constant time otherwise. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - void clear() - { return tree_.clear(); } - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! - //! <b>Effects</b>: Erases all the elements of the container. - //! - //! <b>Complexity</b>: Linear to the number of elements on the container. - //! Disposer::operator()(pointer) is called for the removed elements. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - template<class Disposer> - void clear_and_dispose(Disposer disposer) - { return tree_.clear_and_dispose(disposer); } - - //! <b>Effects</b>: Returns the number of contained elements with the given key - //! - //! <b>Complexity</b>: Logarithmic to the number of elements contained plus lineal - //! to number of objects with the given key. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. - size_type count(const_reference value) const - { return tree_.count(value); } - - //! <b>Effects</b>: Returns the number of contained elements with the same key - //! compared with the given comparison functor. - //! - //! <b>Complexity</b>: Logarithmic to the number of elements contained plus lineal - //! to number of objects with the given key. - //! - //! <b>Throws</b>: If comp ordering function throws. - template<class KeyType, class KeyValueCompare> - size_type count(const KeyType& key, KeyValueCompare comp) const - { return tree_.count(key, comp); } - - //! <b>Effects</b>: Returns an iterator to the first element whose - //! key is not less than k or end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. - iterator lower_bound(const_reference value) - { return tree_.lower_bound(value); } - - //! <b>Requires</b>: comp must imply the same element order as - //! value_compare. Usually key is the part of the value_type - //! that is used in the ordering functor. - //! - //! <b>Effects</b>: Returns an iterator to the first element whose - //! key according to the comparison functor is not less than k or - //! end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If comp ordering function throws. - //! - //! <b>Note</b>: This function is used when constructing a value_type - //! is expensive and the value_type can be compared with a cheaper - //! key type. Usually this key is part of the value_type. - template<class KeyType, class KeyValueCompare> - iterator lower_bound(const KeyType& key, KeyValueCompare comp) - { return tree_.lower_bound(key, comp); } - - //! <b>Effects</b>: Returns a const iterator to the first element whose - //! key is not less than k or end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. - const_iterator lower_bound(const_reference value) const - { return tree_.lower_bound(value); } - - //! <b>Requires</b>: comp must imply the same element order as - //! value_compare. Usually key is the part of the value_type - //! that is used in the ordering functor. - //! - //! <b>Effects</b>: Returns a const_iterator to the first element whose - //! key according to the comparison functor is not less than k or - //! end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If comp ordering function throws. - //! - //! <b>Note</b>: This function is used when constructing a value_type - //! is expensive and the value_type can be compared with a cheaper - //! key type. Usually this key is part of the value_type. - template<class KeyType, class KeyValueCompare> - const_iterator lower_bound(const KeyType& key, KeyValueCompare comp) const - { return tree_.lower_bound(key, comp); } - - //! <b>Effects</b>: Returns an iterator to the first element whose - //! key is greater than k or end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. - iterator upper_bound(const_reference value) - { return tree_.upper_bound(value); } - - //! <b>Requires</b>: comp must imply the same element order as - //! value_compare. Usually key is the part of the value_type - //! that is used in the ordering functor. - //! - //! <b>Effects</b>: Returns an iterator to the first element whose - //! key according to the comparison functor is greater than key or - //! end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If comp ordering function throws. - //! - //! <b>Note</b>: This function is used when constructing a value_type - //! is expensive and the value_type can be compared with a cheaper - //! key type. Usually this key is part of the value_type. - template<class KeyType, class KeyValueCompare> - iterator upper_bound(const KeyType& key, KeyValueCompare comp) - { return tree_.upper_bound(key, comp); } - - //! <b>Effects</b>: Returns an iterator to the first element whose - //! key is greater than k or end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. - const_iterator upper_bound(const_reference value) const - { return tree_.upper_bound(value); } - - //! <b>Requires</b>: comp must imply the same element order as - //! value_compare. Usually key is the part of the value_type - //! that is used in the ordering functor. - //! - //! <b>Effects</b>: Returns a const_iterator to the first element whose - //! key according to the comparison functor is greater than key or - //! end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If comp ordering function throws. - //! - //! <b>Note</b>: This function is used when constructing a value_type - //! is expensive and the value_type can be compared with a cheaper - //! key type. Usually this key is part of the value_type. - template<class KeyType, class KeyValueCompare> - const_iterator upper_bound(const KeyType& key, KeyValueCompare comp) const - { return tree_.upper_bound(key, comp); } - - //! <b>Effects</b>: Finds an iterator to the first element whose value is - //! "value" or end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. - iterator find(const_reference value) - { return tree_.find(value); } - - //! <b>Requires</b>: comp must imply the same element order as - //! value_compare. Usually key is the part of the value_type - //! that is used in the ordering functor. - //! - //! <b>Effects</b>: Finds an iterator to the first element whose key is - //! "key" according to the comparison functor or end() if that element - //! does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If comp ordering function throws. - //! - //! <b>Note</b>: This function is used when constructing a value_type - //! is expensive and the value_type can be compared with a cheaper - //! key type. Usually this key is part of the value_type. - template<class KeyType, class KeyValueCompare> - iterator find(const KeyType& key, KeyValueCompare comp) - { return tree_.find(key, comp); } - - //! <b>Effects</b>: Finds a const_iterator to the first element whose value is - //! "value" or end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. - const_iterator find(const_reference value) const - { return tree_.find(value); } - - //! <b>Requires</b>: comp must imply the same element order as - //! value_compare. Usually key is the part of the value_type - //! that is used in the ordering functor. - //! - //! <b>Effects</b>: Finds a const_iterator to the first element whose key is - //! "key" according to the comparison functor or end() if that element - //! does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If comp ordering function throws. - //! - //! <b>Note</b>: This function is used when constructing a value_type - //! is expensive and the value_type can be compared with a cheaper - //! key type. Usually this key is part of the value_type. - template<class KeyType, class KeyValueCompare> - const_iterator find(const KeyType& key, KeyValueCompare comp) const - { return tree_.find(key, comp); } - - //! <b>Effects</b>: Finds a range containing all elements whose key is k or - //! an empty range that indicates the position where those elements would be - //! if they there is no elements with key k. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. - std::pair<iterator,iterator> equal_range(const_reference value) - { return tree_.equal_range(value); } - - //! <b>Requires</b>: comp must imply the same element order as - //! value_compare. Usually key is the part of the value_type - //! that is used in the ordering functor. - //! - //! <b>Effects</b>: Finds a range containing all elements whose key is k - //! according to the comparison functor or an empty range - //! that indicates the position where those elements would be - //! if they there is no elements with key k. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If comp ordering function throws. - //! - //! <b>Note</b>: This function is used when constructing a value_type - //! is expensive and the value_type can be compared with a cheaper - //! key type. Usually this key is part of the value_type. - template<class KeyType, class KeyValueCompare> - std::pair<iterator,iterator> equal_range(const KeyType& key, KeyValueCompare comp) - { return tree_.equal_range(key, comp); } - - //! <b>Effects</b>: Finds a range containing all elements whose key is k or - //! an empty range that indicates the position where those elements would be - //! if they there is no elements with key k. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. - std::pair<const_iterator, const_iterator> - equal_range(const_reference value) const - { return tree_.equal_range(value); } - - //! <b>Requires</b>: comp must imply the same element order as - //! value_compare. Usually key is the part of the value_type - //! that is used in the ordering functor. - //! - //! <b>Effects</b>: Finds a range containing all elements whose key is k - //! according to the comparison functor or an empty range - //! that indicates the position where those elements would be - //! if they there is no elements with key k. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If comp ordering function throws. - //! - //! <b>Note</b>: This function is used when constructing a value_type - //! is expensive and the value_type can be compared with a cheaper - //! key type. Usually this key is part of the value_type. - template<class KeyType, class KeyValueCompare> - std::pair<const_iterator, const_iterator> - equal_range(const KeyType& key, KeyValueCompare comp) const - { return tree_.equal_range(key, comp); } - - //! <b>Requires</b>: value must be an lvalue and shall be in a avl_multiset of - //! appropriate type. Otherwise the behavior is undefined. - //! - //! <b>Effects</b>: Returns: a valid iterator i belonging to the avl_multiset - //! that points to the value - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: This static function is available only if the <i>value traits</i> - //! is stateless. - static iterator s_iterator_to(reference value) - { return tree_type::s_iterator_to(value); } - - //! <b>Requires</b>: value must be an lvalue and shall be in a avl_multiset of - //! appropriate type. Otherwise the behavior is undefined. - //! - //! <b>Effects</b>: Returns: a valid const_iterator i belonging to the - //! avl_multiset that points to the value - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: This static function is available only if the <i>value traits</i> - //! is stateless. - static const_iterator s_iterator_to(const_reference value) - { return tree_type::s_iterator_to(value); } - - //! <b>Requires</b>: value must be an lvalue and shall be in a avl_multiset of - //! appropriate type. Otherwise the behavior is undefined. - //! - //! <b>Effects</b>: Returns: a valid iterator i belonging to the avl_multiset - //! that points to the value - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - iterator iterator_to(reference value) - { return tree_.iterator_to(value); } - - //! <b>Requires</b>: value must be an lvalue and shall be in a avl_multiset of - //! appropriate type. Otherwise the behavior is undefined. - //! - //! <b>Effects</b>: Returns: a valid const_iterator i belonging to the - //! avl_multiset that points to the value - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_iterator iterator_to(const_reference value) const - { return tree_.iterator_to(value); } - - //! <b>Requires</b>: value shall not be in a avl_multiset/avl_multiset. - //! - //! <b>Effects</b>: init_node puts the hook of a value in a well-known default - //! state. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant time. - //! - //! <b>Note</b>: This function puts the hook in the well-known default state - //! used by auto_unlink and safe hooks. - static void init_node(reference value) - { tree_type::init_node(value); } - - //! <b>Effects</b>: Unlinks the leftmost node from the tree. - //! - //! <b>Complexity</b>: Average complexity is constant time. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Notes</b>: This function breaks the tree and the tree can - //! only be used for more unlink_leftmost_without_rebalance calls. - //! This function is normally used to achieve a step by step - //! controlled destruction of the tree. - pointer unlink_leftmost_without_rebalance() - { return tree_.unlink_leftmost_without_rebalance(); } - - //! <b>Requires</b>: replace_this must be a valid iterator of *this - //! and with_this must not be inserted in any tree. - //! - //! <b>Effects</b>: Replaces replace_this in its position in the - //! tree with with_this. The tree does not need to be rebalanced. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: This function will break container ordering invariants if - //! with_this is not equivalent to *replace_this according to the - //! ordering rules. This function is faster than erasing and inserting - //! the node, since no rebalancing or comparison is needed. - void replace_node(iterator replace_this, reference with_this) - { tree_.replace_node(replace_this, with_this); } - - /// @cond - friend bool operator==(const avl_multiset_impl &x, const avl_multiset_impl &y) - { return x.tree_ == y.tree_; } - - friend bool operator<(const avl_multiset_impl &x, const avl_multiset_impl &y) - { return x.tree_ < y.tree_; } - /// @endcond -}; - -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -inline bool operator!= -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -(const avl_multiset_impl<T, Options...> &x, const avl_multiset_impl<T, Options...> &y) -#else -(const avl_multiset_impl<Config> &x, const avl_multiset_impl<Config> &y) -#endif -{ return !(x == y); } - -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -inline bool operator> -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -(const avl_multiset_impl<T, Options...> &x, const avl_multiset_impl<T, Options...> &y) -#else -(const avl_multiset_impl<Config> &x, const avl_multiset_impl<Config> &y) -#endif -{ return y < x; } - -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -inline bool operator<= -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -(const avl_multiset_impl<T, Options...> &x, const avl_multiset_impl<T, Options...> &y) -#else -(const avl_multiset_impl<Config> &x, const avl_multiset_impl<Config> &y) -#endif -{ return !(y < x); } - -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -inline bool operator>= -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -(const avl_multiset_impl<T, Options...> &x, const avl_multiset_impl<T, Options...> &y) -#else -(const avl_multiset_impl<Config> &x, const avl_multiset_impl<Config> &y) -#endif -{ return !(x < y); } - -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -inline void swap -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -(avl_multiset_impl<T, Options...> &x, avl_multiset_impl<T, Options...> &y) -#else -(avl_multiset_impl<Config> &x, avl_multiset_impl<Config> &y) -#endif -{ x.swap(y); } - -//! Helper metafunction to define a \c avl_multiset that yields to the same type when the -//! same options (either explicitly or implicitly) are used. -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) || defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template<class T, class ...Options> -#else -template<class T, class O1 = none, class O2 = none - , class O3 = none, class O4 = none> -#endif -struct make_avl_multiset -{ - /// @cond - typedef avl_multiset_impl - < typename make_avltree_opt - #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) - <T, O1, O2, O3, O4> - #else - <T, Options...> - #endif - ::type - > implementation_defined; - /// @endcond - typedef implementation_defined type; -}; - -#ifndef BOOST_INTRUSIVE_DOXYGEN_INVOKED - -#if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template<class T, class O1, class O2, class O3, class O4> -#else -template<class T, class ...Options> -#endif -class avl_multiset - : public make_avl_multiset<T, - #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) - O1, O2, O3, O4 - #else - Options... - #endif - >::type -{ - typedef typename make_avl_multiset - #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) - <T, O1, O2, O3, O4> - #else - <T, Options...> - #endif - ::type Base; - - BOOST_MOVABLE_BUT_NOT_COPYABLE(avl_multiset) - public: - typedef typename Base::value_compare value_compare; - typedef typename Base::value_traits value_traits; - typedef typename Base::iterator iterator; - typedef typename Base::const_iterator const_iterator; - - //Assert if passed value traits are compatible with the type - BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value)); - - avl_multiset( const value_compare &cmp = value_compare() - , const value_traits &v_traits = value_traits()) - : Base(cmp, v_traits) - {} - - template<class Iterator> - avl_multiset( Iterator b, Iterator e - , const value_compare &cmp = value_compare() - , const value_traits &v_traits = value_traits()) - : Base(b, e, cmp, v_traits) - {} - - avl_multiset(BOOST_RV_REF(avl_multiset) x) - : Base(::boost::move(static_cast<Base&>(x))) - {} - - avl_multiset& operator=(BOOST_RV_REF(avl_multiset) x) - { this->Base::operator=(::boost::move(static_cast<Base&>(x))); return *this; } - - static avl_multiset &container_from_end_iterator(iterator end_iterator) - { return static_cast<avl_multiset &>(Base::container_from_end_iterator(end_iterator)); } - - static const avl_multiset &container_from_end_iterator(const_iterator end_iterator) - { return static_cast<const avl_multiset &>(Base::container_from_end_iterator(end_iterator)); } - - static avl_multiset &container_from_iterator(iterator end_iterator) - { return static_cast<avl_multiset &>(Base::container_from_iterator(end_iterator)); } - - static const avl_multiset &container_from_iterator(const_iterator end_iterator) - { return static_cast<const avl_multiset &>(Base::container_from_iterator(end_iterator)); } -}; - -#endif - -} //namespace intrusive -} //namespace boost - -#include <boost/intrusive/detail/config_end.hpp> - -#endif //BOOST_INTRUSIVE_AVL_SET_HPP diff --git a/src/third_party/boost/boost/intrusive/avl_set_hook.hpp b/src/third_party/boost/boost/intrusive/avl_set_hook.hpp deleted file mode 100644 index 23b1f0bd8f2..00000000000 --- a/src/third_party/boost/boost/intrusive/avl_set_hook.hpp +++ /dev/null @@ -1,297 +0,0 @@ -///////////////////////////////////////////////////////////////////////////// -// -// (C) Copyright Ion Gaztanaga 2007-2009 -// -// Distributed under the Boost Software License, Version 1.0. -// (See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) -// -// See http://www.boost.org/libs/intrusive for documentation. -// -///////////////////////////////////////////////////////////////////////////// - -#ifndef BOOST_INTRUSIVE_AVL_SET_HOOK_HPP -#define BOOST_INTRUSIVE_AVL_SET_HOOK_HPP - -#include <boost/intrusive/detail/config_begin.hpp> -#include <boost/intrusive/intrusive_fwd.hpp> -#include <boost/intrusive/detail/utilities.hpp> -#include <boost/intrusive/detail/avltree_node.hpp> -#include <boost/intrusive/avltree_algorithms.hpp> -#include <boost/intrusive/options.hpp> -#include <boost/intrusive/detail/generic_hook.hpp> - -namespace boost { -namespace intrusive { - -/// @cond -template<class VoidPointer, bool OptimizeSize = false> -struct get_avl_set_node_algo -{ - typedef avltree_algorithms<avltree_node_traits<VoidPointer, OptimizeSize> > type; -}; -/// @endcond - -//! Helper metafunction to define a \c avl_set_base_hook that yields to the same -//! type when the same options (either explicitly or implicitly) are used. -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) || defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template<class ...Options> -#else -template<class O1 = none, class O2 = none, class O3 = none, class O4 = none> -#endif -struct make_avl_set_base_hook -{ - /// @cond - typedef typename pack_options - #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) - <hook_defaults, O1, O2, O3, O4> - #else - <hook_defaults, Options...> - #endif - ::type packed_options; - - typedef detail::generic_hook - < get_avl_set_node_algo<typename packed_options::void_pointer - ,packed_options::optimize_size> - , typename packed_options::tag - , packed_options::link_mode - , detail::AvlSetBaseHook - > implementation_defined; - /// @endcond - typedef implementation_defined type; -}; - -//! Derive a class from avl_set_base_hook in order to store objects in -//! in an avl_set/avl_multiset. avl_set_base_hook holds the data necessary to maintain -//! the avl_set/avl_multiset and provides an appropriate value_traits class for avl_set/avl_multiset. -//! -//! The hook admits the following options: \c tag<>, \c void_pointer<>, -//! \c link_mode<> and \c optimize_size<>. -//! -//! \c tag<> defines a tag to identify the node. -//! The same tag value can be used in different classes, but if a class is -//! derived from more than one \c list_base_hook, then each \c list_base_hook needs its -//! unique tag. -//! -//! \c void_pointer<> is the pointer type that will be used internally in the hook -//! and the the container configured to use this hook. -//! -//! \c link_mode<> will specify the linking mode of the hook (\c normal_link, -//! \c auto_unlink or \c safe_link). -//! -//! \c optimize_size<> will tell the hook to optimize the hook for size instead -//! of speed. -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) || defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template<class ...Options> -#else -template<class O1, class O2, class O3, class O4> -#endif -class avl_set_base_hook - : public make_avl_set_base_hook - #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) - <O1, O2, O3, O4> - #else - <Options...> - #endif - ::type -{ - #if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) - public: - //! <b>Effects</b>: If link_mode is \c auto_unlink or \c safe_link - //! initializes the node to an unlinked state. - //! - //! <b>Throws</b>: Nothing. - avl_set_base_hook(); - - //! <b>Effects</b>: If link_mode is \c auto_unlink or \c safe_link - //! initializes the node to an unlinked state. The argument is ignored. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Rationale</b>: Providing a copy-constructor - //! makes classes using the hook STL-compliant without forcing the - //! user to do some additional work. \c swap can be used to emulate - //! move-semantics. - avl_set_base_hook(const avl_set_base_hook& ); - - //! <b>Effects</b>: Empty function. The argument is ignored. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Rationale</b>: Providing an assignment operator - //! makes classes using the hook STL-compliant without forcing the - //! user to do some additional work. \c swap can be used to emulate - //! move-semantics. - avl_set_base_hook& operator=(const avl_set_base_hook& ); - - //! <b>Effects</b>: If link_mode is \c normal_link, the destructor does - //! nothing (ie. no code is generated). If link_mode is \c safe_link and the - //! object is stored in a set an assertion is raised. If link_mode is - //! \c auto_unlink and \c is_linked() is true, the node is unlinked. - //! - //! <b>Throws</b>: Nothing. - ~avl_set_base_hook(); - - //! <b>Effects</b>: Swapping two nodes swaps the position of the elements - //! related to those nodes in one or two containers. That is, if the node - //! this is part of the element e1, the node x is part of the element e2 - //! and both elements are included in the containers s1 and s2, then after - //! the swap-operation e1 is in s2 at the position of e2 and e2 is in s1 - //! at the position of e1. If one element is not in a container, then - //! after the swap-operation the other element is not in a container. - //! Iterators to e1 and e2 related to those nodes are invalidated. - //! - //! <b>Complexity</b>: Constant - //! - //! <b>Throws</b>: Nothing. - void swap_nodes(avl_set_base_hook &other); - - //! <b>Precondition</b>: link_mode must be \c safe_link or \c auto_unlink. - //! - //! <b>Returns</b>: true, if the node belongs to a container, false - //! otherwise. This function can be used to test whether \c set::iterator_to - //! will return a valid iterator. - //! - //! <b>Complexity</b>: Constant - bool is_linked() const; - - //! <b>Effects</b>: Removes the node if it's inserted in a container. - //! This function is only allowed if link_mode is \c auto_unlink. - //! - //! <b>Throws</b>: Nothing. - void unlink(); - #endif -}; - -//! Helper metafunction to define a \c avl_set_member_hook that yields to the same -//! type when the same options (either explicitly or implicitly) are used. -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) || defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template<class ...Options> -#else -template<class O1 = none, class O2 = none, class O3 = none, class O4 = none> -#endif -struct make_avl_set_member_hook -{ - /// @cond - typedef typename pack_options - #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) - <hook_defaults, O1, O2, O3, O4> - #else - <hook_defaults, Options...> - #endif - ::type packed_options; - - typedef detail::generic_hook - < get_avl_set_node_algo<typename packed_options::void_pointer - ,packed_options::optimize_size> - , member_tag - , packed_options::link_mode - , detail::NoBaseHook - > implementation_defined; - /// @endcond - typedef implementation_defined type; -}; - -//! Put a public data member avl_set_member_hook in order to store objects of this class in -//! an avl_set/avl_multiset. avl_set_member_hook holds the data necessary for maintaining the -//! avl_set/avl_multiset and provides an appropriate value_traits class for avl_set/avl_multiset. -//! -//! The hook admits the following options: \c void_pointer<>, -//! \c link_mode<> and \c optimize_size<>. -//! -//! \c void_pointer<> is the pointer type that will be used internally in the hook -//! and the the container configured to use this hook. -//! -//! \c link_mode<> will specify the linking mode of the hook (\c normal_link, -//! \c auto_unlink or \c safe_link). -//! -//! \c optimize_size<> will tell the hook to optimize the hook for size instead -//! of speed. -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) || defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template<class ...Options> -#else -template<class O1, class O2, class O3, class O4> -#endif -class avl_set_member_hook - : public make_avl_set_member_hook - #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) - <O1, O2, O3, O4> - #else - <Options...> - #endif - ::type -{ - #if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) - public: - //! <b>Effects</b>: If link_mode is \c auto_unlink or \c safe_link - //! initializes the node to an unlinked state. - //! - //! <b>Throws</b>: Nothing. - avl_set_member_hook(); - - //! <b>Effects</b>: If link_mode is \c auto_unlink or \c safe_link - //! initializes the node to an unlinked state. The argument is ignored. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Rationale</b>: Providing a copy-constructor - //! makes classes using the hook STL-compliant without forcing the - //! user to do some additional work. \c swap can be used to emulate - //! move-semantics. - avl_set_member_hook(const avl_set_member_hook& ); - - //! <b>Effects</b>: Empty function. The argument is ignored. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Rationale</b>: Providing an assignment operator - //! makes classes using the hook STL-compliant without forcing the - //! user to do some additional work. \c swap can be used to emulate - //! move-semantics. - avl_set_member_hook& operator=(const avl_set_member_hook& ); - - //! <b>Effects</b>: If link_mode is \c normal_link, the destructor does - //! nothing (ie. no code is generated). If link_mode is \c safe_link and the - //! object is stored in a set an assertion is raised. If link_mode is - //! \c auto_unlink and \c is_linked() is true, the node is unlinked. - //! - //! <b>Throws</b>: Nothing. - ~avl_set_member_hook(); - - //! <b>Effects</b>: Swapping two nodes swaps the position of the elements - //! related to those nodes in one or two containers. That is, if the node - //! this is part of the element e1, the node x is part of the element e2 - //! and both elements are included in the containers s1 and s2, then after - //! the swap-operation e1 is in s2 at the position of e2 and e2 is in s1 - //! at the position of e1. If one element is not in a container, then - //! after the swap-operation the other element is not in a container. - //! Iterators to e1 and e2 related to those nodes are invalidated. - //! - //! <b>Complexity</b>: Constant - //! - //! <b>Throws</b>: Nothing. - void swap_nodes(avl_set_member_hook &other); - - //! <b>Precondition</b>: link_mode must be \c safe_link or \c auto_unlink. - //! - //! <b>Returns</b>: true, if the node belongs to a container, false - //! otherwise. This function can be used to test whether \c set::iterator_to - //! will return a valid iterator. - //! - //! <b>Complexity</b>: Constant - bool is_linked() const; - - //! <b>Effects</b>: Removes the node if it's inserted in a container. - //! This function is only allowed if link_mode is \c auto_unlink. - //! - //! <b>Throws</b>: Nothing. - void unlink(); - #endif -}; - -} //namespace intrusive -} //namespace boost - -#include <boost/intrusive/detail/config_end.hpp> - -#endif //BOOST_INTRUSIVE_AVL_SET_HOOK_HPP diff --git a/src/third_party/boost/boost/intrusive/avltree.hpp b/src/third_party/boost/boost/intrusive/avltree.hpp deleted file mode 100644 index 20903ddef77..00000000000 --- a/src/third_party/boost/boost/intrusive/avltree.hpp +++ /dev/null @@ -1,1688 +0,0 @@ -///////////////////////////////////////////////////////////////////////////// -// -// (C) Copyright Ion Gaztanaga 2007-2009 -// -// Distributed under the Boost Software License, Version 1.0. -// (See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) -// -// See http://www.boost.org/libs/intrusive for documentation. -// -///////////////////////////////////////////////////////////////////////////// -#ifndef BOOST_INTRUSIVE_AVLTREE_HPP -#define BOOST_INTRUSIVE_AVLTREE_HPP - -#include <boost/intrusive/detail/config_begin.hpp> -#include <algorithm> -#include <cstddef> -#include <functional> -#include <iterator> -#include <utility> - -#include <boost/intrusive/detail/assert.hpp> -#include <boost/static_assert.hpp> -#include <boost/intrusive/intrusive_fwd.hpp> -#include <boost/intrusive/avl_set_hook.hpp> -#include <boost/intrusive/detail/avltree_node.hpp> -#include <boost/intrusive/detail/tree_node.hpp> -#include <boost/intrusive/detail/ebo_functor_holder.hpp> -#include <boost/intrusive/detail/mpl.hpp> -#include <boost/intrusive/pointer_traits.hpp> -#include <boost/intrusive/pointer_traits.hpp> -#include <boost/intrusive/detail/clear_on_destructor_base.hpp> -#include <boost/intrusive/options.hpp> -#include <boost/intrusive/detail/utilities.hpp> -#include <boost/intrusive/avltree_algorithms.hpp> -#include <boost/intrusive/link_mode.hpp> -#include <boost/move/move.hpp> - -namespace boost { -namespace intrusive { - -/// @cond - -template <class ValueTraits, class Compare, class SizeType, bool ConstantTimeSize> -struct avl_setopt -{ - typedef ValueTraits value_traits; - typedef Compare compare; - typedef SizeType size_type; - static const bool constant_time_size = ConstantTimeSize; -}; - -template <class T> -struct avl_set_defaults - : pack_options - < none - , base_hook<detail::default_avl_set_hook> - , constant_time_size<true> - , size_type<std::size_t> - , compare<std::less<T> > - >::type -{}; - -/// @endcond - -//! The class template avltree is an intrusive AVL tree container, that -//! is used to construct intrusive avl_set and avl_multiset containers. -//! The no-throw guarantee holds only, if the value_compare object -//! doesn't throw. -//! -//! The template parameter \c T is the type to be managed by the container. -//! The user can specify additional options and if no options are provided -//! default options are used. -//! -//! The container supports the following options: -//! \c base_hook<>/member_hook<>/value_traits<>, -//! \c constant_time_size<>, \c size_type<> and -//! \c compare<>. -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -class avltree_impl - : private detail::clear_on_destructor_base<avltree_impl<Config> > -{ - template<class C> friend class detail::clear_on_destructor_base; - public: - typedef typename Config::value_traits value_traits; - /// @cond - static const bool external_value_traits = - detail::external_value_traits_is_true<value_traits>::value; - typedef typename detail::eval_if_c - < external_value_traits - , detail::eval_value_traits<value_traits> - , detail::identity<value_traits> - >::type real_value_traits; - /// @endcond - typedef typename real_value_traits::pointer pointer; - typedef typename real_value_traits::const_pointer const_pointer; - typedef typename boost::intrusive:: - pointer_traits<pointer>::element_type value_type; - typedef value_type key_type; - typedef typename boost::intrusive:: - pointer_traits<pointer>::reference reference; - typedef typename boost::intrusive:: - pointer_traits<const_pointer>::reference const_reference; - typedef typename boost::intrusive:: - pointer_traits<pointer>::difference_type difference_type; - typedef typename Config::size_type size_type; - typedef typename Config::compare value_compare; - typedef value_compare key_compare; - typedef tree_iterator<avltree_impl, false> iterator; - typedef tree_iterator<avltree_impl, true> const_iterator; - typedef boost::intrusive::detail::reverse_iterator<iterator> reverse_iterator; - typedef boost::intrusive::detail::reverse_iterator<const_iterator>const_reverse_iterator; - typedef typename real_value_traits::node_traits node_traits; - typedef typename node_traits::node node; - typedef typename pointer_traits - <pointer>::template rebind_pointer - <node>::type node_ptr; - typedef typename pointer_traits - <pointer>::template rebind_pointer - <const node>::type const_node_ptr; - typedef avltree_algorithms<node_traits> node_algorithms; - - static const bool constant_time_size = Config::constant_time_size; - static const bool stateful_value_traits = detail::store_cont_ptr_on_it<avltree_impl>::value; - - /// @cond - private: - typedef detail::size_holder<constant_time_size, size_type> size_traits; - - //noncopyable, movable - BOOST_MOVABLE_BUT_NOT_COPYABLE(avltree_impl) - - enum { safemode_or_autounlink = - (int)real_value_traits::link_mode == (int)auto_unlink || - (int)real_value_traits::link_mode == (int)safe_link }; - - //Constant-time size is incompatible with auto-unlink hooks! - BOOST_STATIC_ASSERT(!(constant_time_size && ((int)real_value_traits::link_mode == (int)auto_unlink))); - - struct header_plus_size : public size_traits - { node header_; }; - - struct node_plus_pred_t : public detail::ebo_functor_holder<value_compare> - { - node_plus_pred_t(const value_compare &comp) - : detail::ebo_functor_holder<value_compare>(comp) - {} - header_plus_size header_plus_size_; - }; - - struct data_t : public avltree_impl::value_traits - { - typedef typename avltree_impl::value_traits value_traits; - data_t(const value_compare & comp, const value_traits &val_traits) - : value_traits(val_traits), node_plus_pred_(comp) - {} - node_plus_pred_t node_plus_pred_; - } data_; - - const value_compare &priv_comp() const - { return data_.node_plus_pred_.get(); } - - value_compare &priv_comp() - { return data_.node_plus_pred_.get(); } - - const value_traits &priv_value_traits() const - { return data_; } - - value_traits &priv_value_traits() - { return data_; } - - node_ptr priv_header_ptr() - { return pointer_traits<node_ptr>::pointer_to(data_.node_plus_pred_.header_plus_size_.header_); } - - const_node_ptr priv_header_ptr() const - { return pointer_traits<const_node_ptr>::pointer_to(data_.node_plus_pred_.header_plus_size_.header_); } - - static node_ptr uncast(const const_node_ptr & ptr) - { return pointer_traits<node_ptr>::const_cast_from(ptr); } - - size_traits &priv_size_traits() - { return data_.node_plus_pred_.header_plus_size_; } - - const size_traits &priv_size_traits() const - { return data_.node_plus_pred_.header_plus_size_; } - - const real_value_traits &get_real_value_traits(detail::bool_<false>) const - { return data_; } - - const real_value_traits &get_real_value_traits(detail::bool_<true>) const - { return data_.get_value_traits(*this); } - - real_value_traits &get_real_value_traits(detail::bool_<false>) - { return data_; } - - real_value_traits &get_real_value_traits(detail::bool_<true>) - { return data_.get_value_traits(*this); } - - /// @endcond - - public: - - const real_value_traits &get_real_value_traits() const - { return this->get_real_value_traits(detail::bool_<external_value_traits>()); } - - real_value_traits &get_real_value_traits() - { return this->get_real_value_traits(detail::bool_<external_value_traits>()); } - - typedef typename node_algorithms::insert_commit_data insert_commit_data; - - //! <b>Effects</b>: Constructs an empty tree. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: If value_traits::node_traits::node - //! constructor throws (this does not happen with predefined Boost.Intrusive hooks) - //! or the copy constructor of the value_compare object throws. Basic guarantee. - avltree_impl( const value_compare &cmp = value_compare() - , const value_traits &v_traits = value_traits()) - : data_(cmp, v_traits) - { - node_algorithms::init_header(this->priv_header_ptr()); - this->priv_size_traits().set_size(size_type(0)); - } - - //! <b>Requires</b>: Dereferencing iterator must yield an lvalue of type value_type. - //! cmp must be a comparison function that induces a strict weak ordering. - //! - //! <b>Effects</b>: Constructs an empty tree and inserts elements from - //! [b, e). - //! - //! <b>Complexity</b>: Linear in N if [b, e) is already sorted using - //! comp and otherwise N * log N, where N is the distance between first and last. - //! - //! <b>Throws</b>: If value_traits::node_traits::node - //! constructor throws (this does not happen with predefined Boost.Intrusive hooks) - //! or the copy constructor/operator() of the value_compare object throws. Basic guarantee. - template<class Iterator> - avltree_impl( bool unique, Iterator b, Iterator e - , const value_compare &cmp = value_compare() - , const value_traits &v_traits = value_traits()) - : data_(cmp, v_traits) - { - node_algorithms::init_header(this->priv_header_ptr()); - this->priv_size_traits().set_size(size_type(0)); - if(unique) - this->insert_unique(b, e); - else - this->insert_equal(b, e); - } - - //! <b>Effects</b>: to-do - //! - avltree_impl(BOOST_RV_REF(avltree_impl) x) - : data_(::boost::move(x.priv_comp()), ::boost::move(x.priv_value_traits())) - { - node_algorithms::init_header(this->priv_header_ptr()); - this->priv_size_traits().set_size(size_type(0)); - this->swap(x); - } - - //! <b>Effects</b>: to-do - //! - avltree_impl& operator=(BOOST_RV_REF(avltree_impl) x) - { this->swap(x); return *this; } - - //! <b>Effects</b>: Detaches all elements from this. The objects in the set - //! are not deleted (i.e. no destructors are called), but the nodes according to - //! the value_traits template parameter are reinitialized and thus can be reused. - //! - //! <b>Complexity</b>: Linear to elements contained in *this. - //! - //! <b>Throws</b>: Nothing. - ~avltree_impl() - {} - - //! <b>Effects</b>: Returns an iterator pointing to the beginning of the tree. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - iterator begin() - { return iterator (node_traits::get_left(this->priv_header_ptr()), this); } - - //! <b>Effects</b>: Returns a const_iterator pointing to the beginning of the tree. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_iterator begin() const - { return cbegin(); } - - //! <b>Effects</b>: Returns a const_iterator pointing to the beginning of the tree. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_iterator cbegin() const - { return const_iterator (node_traits::get_left(this->priv_header_ptr()), this); } - - //! <b>Effects</b>: Returns an iterator pointing to the end of the tree. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - iterator end() - { return iterator (this->priv_header_ptr(), this); } - - //! <b>Effects</b>: Returns a const_iterator pointing to the end of the tree. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_iterator end() const - { return cend(); } - - //! <b>Effects</b>: Returns a const_iterator pointing to the end of the tree. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_iterator cend() const - { return const_iterator (uncast(this->priv_header_ptr()), this); } - - //! <b>Effects</b>: Returns a reverse_iterator pointing to the beginning of the - //! reversed tree. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - reverse_iterator rbegin() - { return reverse_iterator(end()); } - - //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning - //! of the reversed tree. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_reverse_iterator rbegin() const - { return const_reverse_iterator(end()); } - - //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning - //! of the reversed tree. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_reverse_iterator crbegin() const - { return const_reverse_iterator(end()); } - - //! <b>Effects</b>: Returns a reverse_iterator pointing to the end - //! of the reversed tree. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - reverse_iterator rend() - { return reverse_iterator(begin()); } - - //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the end - //! of the reversed tree. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_reverse_iterator rend() const - { return const_reverse_iterator(begin()); } - - //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the end - //! of the reversed tree. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_reverse_iterator crend() const - { return const_reverse_iterator(begin()); } - - //! <b>Precondition</b>: end_iterator must be a valid end iterator - //! of avltree. - //! - //! <b>Effects</b>: Returns a const reference to the avltree associated to the end iterator - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - static avltree_impl &container_from_end_iterator(iterator end_iterator) - { return priv_container_from_end_iterator(end_iterator); } - - //! <b>Precondition</b>: end_iterator must be a valid end const_iterator - //! of avltree. - //! - //! <b>Effects</b>: Returns a const reference to the avltree associated to the end iterator - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - static const avltree_impl &container_from_end_iterator(const_iterator end_iterator) - { return priv_container_from_end_iterator(end_iterator); } - - //! <b>Precondition</b>: it must be a valid iterator - //! of rbtree. - //! - //! <b>Effects</b>: Returns a const reference to the tree associated to the iterator - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Logarithmic. - static avltree_impl &container_from_iterator(iterator it) - { return priv_container_from_iterator(it); } - - //! <b>Precondition</b>: it must be a valid end const_iterator - //! of rbtree. - //! - //! <b>Effects</b>: Returns a const reference to the tree associated to the iterator - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Logarithmic. - static const avltree_impl &container_from_iterator(const_iterator it) - { return priv_container_from_iterator(it); } - - //! <b>Effects</b>: Returns the value_compare object used by the tree. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: If value_compare copy-constructor throws. - value_compare value_comp() const - { return priv_comp(); } - - //! <b>Effects</b>: Returns true if the container is empty. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - bool empty() const - { return node_algorithms::unique(this->priv_header_ptr()); } - - //! <b>Effects</b>: Returns the number of elements stored in the tree. - //! - //! <b>Complexity</b>: Linear to elements contained in *this - //! if constant-time size option is disabled. Constant time otherwise. - //! - //! <b>Throws</b>: Nothing. - size_type size() const - { - if(constant_time_size) - return this->priv_size_traits().get_size(); - else{ - return (size_type)node_algorithms::size(this->priv_header_ptr()); - } - } - - //! <b>Effects</b>: Swaps the contents of two avltrees. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: If the comparison functor's swap call throws. - void swap(avltree_impl& other) - { - //This can throw - using std::swap; - swap(priv_comp(), priv_comp()); - //These can't throw - node_algorithms::swap_tree(this->priv_header_ptr(), other.priv_header_ptr()); - if(constant_time_size){ - size_type backup = this->priv_size_traits().get_size(); - this->priv_size_traits().set_size(other.priv_size_traits().get_size()); - other.priv_size_traits().set_size(backup); - } - } - - //! <b>Requires</b>: value must be an lvalue - //! - //! <b>Effects</b>: Inserts value into the tree before the upper bound. - //! - //! <b>Complexity</b>: Average complexity for insert element is at - //! most logarithmic. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. Strong guarantee. - //! - //! <b>Note</b>: Does not affect the validity of iterators and references. - //! No copy-constructors are called. - iterator insert_equal(reference value) - { - detail::key_nodeptr_comp<value_compare, avltree_impl> - key_node_comp(priv_comp(), this); - node_ptr to_insert(get_real_value_traits().to_node_ptr(value)); - if(safemode_or_autounlink) - BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert)); - iterator ret(node_algorithms::insert_equal_upper_bound - (this->priv_header_ptr(), to_insert, key_node_comp), this); - this->priv_size_traits().increment(); - return ret; - } - - //! <b>Requires</b>: value must be an lvalue, and "hint" must be - //! a valid iterator. - //! - //! <b>Effects</b>: Inserts x into the tree, using "hint" as a hint to - //! where it will be inserted. If "hint" is the upper_bound - //! the insertion takes constant time (two comparisons in the worst case) - //! - //! <b>Complexity</b>: Logarithmic in general, but it is amortized - //! constant time if t is inserted immediately before hint. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. Strong guarantee. - //! - //! <b>Note</b>: Does not affect the validity of iterators and references. - //! No copy-constructors are called. - iterator insert_equal(const_iterator hint, reference value) - { - detail::key_nodeptr_comp<value_compare, avltree_impl> - key_node_comp(priv_comp(), this); - node_ptr to_insert(get_real_value_traits().to_node_ptr(value)); - if(safemode_or_autounlink) - BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert)); - iterator ret(node_algorithms::insert_equal - (this->priv_header_ptr(), hint.pointed_node(), to_insert, key_node_comp), this); - this->priv_size_traits().increment(); - return ret; - } - - //! <b>Requires</b>: Dereferencing iterator must yield an lvalue - //! of type value_type. - //! - //! <b>Effects</b>: Inserts a each element of a range into the tree - //! before the upper bound of the key of each element. - //! - //! <b>Complexity</b>: Insert range is in general O(N * log(N)), where N is the - //! size of the range. However, it is linear in N if the range is already sorted - //! by value_comp(). - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Does not affect the validity of iterators and references. - //! No copy-constructors are called. - template<class Iterator> - void insert_equal(Iterator b, Iterator e) - { - iterator end(this->end()); - for (; b != e; ++b) - this->insert_equal(end, *b); - } - - //! <b>Requires</b>: value must be an lvalue - //! - //! <b>Effects</b>: Inserts value into the tree if the value - //! is not already present. - //! - //! <b>Complexity</b>: Average complexity for insert element is at - //! most logarithmic. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Does not affect the validity of iterators and references. - //! No copy-constructors are called. - std::pair<iterator, bool> insert_unique(reference value) - { - insert_commit_data commit_data; - std::pair<iterator, bool> ret = insert_unique_check(value, priv_comp(), commit_data); - if(!ret.second) - return ret; - return std::pair<iterator, bool> (insert_unique_commit(value, commit_data), true); - } - - //! <b>Requires</b>: value must be an lvalue, and "hint" must be - //! a valid iterator - //! - //! <b>Effects</b>: Tries to insert x into the tree, using "hint" as a hint - //! to where it will be inserted. - //! - //! <b>Complexity</b>: Logarithmic in general, but it is amortized - //! constant time (two comparisons in the worst case) - //! if t is inserted immediately before hint. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Does not affect the validity of iterators and references. - //! No copy-constructors are called. - iterator insert_unique(const_iterator hint, reference value) - { - insert_commit_data commit_data; - std::pair<iterator, bool> ret = insert_unique_check(hint, value, priv_comp(), commit_data); - if(!ret.second) - return ret.first; - return insert_unique_commit(value, commit_data); - } - - //! <b>Requires</b>: Dereferencing iterator must yield an lvalue - //! of type value_type. - //! - //! <b>Effects</b>: Tries to insert each element of a range into the tree. - //! - //! <b>Complexity</b>: Insert range is in general O(N * log(N)), where N is the - //! size of the range. However, it is linear in N if the range is already sorted - //! by value_comp(). - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Does not affect the validity of iterators and references. - //! No copy-constructors are called. - template<class Iterator> - void insert_unique(Iterator b, Iterator e) - { - if(this->empty()){ - iterator end(this->end()); - for (; b != e; ++b) - this->insert_unique(end, *b); - } - else{ - for (; b != e; ++b) - this->insert_unique(*b); - } - } - - //! <b>Requires</b>: key_value_comp must be a comparison function that induces - //! the same strict weak ordering as value_compare. The difference is that - //! key_value_comp compares an arbitrary key with the contained values. - //! - //! <b>Effects</b>: Checks if a value can be inserted in the container, using - //! a user provided key instead of the value itself. - //! - //! <b>Returns</b>: If there is an equivalent value - //! returns a pair containing an iterator to the already present value - //! and false. If the value can be inserted returns true in the returned - //! pair boolean and fills "commit_data" that is meant to be used with - //! the "insert_commit" function. - //! - //! <b>Complexity</b>: Average complexity is at most logarithmic. - //! - //! <b>Throws</b>: If the key_value_comp ordering function throws. Strong guarantee. - //! - //! <b>Notes</b>: This function is used to improve performance when constructing - //! a value_type is expensive: if there is an equivalent value - //! the constructed object must be discarded. Many times, the part of the - //! node that is used to impose the order is much cheaper to construct - //! than the value_type and this function offers the possibility to use that - //! part to check if the insertion will be successful. - //! - //! If the check is successful, the user can construct the value_type and use - //! "insert_commit" to insert the object in constant-time. This gives a total - //! logarithmic complexity to the insertion: check(O(log(N)) + commit(O(1)). - //! - //! "commit_data" remains valid for a subsequent "insert_commit" only if no more - //! objects are inserted or erased from the container. - template<class KeyType, class KeyValueCompare> - std::pair<iterator, bool> insert_unique_check - (const KeyType &key, KeyValueCompare key_value_comp, insert_commit_data &commit_data) - { - detail::key_nodeptr_comp<KeyValueCompare, avltree_impl> - comp(key_value_comp, this); - std::pair<node_ptr, bool> ret = - (node_algorithms::insert_unique_check - (this->priv_header_ptr(), key, comp, commit_data)); - return std::pair<iterator, bool>(iterator(ret.first, this), ret.second); - } - - //! <b>Requires</b>: key_value_comp must be a comparison function that induces - //! the same strict weak ordering as value_compare. The difference is that - //! key_value_comp compares an arbitrary key with the contained values. - //! - //! <b>Effects</b>: Checks if a value can be inserted in the container, using - //! a user provided key instead of the value itself, using "hint" - //! as a hint to where it will be inserted. - //! - //! <b>Returns</b>: If there is an equivalent value - //! returns a pair containing an iterator to the already present value - //! and false. If the value can be inserted returns true in the returned - //! pair boolean and fills "commit_data" that is meant to be used with - //! the "insert_commit" function. - //! - //! <b>Complexity</b>: Logarithmic in general, but it's amortized - //! constant time if t is inserted immediately before hint. - //! - //! <b>Throws</b>: If the key_value_comp ordering function throws. Strong guarantee. - //! - //! <b>Notes</b>: This function is used to improve performance when constructing - //! a value_type is expensive: if there is an equivalent value - //! the constructed object must be discarded. Many times, the part of the - //! constructing that is used to impose the order is much cheaper to construct - //! than the value_type and this function offers the possibility to use that key - //! to check if the insertion will be successful. - //! - //! If the check is successful, the user can construct the value_type and use - //! "insert_commit" to insert the object in constant-time. This can give a total - //! constant-time complexity to the insertion: check(O(1)) + commit(O(1)). - //! - //! "commit_data" remains valid for a subsequent "insert_commit" only if no more - //! objects are inserted or erased from the container. - template<class KeyType, class KeyValueCompare> - std::pair<iterator, bool> insert_unique_check - (const_iterator hint, const KeyType &key - ,KeyValueCompare key_value_comp, insert_commit_data &commit_data) - { - detail::key_nodeptr_comp<KeyValueCompare, avltree_impl> - comp(key_value_comp, this); - std::pair<node_ptr, bool> ret = - (node_algorithms::insert_unique_check - (this->priv_header_ptr(), hint.pointed_node(), key, comp, commit_data)); - return std::pair<iterator, bool>(iterator(ret.first, this), ret.second); - } - - //! <b>Requires</b>: value must be an lvalue of type value_type. commit_data - //! must have been obtained from a previous call to "insert_check". - //! No objects should have been inserted or erased from the container between - //! the "insert_check" that filled "commit_data" and the call to "insert_commit". - //! - //! <b>Effects</b>: Inserts the value in the avl_set using the information obtained - //! from the "commit_data" that a previous "insert_check" filled. - //! - //! <b>Returns</b>: An iterator to the newly inserted object. - //! - //! <b>Complexity</b>: Constant time. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Notes</b>: This function has only sense if a "insert_check" has been - //! previously executed to fill "commit_data". No value should be inserted or - //! erased between the "insert_check" and "insert_commit" calls. - iterator insert_unique_commit(reference value, const insert_commit_data &commit_data) - { - node_ptr to_insert(get_real_value_traits().to_node_ptr(value)); - if(safemode_or_autounlink) - BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert)); - node_algorithms::insert_unique_commit - (this->priv_header_ptr(), to_insert, commit_data); - this->priv_size_traits().increment(); - return iterator(to_insert, this); - } - - //! <b>Requires</b>: value must be an lvalue, "pos" must be - //! a valid iterator (or end) and must be the succesor of value - //! once inserted according to the predicate - //! - //! <b>Effects</b>: Inserts x into the tree before "pos". - //! - //! <b>Complexity</b>: Constant time. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: This function does not check preconditions so if "pos" is not - //! the successor of "value" tree ordering invariant will be broken. - //! This is a low-level function to be used only for performance reasons - //! by advanced users. - iterator insert_before(const_iterator pos, reference value) - { - node_ptr to_insert(get_real_value_traits().to_node_ptr(value)); - if(safemode_or_autounlink) - BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert)); - iterator ret(node_algorithms::insert_before - (this->priv_header_ptr(), pos.pointed_node(), to_insert), this); - this->priv_size_traits().increment(); - return ret; - } - - //! <b>Requires</b>: value must be an lvalue, and it must be no less - //! than the greatest inserted key - //! - //! <b>Effects</b>: Inserts x into the tree in the last position. - //! - //! <b>Complexity</b>: Constant time. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: This function does not check preconditions so if value is - //! less than the greatest inserted key tree ordering invariant will be broken. - //! This function is slightly more efficient than using "insert_before". - //! This is a low-level function to be used only for performance reasons - //! by advanced users. - void push_back(reference value) - { - node_ptr to_insert(get_real_value_traits().to_node_ptr(value)); - if(safemode_or_autounlink) - BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert)); - node_algorithms::push_back(this->priv_header_ptr(), to_insert); - this->priv_size_traits().increment(); - } - - //! <b>Requires</b>: value must be an lvalue, and it must be no greater - //! than the minimum inserted key - //! - //! <b>Effects</b>: Inserts x into the tree in the first position. - //! - //! <b>Complexity</b>: Constant time. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: This function does not check preconditions so if value is - //! greater than the minimum inserted key tree ordering invariant will be broken. - //! This function is slightly more efficient than using "insert_before". - //! This is a low-level function to be used only for performance reasons - //! by advanced users. - void push_front(reference value) - { - node_ptr to_insert(get_real_value_traits().to_node_ptr(value)); - if(safemode_or_autounlink) - BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert)); - node_algorithms::push_front(this->priv_header_ptr(), to_insert); - this->priv_size_traits().increment(); - } - - //! <b>Effects</b>: Erases the element pointed to by pos. - //! - //! <b>Complexity</b>: Average complexity for erase element is constant time. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - iterator erase(const_iterator i) - { - const_iterator ret(i); - ++ret; - node_ptr to_erase(i.pointed_node()); - if(safemode_or_autounlink) - BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(!node_algorithms::unique(to_erase)); - node_algorithms::erase(this->priv_header_ptr(), to_erase); - this->priv_size_traits().decrement(); - if(safemode_or_autounlink) - node_algorithms::init(to_erase); - return ret.unconst(); - } - - //! <b>Effects</b>: Erases the range pointed to by b end e. - //! - //! <b>Complexity</b>: Average complexity for erase range is at most - //! O(log(size() + N)), where N is the number of elements in the range. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - iterator erase(const_iterator b, const_iterator e) - { size_type n; return private_erase(b, e, n); } - - //! <b>Effects</b>: Erases all the elements with the given value. - //! - //! <b>Returns</b>: The number of erased elements. - //! - //! <b>Complexity</b>: O(log(size() + N). - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - size_type erase(const_reference value) - { return this->erase(value, priv_comp()); } - - //! <b>Effects</b>: Erases all the elements with the given key. - //! according to the comparison functor "comp". - //! - //! <b>Returns</b>: The number of erased elements. - //! - //! <b>Complexity</b>: O(log(size() + N). - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - template<class KeyType, class KeyValueCompare> - size_type erase(const KeyType& key, KeyValueCompare comp - /// @cond - , typename detail::enable_if_c<!detail::is_convertible<KeyValueCompare, const_iterator>::value >::type * = 0 - /// @endcond - ) - { - std::pair<iterator,iterator> p = this->equal_range(key, comp); - size_type n; - private_erase(p.first, p.second, n); - return n; - } - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! - //! <b>Effects</b>: Erases the element pointed to by pos. - //! Disposer::operator()(pointer) is called for the removed element. - //! - //! <b>Complexity</b>: Average complexity for erase element is constant time. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators - //! to the erased elements. - template<class Disposer> - iterator erase_and_dispose(const_iterator i, Disposer disposer) - { - node_ptr to_erase(i.pointed_node()); - iterator ret(this->erase(i)); - disposer(get_real_value_traits().to_value_ptr(to_erase)); - return ret; - } - - #if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) - template<class Disposer> - iterator erase_and_dispose(iterator i, Disposer disposer) - { return this->erase_and_dispose(const_iterator(i), disposer); } - #endif - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! - //! <b>Effects</b>: Erases the range pointed to by b end e. - //! Disposer::operator()(pointer) is called for the removed elements. - //! - //! <b>Complexity</b>: Average complexity for erase range is at most - //! O(log(size() + N)), where N is the number of elements in the range. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators - //! to the erased elements. - template<class Disposer> - iterator erase_and_dispose(const_iterator b, const_iterator e, Disposer disposer) - { size_type n; return private_erase(b, e, n, disposer); } - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! - //! <b>Effects</b>: Erases all the elements with the given value. - //! Disposer::operator()(pointer) is called for the removed elements. - //! - //! <b>Returns</b>: The number of erased elements. - //! - //! <b>Complexity</b>: O(log(size() + N). - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - template<class Disposer> - size_type erase_and_dispose(const_reference value, Disposer disposer) - { - std::pair<iterator,iterator> p = this->equal_range(value); - size_type n; - private_erase(p.first, p.second, n, disposer); - return n; - } - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! - //! <b>Effects</b>: Erases all the elements with the given key. - //! according to the comparison functor "comp". - //! Disposer::operator()(pointer) is called for the removed elements. - //! - //! <b>Returns</b>: The number of erased elements. - //! - //! <b>Complexity</b>: O(log(size() + N). - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators - //! to the erased elements. - template<class KeyType, class KeyValueCompare, class Disposer> - size_type erase_and_dispose(const KeyType& key, KeyValueCompare comp, Disposer disposer - /// @cond - , typename detail::enable_if_c<!detail::is_convertible<KeyValueCompare, const_iterator>::value >::type * = 0 - /// @endcond - ) - { - std::pair<iterator,iterator> p = this->equal_range(key, comp); - size_type n; - private_erase(p.first, p.second, n, disposer); - return n; - } - - //! <b>Effects</b>: Erases all of the elements. - //! - //! <b>Complexity</b>: Linear to the number of elements on the container. - //! if it's a safe-mode or auto-unlink value_type. Constant time otherwise. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - void clear() - { - if(safemode_or_autounlink){ - this->clear_and_dispose(detail::null_disposer()); - } - else{ - node_algorithms::init_header(this->priv_header_ptr()); - this->priv_size_traits().set_size(0); - } - } - - //! <b>Effects</b>: Erases all of the elements calling disposer(p) for - //! each node to be erased. - //! <b>Complexity</b>: Average complexity for is at most O(log(size() + N)), - //! where N is the number of elements in the container. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. Calls N times to disposer functor. - template<class Disposer> - void clear_and_dispose(Disposer disposer) - { - node_algorithms::clear_and_dispose(this->priv_header_ptr() - , detail::node_disposer<Disposer, avltree_impl>(disposer, this)); - node_algorithms::init_header(this->priv_header_ptr()); - this->priv_size_traits().set_size(0); - } - - //! <b>Effects</b>: Returns the number of contained elements with the given value - //! - //! <b>Complexity</b>: Logarithmic to the number of elements contained plus lineal - //! to number of objects with the given value. - //! - //! <b>Throws</b>: Nothing. - size_type count(const_reference value) const - { return this->count(value, priv_comp()); } - - //! <b>Effects</b>: Returns the number of contained elements with the given key - //! - //! <b>Complexity</b>: Logarithmic to the number of elements contained plus lineal - //! to number of objects with the given key. - //! - //! <b>Throws</b>: Nothing. - template<class KeyType, class KeyValueCompare> - size_type count(const KeyType &key, KeyValueCompare comp) const - { - std::pair<const_iterator, const_iterator> ret = this->equal_range(key, comp); - return std::distance(ret.first, ret.second); - } - - //! <b>Effects</b>: Returns an iterator to the first element whose - //! key is not less than k or end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: Nothing. - iterator lower_bound(const_reference value) - { return this->lower_bound(value, priv_comp()); } - - //! <b>Effects</b>: Returns an iterator to the first element whose - //! key is not less than k or end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: Nothing. - const_iterator lower_bound(const_reference value) const - { return this->lower_bound(value, priv_comp()); } - - //! <b>Effects</b>: Returns an iterator to the first element whose - //! key is not less than k or end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: Nothing. - template<class KeyType, class KeyValueCompare> - iterator lower_bound(const KeyType &key, KeyValueCompare comp) - { - detail::key_nodeptr_comp<KeyValueCompare, avltree_impl> - key_node_comp(comp, this); - return iterator(node_algorithms::lower_bound - (this->priv_header_ptr(), key, key_node_comp), this); - } - - //! <b>Effects</b>: Returns a const iterator to the first element whose - //! key is not less than k or end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: Nothing. - template<class KeyType, class KeyValueCompare> - const_iterator lower_bound(const KeyType &key, KeyValueCompare comp) const - { - detail::key_nodeptr_comp<KeyValueCompare, avltree_impl> - key_node_comp(comp, this); - return const_iterator(node_algorithms::lower_bound - (this->priv_header_ptr(), key, key_node_comp), this); - } - - //! <b>Effects</b>: Returns an iterator to the first element whose - //! key is greater than k or end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: Nothing. - iterator upper_bound(const_reference value) - { return this->upper_bound(value, priv_comp()); } - - //! <b>Effects</b>: Returns an iterator to the first element whose - //! key is greater than k according to comp or end() if that element - //! does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: Nothing. - template<class KeyType, class KeyValueCompare> - iterator upper_bound(const KeyType &key, KeyValueCompare comp) - { - detail::key_nodeptr_comp<KeyValueCompare, avltree_impl> - key_node_comp(comp, this); - return iterator(node_algorithms::upper_bound - (this->priv_header_ptr(), key, key_node_comp), this); - } - - //! <b>Effects</b>: Returns an iterator to the first element whose - //! key is greater than k or end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: Nothing. - const_iterator upper_bound(const_reference value) const - { return this->upper_bound(value, priv_comp()); } - - //! <b>Effects</b>: Returns an iterator to the first element whose - //! key is greater than k according to comp or end() if that element - //! does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: Nothing. - template<class KeyType, class KeyValueCompare> - const_iterator upper_bound(const KeyType &key, KeyValueCompare comp) const - { - detail::key_nodeptr_comp<KeyValueCompare, avltree_impl> - key_node_comp(comp, this); - return const_iterator(node_algorithms::upper_bound - (this->priv_header_ptr(), key, key_node_comp), this); - } - - //! <b>Effects</b>: Finds an iterator to the first element whose key is - //! k or end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: Nothing. - iterator find(const_reference value) - { return this->find(value, priv_comp()); } - - //! <b>Effects</b>: Finds an iterator to the first element whose key is - //! k or end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: Nothing. - template<class KeyType, class KeyValueCompare> - iterator find(const KeyType &key, KeyValueCompare comp) - { - detail::key_nodeptr_comp<KeyValueCompare, avltree_impl> - key_node_comp(comp, this); - return iterator - (node_algorithms::find(this->priv_header_ptr(), key, key_node_comp), this); - } - - //! <b>Effects</b>: Finds a const_iterator to the first element whose key is - //! k or end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: Nothing. - const_iterator find(const_reference value) const - { return this->find(value, priv_comp()); } - - //! <b>Effects</b>: Finds a const_iterator to the first element whose key is - //! k or end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: Nothing. - template<class KeyType, class KeyValueCompare> - const_iterator find(const KeyType &key, KeyValueCompare comp) const - { - detail::key_nodeptr_comp<KeyValueCompare, avltree_impl> - key_node_comp(comp, this); - return const_iterator - (node_algorithms::find(this->priv_header_ptr(), key, key_node_comp), this); - } - - //! <b>Effects</b>: Finds a range containing all elements whose key is k or - //! an empty range that indicates the position where those elements would be - //! if they there is no elements with key k. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: Nothing. - std::pair<iterator,iterator> equal_range(const_reference value) - { return this->equal_range(value, priv_comp()); } - - //! <b>Effects</b>: Finds a range containing all elements whose key is k or - //! an empty range that indicates the position where those elements would be - //! if they there is no elements with key k. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: Nothing. - template<class KeyType, class KeyValueCompare> - std::pair<iterator,iterator> equal_range(const KeyType &key, KeyValueCompare comp) - { - detail::key_nodeptr_comp<KeyValueCompare, avltree_impl> - key_node_comp(comp, this); - std::pair<node_ptr, node_ptr> ret - (node_algorithms::equal_range(this->priv_header_ptr(), key, key_node_comp)); - return std::pair<iterator, iterator>(iterator(ret.first, this), iterator(ret.second, this)); - } - - //! <b>Effects</b>: Finds a range containing all elements whose key is k or - //! an empty range that indicates the position where those elements would be - //! if they there is no elements with key k. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: Nothing. - std::pair<const_iterator, const_iterator> - equal_range(const_reference value) const - { return this->equal_range(value, priv_comp()); } - - //! <b>Effects</b>: Finds a range containing all elements whose key is k or - //! an empty range that indicates the position where those elements would be - //! if they there is no elements with key k. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: Nothing. - template<class KeyType, class KeyValueCompare> - std::pair<const_iterator, const_iterator> - equal_range(const KeyType &key, KeyValueCompare comp) const - { - detail::key_nodeptr_comp<KeyValueCompare, avltree_impl> - key_node_comp(comp, this); - std::pair<node_ptr, node_ptr> ret - (node_algorithms::equal_range(this->priv_header_ptr(), key, key_node_comp)); - return std::pair<const_iterator, const_iterator>(const_iterator(ret.first, this), const_iterator(ret.second, this)); - } - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! Cloner should yield to nodes equivalent to the original nodes. - //! - //! <b>Effects</b>: Erases all the elements from *this - //! calling Disposer::operator()(pointer), clones all the - //! elements from src calling Cloner::operator()(const_reference ) - //! and inserts them on *this. Copies the predicate from the source container. - //! - //! If cloner throws, all cloned elements are unlinked and disposed - //! calling Disposer::operator()(pointer). - //! - //! <b>Complexity</b>: Linear to erased plus inserted elements. - //! - //! <b>Throws</b>: If cloner throws or predicate copy assignment throws. Basic guarantee. - template <class Cloner, class Disposer> - void clone_from(const avltree_impl &src, Cloner cloner, Disposer disposer) - { - this->clear_and_dispose(disposer); - if(!src.empty()){ - detail::exception_disposer<avltree_impl, Disposer> - rollback(*this, disposer); - node_algorithms::clone - (src.priv_header_ptr() - ,this->priv_header_ptr() - ,detail::node_cloner<Cloner, avltree_impl>(cloner, this) - ,detail::node_disposer<Disposer, avltree_impl>(disposer, this)); - this->priv_size_traits().set_size(src.priv_size_traits().get_size()); - this->priv_comp() = src.priv_comp(); - rollback.release(); - } - } - - //! <b>Effects</b>: Unlinks the leftmost node from the tree. - //! - //! <b>Complexity</b>: Average complexity is constant time. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Notes</b>: This function breaks the tree and the tree can - //! only be used for more unlink_leftmost_without_rebalance calls. - //! This function is normally used to achieve a step by step - //! controlled destruction of the tree. - pointer unlink_leftmost_without_rebalance() - { - node_ptr to_be_disposed(node_algorithms::unlink_leftmost_without_rebalance - (this->priv_header_ptr())); - if(!to_be_disposed) - return 0; - this->priv_size_traits().decrement(); - if(safemode_or_autounlink)//If this is commented does not work with normal_link - node_algorithms::init(to_be_disposed); - return get_real_value_traits().to_value_ptr(to_be_disposed); - } - - //! <b>Requires</b>: replace_this must be a valid iterator of *this - //! and with_this must not be inserted in any tree. - //! - //! <b>Effects</b>: Replaces replace_this in its position in the - //! tree with with_this. The tree does not need to be rebalanced. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: This function will break container ordering invariants if - //! with_this is not equivalent to *replace_this according to the - //! ordering rules. This function is faster than erasing and inserting - //! the node, since no rebalancing or comparison is needed. - void replace_node(iterator replace_this, reference with_this) - { - node_algorithms::replace_node( get_real_value_traits().to_node_ptr(*replace_this) - , this->priv_header_ptr() - , get_real_value_traits().to_node_ptr(with_this)); - if(safemode_or_autounlink) - node_algorithms::init(replace_this.pointed_node()); - } - - //! <b>Requires</b>: value must be an lvalue and shall be in a set of - //! appropriate type. Otherwise the behavior is undefined. - //! - //! <b>Effects</b>: Returns: a valid iterator i belonging to the set - //! that points to the value - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: This static function is available only if the <i>value traits</i> - //! is stateless. - static iterator s_iterator_to(reference value) - { - BOOST_STATIC_ASSERT((!stateful_value_traits)); - return iterator (value_traits::to_node_ptr(value), 0); - } - - //! <b>Requires</b>: value must be an lvalue and shall be in a set of - //! appropriate type. Otherwise the behavior is undefined. - //! - //! <b>Effects</b>: Returns: a valid const_iterator i belonging to the - //! set that points to the value - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: This static function is available only if the <i>value traits</i> - //! is stateless. - static const_iterator s_iterator_to(const_reference value) - { - BOOST_STATIC_ASSERT((!stateful_value_traits)); - return const_iterator (value_traits::to_node_ptr(const_cast<reference> (value)), 0); - } - - //! <b>Requires</b>: value must be an lvalue and shall be in a set of - //! appropriate type. Otherwise the behavior is undefined. - //! - //! <b>Effects</b>: Returns: a valid iterator i belonging to the set - //! that points to the value - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - iterator iterator_to(reference value) - { return iterator (value_traits::to_node_ptr(value), this); } - - //! <b>Requires</b>: value must be an lvalue and shall be in a set of - //! appropriate type. Otherwise the behavior is undefined. - //! - //! <b>Effects</b>: Returns: a valid const_iterator i belonging to the - //! set that points to the value - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_iterator iterator_to(const_reference value) const - { return const_iterator (value_traits::to_node_ptr(const_cast<reference> (value)), this); } - - //! <b>Requires</b>: value shall not be in a tree. - //! - //! <b>Effects</b>: init_node puts the hook of a value in a well-known default - //! state. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant time. - //! - //! <b>Note</b>: This function puts the hook in the well-known default state - //! used by auto_unlink and safe hooks. - static void init_node(reference value) - { node_algorithms::init(value_traits::to_node_ptr(value)); } - -/* - //! <b>Effects</b>: removes x from a tree of the appropriate type. It has no effect, - //! if x is not in such a tree. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant time. - //! - //! <b>Note</b>: This static function is only usable with the "safe mode" - //! hook and non-constant time size lists. Otherwise, the user must use - //! the non-static "erase(reference )" member. If the user calls - //! this function with a non "safe mode" or constant time size list - //! a compilation error will be issued. - template<class T> - static void remove_node(T& value) - { - //This function is only usable for safe mode hooks and non-constant - //time lists. - //BOOST_STATIC_ASSERT((!(safemode_or_autounlink && constant_time_size))); - BOOST_STATIC_ASSERT((!constant_time_size)); - BOOST_STATIC_ASSERT((boost::is_convertible<T, value_type>::value)); - node_ptr to_remove(value_traits::to_node_ptr(value)); - node_algorithms::unlink_and_rebalance(to_remove); - if(safemode_or_autounlink) - node_algorithms::init(to_remove); - } -*/ - - /// @cond - - private: - template<class Disposer> - iterator private_erase(const_iterator b, const_iterator e, size_type &n, Disposer disposer) - { - for(n = 0; b != e; ++n) - this->erase_and_dispose(b++, disposer); - return b.unconst(); - } - - iterator private_erase(const_iterator b, const_iterator e, size_type &n) - { - for(n = 0; b != e; ++n) - this->erase(b++); - return b.unconst(); - } - /// @endcond - - private: - static avltree_impl &priv_container_from_end_iterator(const const_iterator &end_iterator) - { - header_plus_size *r = detail::parent_from_member<header_plus_size, node> - ( boost::intrusive::detail::to_raw_pointer(end_iterator.pointed_node()), &header_plus_size::header_); - node_plus_pred_t *n = detail::parent_from_member - <node_plus_pred_t, header_plus_size>(r, &node_plus_pred_t::header_plus_size_); - data_t *d = detail::parent_from_member<data_t, node_plus_pred_t>(n, &data_t::node_plus_pred_); - avltree_impl *avl = detail::parent_from_member<avltree_impl, data_t>(d, &avltree_impl::data_); - return *avl; - } - - static avltree_impl &priv_container_from_iterator(const const_iterator &it) - { return priv_container_from_end_iterator(it.end_iterator_from_it()); } -}; - -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -inline bool operator< -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -(const avltree_impl<T, Options...> &x, const avltree_impl<T, Options...> &y) -#else -(const avltree_impl<Config> &x, const avltree_impl<Config> &y) -#endif -{ return std::lexicographical_compare(x.begin(), x.end(), y.begin(), y.end()); } - -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -bool operator== -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -(const avltree_impl<T, Options...> &x, const avltree_impl<T, Options...> &y) -#else -(const avltree_impl<Config> &x, const avltree_impl<Config> &y) -#endif -{ - typedef avltree_impl<Config> tree_type; - typedef typename tree_type::const_iterator const_iterator; - - if(tree_type::constant_time_size && x.size() != y.size()){ - return false; - } - const_iterator end1 = x.end(); - const_iterator i1 = x.begin(); - const_iterator i2 = y.begin(); - if(tree_type::constant_time_size){ - while (i1 != end1 && *i1 == *i2) { - ++i1; - ++i2; - } - return i1 == end1; - } - else{ - const_iterator end2 = y.end(); - while (i1 != end1 && i2 != end2 && *i1 == *i2) { - ++i1; - ++i2; - } - return i1 == end1 && i2 == end2; - } -} - -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -inline bool operator!= -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -(const avltree_impl<T, Options...> &x, const avltree_impl<T, Options...> &y) -#else -(const avltree_impl<Config> &x, const avltree_impl<Config> &y) -#endif -{ return !(x == y); } - -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -inline bool operator> -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -(const avltree_impl<T, Options...> &x, const avltree_impl<T, Options...> &y) -#else -(const avltree_impl<Config> &x, const avltree_impl<Config> &y) -#endif -{ return y < x; } - -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -inline bool operator<= -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -(const avltree_impl<T, Options...> &x, const avltree_impl<T, Options...> &y) -#else -(const avltree_impl<Config> &x, const avltree_impl<Config> &y) -#endif -{ return !(y < x); } - -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -inline bool operator>= -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -(const avltree_impl<T, Options...> &x, const avltree_impl<T, Options...> &y) -#else -(const avltree_impl<Config> &x, const avltree_impl<Config> &y) -#endif -{ return !(x < y); } - -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -inline void swap -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -(avltree_impl<T, Options...> &x, avltree_impl<T, Options...> &y) -#else -(avltree_impl<Config> &x, avltree_impl<Config> &y) -#endif -{ x.swap(y); } - -/// @cond - -#if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template<class T, class O1 = none, class O2 = none - , class O3 = none, class O4 = none - > -#else -template<class T, class ...Options> -#endif -struct make_avltree_opt -{ - typedef typename pack_options - #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) - < avl_set_defaults<T>, O1, O2, O3, O4> - #else - < avl_set_defaults<T>, Options...> - #endif - ::type packed_options; - - typedef typename detail::get_value_traits - <T, typename packed_options::value_traits>::type value_traits; - - typedef avl_setopt - < value_traits - , typename packed_options::compare - , typename packed_options::size_type - , packed_options::constant_time_size - > type; -}; -/// @endcond - -//! Helper metafunction to define a \c avltree that yields to the same type when the -//! same options (either explicitly or implicitly) are used. -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) || defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template<class T, class ...Options> -#else -template<class T, class O1 = none, class O2 = none - , class O3 = none, class O4 = none> -#endif -struct make_avltree -{ - /// @cond - typedef avltree_impl - #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) - < typename make_avltree_opt<T, O1, O2, O3, O4>::type - #else - < typename make_avltree_opt<T, Options...>::type - #endif - > implementation_defined; - /// @endcond - typedef implementation_defined type; -}; - -#ifndef BOOST_INTRUSIVE_DOXYGEN_INVOKED - -#if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template<class T, class O1, class O2, class O3, class O4> -#else -template<class T, class ...Options> -#endif -class avltree - #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) - : public make_avltree<T, O1, O2, O3, O4>::type - #else - : public make_avltree<T, Options...>::type - #endif -{ - typedef typename make_avltree - #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) - <T, O1, O2, O3, O4> - #else - <T, Options...> - #endif - ::type Base; - - BOOST_MOVABLE_BUT_NOT_COPYABLE(avltree) - - public: - typedef typename Base::value_compare value_compare; - typedef typename Base::value_traits value_traits; - typedef typename Base::real_value_traits real_value_traits; - typedef typename Base::iterator iterator; - typedef typename Base::const_iterator const_iterator; - - //Assert if passed value traits are compatible with the type - BOOST_STATIC_ASSERT((detail::is_same<typename real_value_traits::value_type, T>::value)); - - avltree( const value_compare &cmp = value_compare() - , const value_traits &v_traits = value_traits()) - : Base(cmp, v_traits) - {} - - template<class Iterator> - avltree( bool unique, Iterator b, Iterator e - , const value_compare &cmp = value_compare() - , const value_traits &v_traits = value_traits()) - : Base(unique, b, e, cmp, v_traits) - {} - - avltree(BOOST_RV_REF(avltree) x) - : Base(::boost::move(static_cast<Base&>(x))) - {} - - avltree& operator=(BOOST_RV_REF(avltree) x) - { this->Base::operator=(::boost::move(static_cast<Base&>(x))); return *this; } - - static avltree &container_from_end_iterator(iterator end_iterator) - { return static_cast<avltree &>(Base::container_from_end_iterator(end_iterator)); } - - static const avltree &container_from_end_iterator(const_iterator end_iterator) - { return static_cast<const avltree &>(Base::container_from_end_iterator(end_iterator)); } - - static avltree &container_from_iterator(iterator it) - { return static_cast<avltree &>(Base::container_from_iterator(it)); } - - static const avltree &container_from_iterator(const_iterator it) - { return static_cast<const avltree &>(Base::container_from_iterator(it)); } -}; - -#endif - - -} //namespace intrusive -} //namespace boost - -#include <boost/intrusive/detail/config_end.hpp> - -#endif //BOOST_INTRUSIVE_AVLTREE_HPP diff --git a/src/third_party/boost/boost/intrusive/avltree_algorithms.hpp b/src/third_party/boost/boost/intrusive/avltree_algorithms.hpp deleted file mode 100644 index 9b917c767d7..00000000000 --- a/src/third_party/boost/boost/intrusive/avltree_algorithms.hpp +++ /dev/null @@ -1,943 +0,0 @@ -///////////////////////////////////////////////////////////////////////////// -// -// (C) Copyright Daniel K. O. 2005. -// (C) Copyright Ion Gaztanaga 2007. -// -// Distributed under the Boost Software License, Version 1.0. -// (See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) -// -// See http://www.boost.org/libs/intrusive for documentation. -// -///////////////////////////////////////////////////////////////////////////// - -#ifndef BOOST_INTRUSIVE_AVLTREE_ALGORITHMS_HPP -#define BOOST_INTRUSIVE_AVLTREE_ALGORITHMS_HPP - -#include <boost/intrusive/detail/config_begin.hpp> - -#include <cstddef> -#include <boost/intrusive/intrusive_fwd.hpp> - -#include <boost/intrusive/detail/assert.hpp> -#include <boost/intrusive/detail/utilities.hpp> -#include <boost/intrusive/detail/tree_algorithms.hpp> -#include <boost/intrusive/pointer_traits.hpp> - - -namespace boost { -namespace intrusive { - -//! avltree_algorithms is configured with a NodeTraits class, which encapsulates the -//! information about the node to be manipulated. NodeTraits must support the -//! following interface: -//! -//! <b>Typedefs</b>: -//! -//! <tt>node</tt>: The type of the node that forms the circular list -//! -//! <tt>node_ptr</tt>: A pointer to a node -//! -//! <tt>const_node_ptr</tt>: A pointer to a const node -//! -//! <tt>balance</tt>: The type of the balance factor -//! -//! <b>Static functions</b>: -//! -//! <tt>static node_ptr get_parent(const_node_ptr n);</tt> -//! -//! <tt>static void set_parent(node_ptr n, node_ptr parent);</tt> -//! -//! <tt>static node_ptr get_left(const_node_ptr n);</tt> -//! -//! <tt>static void set_left(node_ptr n, node_ptr left);</tt> -//! -//! <tt>static node_ptr get_right(const_node_ptr n);</tt> -//! -//! <tt>static void set_right(node_ptr n, node_ptr right);</tt> -//! -//! <tt>static balance get_balance(const_node_ptr n);</tt> -//! -//! <tt>static void set_balance(node_ptr n, balance b);</tt> -//! -//! <tt>static balance negative();</tt> -//! -//! <tt>static balance zero();</tt> -//! -//! <tt>static balance positive();</tt> -template<class NodeTraits> -class avltree_algorithms -{ - public: - typedef typename NodeTraits::node node; - typedef NodeTraits node_traits; - typedef typename NodeTraits::node_ptr node_ptr; - typedef typename NodeTraits::const_node_ptr const_node_ptr; - typedef typename NodeTraits::balance balance; - - /// @cond - private: - typedef detail::tree_algorithms<NodeTraits> tree_algorithms; - - template<class F> - struct avltree_node_cloner - : private detail::ebo_functor_holder<F> - { - typedef detail::ebo_functor_holder<F> base_t; - - avltree_node_cloner(F f) - : base_t(f) - {} - - node_ptr operator()(const node_ptr &p) - { - node_ptr n = base_t::get()(p); - NodeTraits::set_balance(n, NodeTraits::get_balance(p)); - return n; - } - }; - - struct avltree_erase_fixup - { - void operator()(const node_ptr &to_erase, const node_ptr &successor) - { NodeTraits::set_balance(successor, NodeTraits::get_balance(to_erase)); } - }; - - static node_ptr uncast(const const_node_ptr & ptr) - { return pointer_traits<node_ptr>::const_cast_from(ptr); } - /// @endcond - - public: - static node_ptr begin_node(const const_node_ptr & header) - { return tree_algorithms::begin_node(header); } - - static node_ptr end_node(const const_node_ptr & header) - { return tree_algorithms::end_node(header); } - - //! This type is the information that will be - //! filled by insert_unique_check - typedef typename tree_algorithms::insert_commit_data insert_commit_data; - - //! <b>Requires</b>: header1 and header2 must be the header nodes - //! of two trees. - //! - //! <b>Effects</b>: Swaps two trees. After the function header1 will contain - //! links to the second tree and header2 will have links to the first tree. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - static void swap_tree(const node_ptr & header1, const node_ptr & header2) - { return tree_algorithms::swap_tree(header1, header2); } - - //! <b>Requires</b>: node1 and node2 can't be header nodes - //! of two trees. - //! - //! <b>Effects</b>: Swaps two nodes. After the function node1 will be inserted - //! in the position node2 before the function. node2 will be inserted in the - //! position node1 had before the function. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: This function will break container ordering invariants if - //! node1 and node2 are not equivalent according to the ordering rules. - //! - //!Experimental function - static void swap_nodes(const node_ptr & node1, const node_ptr & node2) - { - if(node1 == node2) - return; - - node_ptr header1(tree_algorithms::get_header(node1)), header2(tree_algorithms::get_header(node2)); - swap_nodes(node1, header1, node2, header2); - } - - //! <b>Requires</b>: node1 and node2 can't be header nodes - //! of two trees with header header1 and header2. - //! - //! <b>Effects</b>: Swaps two nodes. After the function node1 will be inserted - //! in the position node2 before the function. node2 will be inserted in the - //! position node1 had before the function. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: This function will break container ordering invariants if - //! node1 and node2 are not equivalent according to the ordering rules. - //! - //!Experimental function - static void swap_nodes(const node_ptr & node1, const node_ptr & header1, const node_ptr & node2, const node_ptr & header2) - { - if(node1 == node2) return; - - tree_algorithms::swap_nodes(node1, header1, node2, header2); - //Swap balance - balance c = NodeTraits::get_balance(node1); - NodeTraits::set_balance(node1, NodeTraits::get_balance(node2)); - NodeTraits::set_balance(node2, c); - } - - //! <b>Requires</b>: node_to_be_replaced must be inserted in a tree - //! and new_node must not be inserted in a tree. - //! - //! <b>Effects</b>: Replaces node_to_be_replaced in its position in the - //! tree with new_node. The tree does not need to be rebalanced - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: This function will break container ordering invariants if - //! 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 - static void replace_node(const node_ptr & node_to_be_replaced, const node_ptr & new_node) - { - if(node_to_be_replaced == new_node) - return; - replace_node(node_to_be_replaced, tree_algorithms::get_header(node_to_be_replaced), new_node); - } - - //! <b>Requires</b>: node_to_be_replaced must be inserted in a tree - //! with header "header" and new_node must not be inserted in a tree. - //! - //! <b>Effects</b>: Replaces node_to_be_replaced in its position in the - //! tree with new_node. The tree does not need to be rebalanced - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: This function will break container ordering invariants if - //! 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 or comparison is needed. - //! - //!Experimental function - static void replace_node(const node_ptr & node_to_be_replaced, const node_ptr & header, const node_ptr & new_node) - { - tree_algorithms::replace_node(node_to_be_replaced, header, new_node); - NodeTraits::set_balance(new_node, NodeTraits::get_balance(node_to_be_replaced)); - } - - //! <b>Requires</b>: node is a tree node but not the header. - //! - //! <b>Effects</b>: Unlinks the node and rebalances the tree. - //! - //! <b>Complexity</b>: Average complexity is constant time. - //! - //! <b>Throws</b>: Nothing. - static void unlink(const node_ptr & node) - { - node_ptr x = NodeTraits::get_parent(node); - if(x){ - while(!is_header(x)) - x = NodeTraits::get_parent(x); - erase(x, node); - } - } - - //! <b>Requires</b>: header is the header of a tree. - //! - //! <b>Effects</b>: Unlinks the leftmost node from the tree, and - //! updates the header link to the new leftmost node. - //! - //! <b>Complexity</b>: Average complexity is constant time. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Notes</b>: This function breaks the tree and the tree can - //! only be used for more unlink_leftmost_without_rebalance calls. - //! This function is normally used to achieve a step by step - //! controlled destruction of the tree. - static node_ptr unlink_leftmost_without_rebalance(const node_ptr & header) - { return tree_algorithms::unlink_leftmost_without_rebalance(header); } - - //! <b>Requires</b>: node is a node of the tree or an node initialized - //! by init(...). - //! - //! <b>Effects</b>: Returns true if the node is initialized by init(). - //! - //! <b>Complexity</b>: Constant time. - //! - //! <b>Throws</b>: Nothing. - static bool unique(const const_node_ptr & node) - { return tree_algorithms::unique(node); } - - //! <b>Requires</b>: node is a node of the tree but it's not the header. - //! - //! <b>Effects</b>: Returns the number of nodes of the subtree. - //! - //! <b>Complexity</b>: Linear time. - //! - //! <b>Throws</b>: Nothing. - static std::size_t count(const const_node_ptr & node) - { return tree_algorithms::count(node); } - - //! <b>Requires</b>: header is the header node of the tree. - //! - //! <b>Effects</b>: Returns the number of nodes above the header. - //! - //! <b>Complexity</b>: Linear time. - //! - //! <b>Throws</b>: Nothing. - static std::size_t size(const const_node_ptr & header) - { return tree_algorithms::size(header); } - - //! <b>Requires</b>: p is a node from the tree except the header. - //! - //! <b>Effects</b>: Returns the next node of the tree. - //! - //! <b>Complexity</b>: Average constant time. - //! - //! <b>Throws</b>: Nothing. - static node_ptr next_node(const node_ptr & p) - { return tree_algorithms::next_node(p); } - - //! <b>Requires</b>: p is a node from the tree except the leftmost node. - //! - //! <b>Effects</b>: Returns the previous node of the tree. - //! - //! <b>Complexity</b>: Average constant time. - //! - //! <b>Throws</b>: Nothing. - static node_ptr prev_node(const node_ptr & p) - { return tree_algorithms::prev_node(p); } - - //! <b>Requires</b>: node must not be part of any tree. - //! - //! <b>Effects</b>: After the function unique(node) == true. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Nodes</b>: If node is inserted in a tree, this function corrupts the tree. - static void init(const node_ptr & node) - { tree_algorithms::init(node); } - - //! <b>Requires</b>: node must not be part of any tree. - //! - //! <b>Effects</b>: Initializes the header to represent an empty tree. - //! unique(header) == true. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Nodes</b>: If node is inserted in a tree, this function corrupts the tree. - static void init_header(const node_ptr & header) - { - tree_algorithms::init_header(header); - NodeTraits::set_balance(header, NodeTraits::zero()); - } - - //! <b>Requires</b>: header must be the header of a tree, z a node - //! of that tree and z != header. - //! - //! <b>Effects</b>: Erases node "z" from the tree with header "header". - //! - //! <b>Complexity</b>: Amortized constant time. - //! - //! <b>Throws</b>: Nothing. - static node_ptr erase(const node_ptr & header, const node_ptr & z) - { - typename tree_algorithms::data_for_rebalance info; - tree_algorithms::erase(header, z, avltree_erase_fixup(), info); - node_ptr x = info.x; - node_ptr x_parent = info.x_parent; - - //Rebalance avltree - rebalance_after_erasure(header, x, x_parent); - return z; - } - - //! <b>Requires</b>: "cloner" must be a function - //! object taking a node_ptr and returning a new cloned node of it. "disposer" must - //! take a node_ptr and shouldn't throw. - //! - //! <b>Effects</b>: First empties target tree calling - //! <tt>void disposer::operator()(const node_ptr &)</tt> for every node of the tree - //! except the header. - //! - //! Then, duplicates the entire tree pointed by "source_header" cloning each - //! source node with <tt>node_ptr Cloner::operator()(const node_ptr &)</tt> to obtain - //! the nodes of the target tree. If "cloner" throws, the cloned target nodes - //! are disposed using <tt>void disposer(const node_ptr &)</tt>. - //! - //! <b>Complexity</b>: Linear to the number of element of the source tree plus the. - //! number of elements of tree target tree when calling this function. - //! - //! <b>Throws</b>: If cloner functor throws. If this happens target nodes are disposed. - template <class Cloner, class Disposer> - static void clone - (const const_node_ptr & source_header, const node_ptr & target_header, Cloner cloner, Disposer disposer) - { - avltree_node_cloner<Cloner> new_cloner(cloner); - tree_algorithms::clone(source_header, target_header, new_cloner, disposer); - } - - //! <b>Requires</b>: "disposer" must be an object function - //! taking a node_ptr parameter and shouldn't throw. - //! - //! <b>Effects</b>: Empties the target tree calling - //! <tt>void disposer::operator()(const node_ptr &)</tt> for every node of the tree - //! except the header. - //! - //! <b>Complexity</b>: Linear to the number of element of the source tree plus the. - //! number of elements of tree target tree when calling this function. - //! - //! <b>Throws</b>: If cloner functor throws. If this happens target nodes are disposed. - template<class Disposer> - static void clear_and_dispose(const node_ptr & header, Disposer disposer) - { tree_algorithms::clear_and_dispose(header, disposer); } - - //! <b>Requires</b>: "header" must be the header node of a tree. - //! KeyNodePtrCompare is a function object that induces a strict weak - //! ordering compatible with the strict weak ordering used to create the - //! the tree. KeyNodePtrCompare can compare KeyType with tree's node_ptrs. - //! - //! <b>Effects</b>: Returns an node_ptr to the first element that is - //! not less than "key" according to "comp" or "header" if that element does - //! not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If "comp" throws. - template<class KeyType, class KeyNodePtrCompare> - static node_ptr lower_bound - (const const_node_ptr & header, const KeyType &key, KeyNodePtrCompare comp) - { return tree_algorithms::lower_bound(header, key, comp); } - - //! <b>Requires</b>: "header" must be the header node of a tree. - //! KeyNodePtrCompare is a function object that induces a strict weak - //! ordering compatible with the strict weak ordering used to create the - //! the tree. KeyNodePtrCompare can compare KeyType with tree's node_ptrs. - //! - //! <b>Effects</b>: Returns an node_ptr to the first element that is greater - //! than "key" according to "comp" or "header" if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If "comp" throws. - template<class KeyType, class KeyNodePtrCompare> - static node_ptr upper_bound - (const const_node_ptr & header, const KeyType &key, KeyNodePtrCompare comp) - { return tree_algorithms::upper_bound(header, key, comp); } - - //! <b>Requires</b>: "header" must be the header node of a tree. - //! KeyNodePtrCompare is a function object that induces a strict weak - //! ordering compatible with the strict weak ordering used to create the - //! the tree. KeyNodePtrCompare can compare KeyType with tree's node_ptrs. - //! - //! <b>Effects</b>: Returns an node_ptr to the element that is equivalent to - //! "key" according to "comp" or "header" if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If "comp" throws. - template<class KeyType, class KeyNodePtrCompare> - static node_ptr find - (const const_node_ptr & header, const KeyType &key, KeyNodePtrCompare comp) - { return tree_algorithms::find(header, key, comp); } - - //! <b>Requires</b>: "header" must be the header node of a tree. - //! KeyNodePtrCompare is a function object that induces a strict weak - //! ordering compatible with the strict weak ordering used to create the - //! the tree. KeyNodePtrCompare can compare KeyType with tree's node_ptrs. - //! - //! <b>Effects</b>: Returns an a pair of node_ptr delimiting a range containing - //! all elements that are equivalent to "key" according to "comp" or an - //! empty range that indicates the position where those elements would be - //! if they there are no equivalent elements. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If "comp" throws. - template<class KeyType, class KeyNodePtrCompare> - static std::pair<node_ptr, node_ptr> equal_range - (const const_node_ptr & header, const KeyType &key, KeyNodePtrCompare comp) - { return tree_algorithms::equal_range(header, key, comp); } - - //! <b>Requires</b>: "h" must be the header node of a tree. - //! NodePtrCompare is a function object that induces a strict weak - //! ordering compatible with the strict weak ordering used to create the - //! the tree. NodePtrCompare compares two node_ptrs. - //! - //! <b>Effects</b>: Inserts new_node into the tree before the upper bound - //! according to "comp". - //! - //! <b>Complexity</b>: Average complexity for insert element is at - //! most logarithmic. - //! - //! <b>Throws</b>: If "comp" throws. - template<class NodePtrCompare> - static node_ptr insert_equal_upper_bound - (const node_ptr & h, const node_ptr & new_node, NodePtrCompare comp) - { - tree_algorithms::insert_equal_upper_bound(h, new_node, comp); - rebalance_after_insertion(h, new_node); - return new_node; - } - - //! <b>Requires</b>: "h" must be the header node of a tree. - //! NodePtrCompare is a function object that induces a strict weak - //! ordering compatible with the strict weak ordering used to create the - //! the tree. NodePtrCompare compares two node_ptrs. - //! - //! <b>Effects</b>: Inserts new_node into the tree before the lower bound - //! according to "comp". - //! - //! <b>Complexity</b>: Average complexity for insert element is at - //! most logarithmic. - //! - //! <b>Throws</b>: If "comp" throws. - template<class NodePtrCompare> - static node_ptr insert_equal_lower_bound - (const node_ptr & h, const node_ptr & new_node, NodePtrCompare comp) - { - tree_algorithms::insert_equal_lower_bound(h, new_node, comp); - rebalance_after_insertion(h, new_node); - return new_node; - } - - //! <b>Requires</b>: "header" must be the header node of a tree. - //! NodePtrCompare is a function object that induces a strict weak - //! ordering compatible with the strict weak ordering used to create the - //! the tree. NodePtrCompare compares two node_ptrs. "hint" is node from - //! the "header"'s tree. - //! - //! <b>Effects</b>: Inserts new_node into the tree, using "hint" as a hint to - //! where it will be inserted. If "hint" is the upper_bound - //! the insertion takes constant time (two comparisons in the worst case). - //! - //! <b>Complexity</b>: Logarithmic in general, but it is amortized - //! constant time if new_node is inserted immediately before "hint". - //! - //! <b>Throws</b>: If "comp" throws. - template<class NodePtrCompare> - static node_ptr insert_equal - (const node_ptr & header, const node_ptr & hint, const node_ptr & new_node, NodePtrCompare comp) - { - tree_algorithms::insert_equal(header, hint, new_node, comp); - rebalance_after_insertion(header, new_node); - return new_node; - } - - //! <b>Requires</b>: "header" must be the header node of a tree. - //! "pos" must be a valid iterator or header (end) node. - //! "pos" must be an iterator pointing to the successor to "new_node" - //! once inserted according to the order of already inserted nodes. This function does not - //! check "pos" and this precondition must be guaranteed by the caller. - //! - //! <b>Effects</b>: Inserts new_node into the tree before "pos". - //! - //! <b>Complexity</b>: Constant-time. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: If "pos" is not the successor of the newly inserted "new_node" - //! tree invariants might be broken. - static node_ptr insert_before - (const node_ptr & header, const node_ptr & pos, const node_ptr & new_node) - { - tree_algorithms::insert_before(header, pos, new_node); - rebalance_after_insertion(header, new_node); - return new_node; - } - - //! <b>Requires</b>: "header" must be the header node of a tree. - //! "new_node" must be, according to the used ordering no less than the - //! greatest inserted key. - //! - //! <b>Effects</b>: Inserts new_node into the tree before "pos". - //! - //! <b>Complexity</b>: Constant-time. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: If "new_node" is less than the greatest inserted key - //! tree invariants are broken. This function is slightly faster than - //! using "insert_before". - static void push_back(const node_ptr & header, const node_ptr & new_node) - { - tree_algorithms::push_back(header, new_node); - rebalance_after_insertion(header, new_node); - } - - //! <b>Requires</b>: "header" must be the header node of a tree. - //! "new_node" must be, according to the used ordering, no greater than the - //! lowest inserted key. - //! - //! <b>Effects</b>: Inserts new_node into the tree before "pos". - //! - //! <b>Complexity</b>: Constant-time. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: If "new_node" is greater than the lowest inserted key - //! tree invariants are broken. This function is slightly faster than - //! using "insert_before". - static void push_front(const node_ptr & header, const node_ptr & new_node) - { - tree_algorithms::push_front(header, new_node); - rebalance_after_insertion(header, new_node); - } - - //! <b>Requires</b>: "header" must be the header node of a tree. - //! KeyNodePtrCompare is a function object that induces a strict weak - //! ordering compatible with the strict weak ordering used to create the - //! the tree. NodePtrCompare compares KeyType with a node_ptr. - //! - //! <b>Effects</b>: Checks if there is an equivalent node to "key" in the - //! tree according to "comp" and obtains the needed information to realize - //! a constant-time node insertion if there is no equivalent node. - //! - //! <b>Returns</b>: If there is an equivalent value - //! returns a pair containing a node_ptr to the already present node - //! and false. If there is not equivalent key can be inserted returns true - //! in the returned pair's boolean and fills "commit_data" that is meant to - //! be used with the "insert_commit" function to achieve a constant-time - //! insertion function. - //! - //! <b>Complexity</b>: Average complexity is at most logarithmic. - //! - //! <b>Throws</b>: If "comp" throws. - //! - //! <b>Notes</b>: This function is used to improve performance when constructing - //! a node is expensive and the user does not want to have two equivalent nodes - //! in the tree: if there is an equivalent value - //! the constructed object must be discarded. Many times, the part of the - //! node that is used to impose the order is much cheaper to construct - //! than the node and this function offers the possibility to use that part - //! to check if the insertion will be successful. - //! - //! If the check is successful, the user can construct the node and use - //! "insert_commit" to insert the node in constant-time. This gives a total - //! logarithmic complexity to the insertion: check(O(log(N)) + commit(O(1)). - //! - //! "commit_data" remains valid for a subsequent "insert_unique_commit" only - //! if no more objects are inserted or erased from the set. - template<class KeyType, class KeyNodePtrCompare> - static std::pair<node_ptr, bool> insert_unique_check - (const const_node_ptr & header, const KeyType &key - ,KeyNodePtrCompare comp, insert_commit_data &commit_data) - { return tree_algorithms::insert_unique_check(header, key, comp, commit_data); } - - //! <b>Requires</b>: "header" must be the header node of a tree. - //! KeyNodePtrCompare is a function object that induces a strict weak - //! ordering compatible with the strict weak ordering used to create the - //! the tree. NodePtrCompare compares KeyType with a node_ptr. - //! "hint" is node from the "header"'s tree. - //! - //! <b>Effects</b>: Checks if there is an equivalent node to "key" in the - //! tree according to "comp" using "hint" as a hint to where it should be - //! inserted and obtains the needed information to realize - //! a constant-time node insertion if there is no equivalent node. - //! If "hint" is the upper_bound the function has constant time - //! complexity (two comparisons in the worst case). - //! - //! <b>Returns</b>: If there is an equivalent value - //! returns a pair containing a node_ptr to the already present node - //! and false. If there is not equivalent key can be inserted returns true - //! in the returned pair's boolean and fills "commit_data" that is meant to - //! be used with the "insert_commit" function to achieve a constant-time - //! insertion function. - //! - //! <b>Complexity</b>: Average complexity is at most logarithmic, but it is - //! amortized constant time if new_node should be inserted immediately before "hint". - //! - //! <b>Throws</b>: If "comp" throws. - //! - //! <b>Notes</b>: This function is used to improve performance when constructing - //! a node is expensive and the user does not want to have two equivalent nodes - //! in the tree: if there is an equivalent value - //! the constructed object must be discarded. Many times, the part of the - //! node that is used to impose the order is much cheaper to construct - //! than the node and this function offers the possibility to use that part - //! to check if the insertion will be successful. - //! - //! If the check is successful, the user can construct the node and use - //! "insert_commit" to insert the node in constant-time. This gives a total - //! logarithmic complexity to the insertion: check(O(log(N)) + commit(O(1)). - //! - //! "commit_data" remains valid for a subsequent "insert_unique_commit" only - //! if no more objects are inserted or erased from the set. - template<class KeyType, class KeyNodePtrCompare> - static std::pair<node_ptr, bool> insert_unique_check - (const const_node_ptr & header, const node_ptr &hint, const KeyType &key - ,KeyNodePtrCompare comp, insert_commit_data &commit_data) - { return tree_algorithms::insert_unique_check(header, hint, key, comp, commit_data); } - - //! <b>Requires</b>: "header" must be the header node of a tree. - //! "commit_data" must have been obtained from a previous call to - //! "insert_unique_check". No objects should have been inserted or erased - //! from the set between the "insert_unique_check" that filled "commit_data" - //! and the call to "insert_commit". - //! - //! - //! <b>Effects</b>: Inserts new_node in the set using the information obtained - //! from the "commit_data" that a previous "insert_check" filled. - //! - //! <b>Complexity</b>: Constant time. - //! - //! <b>Throws</b>: Nothing. - //! - //! <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. - static void insert_unique_commit - (const node_ptr & header, const node_ptr & new_value, const insert_commit_data &commit_data) - { - tree_algorithms::insert_unique_commit(header, new_value, commit_data); - rebalance_after_insertion(header, new_value); - } - - //! <b>Requires</b>: "n" must be a node inserted in a tree. - //! - //! <b>Effects</b>: Returns a pointer to the header node of the tree. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: Nothing. - static node_ptr get_header(const node_ptr & n) - { return tree_algorithms::get_header(n); } - - /// @cond - private: - - //! <b>Requires</b>: p is a node of a tree. - //! - //! <b>Effects</b>: Returns true if p is the header of the tree. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - static bool is_header(const const_node_ptr & p) - { return NodeTraits::get_balance(p) == NodeTraits::zero() && tree_algorithms::is_header(p); } - - static void rebalance_after_erasure(const node_ptr & header, const node_ptr & xnode, const node_ptr & xnode_parent) - { - node_ptr x(xnode), x_parent(xnode_parent); - for (node_ptr root = NodeTraits::get_parent(header); x != root; root = NodeTraits::get_parent(header)) { - const balance x_parent_balance = NodeTraits::get_balance(x_parent); - if(x_parent_balance == NodeTraits::zero()){ - NodeTraits::set_balance(x_parent, - (x == NodeTraits::get_right(x_parent) ? NodeTraits::negative() : NodeTraits::positive())); - break; // the height didn't change, let's stop here - } - else if(x_parent_balance == NodeTraits::negative()){ - if (x == NodeTraits::get_left(x_parent)) { - NodeTraits::set_balance(x_parent, NodeTraits::zero()); // balanced - x = x_parent; - x_parent = NodeTraits::get_parent(x_parent); - } - else { - // x is right child - // a is left child - node_ptr a = NodeTraits::get_left(x_parent); - BOOST_INTRUSIVE_INVARIANT_ASSERT(a); - if (NodeTraits::get_balance(a) == NodeTraits::positive()) { - // a MUST have a right child - BOOST_INTRUSIVE_INVARIANT_ASSERT(NodeTraits::get_right(a)); - rotate_left_right(x_parent, header); - x = NodeTraits::get_parent(x_parent); - x_parent = NodeTraits::get_parent(x); - } - else { - rotate_right(x_parent, header); - x = NodeTraits::get_parent(x_parent); - x_parent = NodeTraits::get_parent(x); - } - - // if changed from negative to NodeTraits::positive(), no need to check above - if (NodeTraits::get_balance(x) == NodeTraits::positive()){ - break; - } - } - } - else if(x_parent_balance == NodeTraits::positive()){ - if (x == NodeTraits::get_right(x_parent)) { - NodeTraits::set_balance(x_parent, NodeTraits::zero()); // balanced - x = x_parent; - x_parent = NodeTraits::get_parent(x_parent); - } - else { - // x is left child - // a is right child - node_ptr a = NodeTraits::get_right(x_parent); - BOOST_INTRUSIVE_INVARIANT_ASSERT(a); - if (NodeTraits::get_balance(a) == NodeTraits::negative()) { - // a MUST have then a left child - BOOST_INTRUSIVE_INVARIANT_ASSERT(NodeTraits::get_left(a)); - rotate_right_left(x_parent, header); - - x = NodeTraits::get_parent(x_parent); - x_parent = NodeTraits::get_parent(x); - } - else { - rotate_left(x_parent, header); - x = NodeTraits::get_parent(x_parent); - x_parent = NodeTraits::get_parent(x); - } - // if changed from NodeTraits::positive() to negative, no need to check above - if (NodeTraits::get_balance(x) == NodeTraits::negative()){ - break; - } - } - } - else{ - BOOST_INTRUSIVE_INVARIANT_ASSERT(false); // never reached - } - } - } - - static void rebalance_after_insertion(const node_ptr & header, const node_ptr & xnode) - { - node_ptr x(xnode); - NodeTraits::set_balance(x, NodeTraits::zero()); - // Rebalance. - for(node_ptr root = NodeTraits::get_parent(header); x != root; root = NodeTraits::get_parent(header)){ - const balance x_parent_balance = NodeTraits::get_balance(NodeTraits::get_parent(x)); - - if(x_parent_balance == NodeTraits::zero()){ - // if x is left, parent will have parent->bal_factor = negative - // else, parent->bal_factor = NodeTraits::positive() - NodeTraits::set_balance( NodeTraits::get_parent(x) - , x == NodeTraits::get_left(NodeTraits::get_parent(x)) - ? NodeTraits::negative() : NodeTraits::positive() ); - x = NodeTraits::get_parent(x); - } - else if(x_parent_balance == NodeTraits::positive()){ - // if x is a left child, parent->bal_factor = zero - if (x == NodeTraits::get_left(NodeTraits::get_parent(x))) - NodeTraits::set_balance(NodeTraits::get_parent(x), NodeTraits::zero()); - else{ // x is a right child, needs rebalancing - if (NodeTraits::get_balance(x) == NodeTraits::negative()) - rotate_right_left(NodeTraits::get_parent(x), header); - else - rotate_left(NodeTraits::get_parent(x), header); - } - break; - } - else if(x_parent_balance == NodeTraits::negative()){ - // if x is a left child, needs rebalancing - if (x == NodeTraits::get_left(NodeTraits::get_parent(x))) { - if (NodeTraits::get_balance(x) == NodeTraits::positive()) - rotate_left_right(NodeTraits::get_parent(x), header); - else - rotate_right(NodeTraits::get_parent(x), header); - } - else - NodeTraits::set_balance(NodeTraits::get_parent(x), NodeTraits::zero()); - break; - } - else{ - BOOST_INTRUSIVE_INVARIANT_ASSERT(false); // never reached - } - } - } - - static void left_right_balancing(const node_ptr & a, const node_ptr & b, const node_ptr & c) - { - // balancing... - const balance c_balance = NodeTraits::get_balance(c); - const balance zero_balance = NodeTraits::zero(); - NodeTraits::set_balance(c, zero_balance); - if(c_balance == NodeTraits::negative()){ - NodeTraits::set_balance(a, NodeTraits::positive()); - NodeTraits::set_balance(b, zero_balance); - } - else if(c_balance == zero_balance){ - NodeTraits::set_balance(a, zero_balance); - NodeTraits::set_balance(b, zero_balance); - } - else if(c_balance == NodeTraits::positive()){ - NodeTraits::set_balance(a, zero_balance); - NodeTraits::set_balance(b, NodeTraits::negative()); - } - else{ - BOOST_INTRUSIVE_INVARIANT_ASSERT(false); // never reached - } - } - - static void rotate_left_right(const node_ptr a, const node_ptr & hdr) - { - // | | // - // a(-2) c // - // / \ / \ // - // / \ ==> / \ // - // (pos)b [g] b a // - // / \ / \ / \ // - // [d] c [d] e f [g] // - // / \ // - // e f // - node_ptr b = NodeTraits::get_left(a), c = NodeTraits::get_right(b); - tree_algorithms::rotate_left(b, hdr); - tree_algorithms::rotate_right(a, hdr); - left_right_balancing(a, b, c); - } - - static void rotate_right_left(const node_ptr a, const node_ptr & hdr) - { - // | | // - // a(pos) c // - // / \ / \ // - // / \ / \ // - // [d] b(neg) ==> a b // - // / \ / \ / \ // - // c [g] [d] e f [g] // - // / \ // - // e f // - node_ptr b = NodeTraits::get_right(a), c = NodeTraits::get_left(b); - tree_algorithms::rotate_right(b, hdr); - tree_algorithms::rotate_left(a, hdr); - left_right_balancing(b, a, c); - } - - static void rotate_left(const node_ptr x, const node_ptr & hdr) - { - const node_ptr y = NodeTraits::get_right(x); - tree_algorithms::rotate_left(x, hdr); - - // reset the balancing factor - if (NodeTraits::get_balance(y) == NodeTraits::positive()) { - NodeTraits::set_balance(x, NodeTraits::zero()); - NodeTraits::set_balance(y, NodeTraits::zero()); - } - else { // this doesn't happen during insertions - NodeTraits::set_balance(x, NodeTraits::positive()); - NodeTraits::set_balance(y, NodeTraits::negative()); - } - } - - static void rotate_right(const node_ptr x, const node_ptr & hdr) - { - const node_ptr y = NodeTraits::get_left(x); - tree_algorithms::rotate_right(x, hdr); - - // reset the balancing factor - if (NodeTraits::get_balance(y) == NodeTraits::negative()) { - NodeTraits::set_balance(x, NodeTraits::zero()); - NodeTraits::set_balance(y, NodeTraits::zero()); - } - else { // this doesn't happen during insertions - NodeTraits::set_balance(x, NodeTraits::negative()); - NodeTraits::set_balance(y, NodeTraits::positive()); - } - } - - /// @endcond -}; - -} //namespace intrusive -} //namespace boost - -#include <boost/intrusive/detail/config_end.hpp> - -#endif //BOOST_INTRUSIVE_AVLTREE_ALGORITHMS_HPP diff --git a/src/third_party/boost/boost/intrusive/bs_set_hook.hpp b/src/third_party/boost/boost/intrusive/bs_set_hook.hpp deleted file mode 100644 index bf8e2de09a6..00000000000 --- a/src/third_party/boost/boost/intrusive/bs_set_hook.hpp +++ /dev/null @@ -1,296 +0,0 @@ -///////////////////////////////////////////////////////////////////////////// -// -// (C) Copyright Ion Gaztanaga 2007-2009 -// -// Distributed under the Boost Software License, Version 1.0. -// (See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) -// -// See http://www.boost.org/libs/intrusive for documentation. -// -///////////////////////////////////////////////////////////////////////////// - -#ifndef BOOST_INTRUSIVE_BS_SET_HOOK_HPP -#define BOOST_INTRUSIVE_BS_SET_HOOK_HPP - -#include <boost/intrusive/detail/config_begin.hpp> -#include <boost/intrusive/intrusive_fwd.hpp> -#include <boost/intrusive/detail/utilities.hpp> -#include <boost/intrusive/detail/tree_node.hpp> -#include <boost/intrusive/detail/tree_algorithms.hpp> -#include <boost/intrusive/options.hpp> -#include <boost/intrusive/detail/generic_hook.hpp> - -namespace boost { -namespace intrusive { - -/// @cond -template<class VoidPointer> -struct get_bs_set_node_algo -{ - typedef detail::tree_algorithms<tree_node_traits<VoidPointer> > type; -}; -/// @endcond - -//! Helper metafunction to define a \c bs_set_base_hook that yields to the same -//! type when the same options (either explicitly or implicitly) are used. -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) || defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template<class ...Options> -#else -template<class O1 = none, class O2 = none, class O3 = none> -#endif -struct make_bs_set_base_hook -{ - /// @cond - typedef typename pack_options - #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) - < hook_defaults, O1, O2, O3> - #else - < hook_defaults, Options...> - #endif - ::type packed_options; - - //Scapegoat trees can't be auto unlink trees - BOOST_STATIC_ASSERT(((int)packed_options::link_mode != (int)auto_unlink)); - - typedef detail::generic_hook - < get_bs_set_node_algo<typename packed_options::void_pointer> - , typename packed_options::tag - , packed_options::link_mode - , detail::BsSetBaseHook - > implementation_defined; - /// @endcond - typedef implementation_defined type; -}; - -//! Derive a class from bs_set_base_hook in order to store objects in -//! in a bs_set/bs_multiset. bs_set_base_hook holds the data necessary to maintain -//! the bs_set/bs_multiset and provides an appropriate value_traits class for bs_set/bs_multiset. -//! -//! The hook admits the following options: \c tag<>, \c void_pointer<>, -//! \c link_mode<>. -//! -//! \c tag<> defines a tag to identify the node. -//! The same tag value can be used in different classes, but if a class is -//! derived from more than one \c list_base_hook, then each \c list_base_hook needs its -//! unique tag. -//! -//! \c void_pointer<> is the pointer type that will be used internally in the hook -//! and the the container configured to use this hook. -//! -//! \c link_mode<> will specify the linking mode of the hook (\c normal_link, -//! \c auto_unlink or \c safe_link). -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) || defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template<class ...Options> -#else -template<class O1, class O2, class O3> -#endif -class bs_set_base_hook - : public make_bs_set_base_hook - #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) - <O1, O2, O3> - #else - <Options...> - #endif - ::type - -{ - #if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) - public: - //! <b>Effects</b>: If link_mode is \c auto_unlink or \c safe_link - //! initializes the node to an unlinked state. - //! - //! <b>Throws</b>: Nothing. - bs_set_base_hook(); - - //! <b>Effects</b>: If link_mode is \c auto_unlink or \c safe_link - //! initializes the node to an unlinked state. The argument is ignored. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Rationale</b>: Providing a copy-constructor - //! makes classes using the hook STL-compliant without forcing the - //! user to do some additional work. \c swap can be used to emulate - //! move-semantics. - bs_set_base_hook(const bs_set_base_hook& ); - - //! <b>Effects</b>: Empty function. The argument is ignored. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Rationale</b>: Providing an assignment operator - //! makes classes using the hook STL-compliant without forcing the - //! user to do some additional work. \c swap can be used to emulate - //! move-semantics. - bs_set_base_hook& operator=(const bs_set_base_hook& ); - - //! <b>Effects</b>: If link_mode is \c normal_link, the destructor does - //! nothing (ie. no code is generated). If link_mode is \c safe_link and the - //! object is stored in a set an assertion is raised. If link_mode is - //! \c auto_unlink and \c is_linked() is true, the node is unlinked. - //! - //! <b>Throws</b>: Nothing. - ~bs_set_base_hook(); - - //! <b>Effects</b>: Swapping two nodes swaps the position of the elements - //! related to those nodes in one or two containers. That is, if the node - //! this is part of the element e1, the node x is part of the element e2 - //! and both elements are included in the containers s1 and s2, then after - //! the swap-operation e1 is in s2 at the position of e2 and e2 is in s1 - //! at the position of e1. If one element is not in a container, then - //! after the swap-operation the other element is not in a container. - //! Iterators to e1 and e2 related to those nodes are invalidated. - //! - //! <b>Complexity</b>: Constant - //! - //! <b>Throws</b>: Nothing. - void swap_nodes(bs_set_base_hook &other); - - //! <b>Precondition</b>: link_mode must be \c safe_link or \c auto_unlink. - //! - //! <b>Returns</b>: true, if the node belongs to a container, false - //! otherwise. This function can be used to test whether \c set::iterator_to - //! will return a valid iterator. - //! - //! <b>Complexity</b>: Constant - bool is_linked() const; - - //! <b>Effects</b>: Removes the node if it's inserted in a container. - //! This function is only allowed if link_mode is \c auto_unlink. - //! - //! <b>Throws</b>: Nothing. - void unlink(); - #endif -}; - -//! Helper metafunction to define a \c bs_set_member_hook that yields to the same -//! type when the same options (either explicitly or implicitly) are used. -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) || defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template<class ...Options> -#else -template<class O1 = none, class O2 = none, class O3 = none> -#endif -struct make_bs_set_member_hook -{ - /// @cond - typedef typename pack_options - #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) - < hook_defaults, O1, O2, O3> - #else - < hook_defaults, Options...> - #endif - - ::type packed_options; - - //Scapegoat trees can't be auto unlink trees - BOOST_STATIC_ASSERT(((int)packed_options::link_mode != (int)auto_unlink)); - - typedef detail::generic_hook - < get_bs_set_node_algo<typename packed_options::void_pointer> - , member_tag - , packed_options::link_mode - , detail::NoBaseHook - > implementation_defined; - /// @endcond - typedef implementation_defined type; -}; - -//! Put a public data member bs_set_member_hook in order to store objects of this class in -//! a bs_set/bs_multiset. bs_set_member_hook holds the data necessary for maintaining the -//! bs_set/bs_multiset and provides an appropriate value_traits class for bs_set/bs_multiset. -//! -//! The hook admits the following options: \c void_pointer<>, \c link_mode<>. -//! -//! \c void_pointer<> is the pointer type that will be used internally in the hook -//! and the the container configured to use this hook. -//! -//! \c link_mode<> will specify the linking mode of the hook (\c normal_link, -//! \c auto_unlink or \c safe_link). -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) || defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template<class ...Options> -#else -template<class O1, class O2, class O3> -#endif -class bs_set_member_hook - : public make_bs_set_member_hook - #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) - <O1, O2, O3> - #else - <Options...> - #endif - ::type -{ - #if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) - public: - //! <b>Effects</b>: If link_mode is \c auto_unlink or \c safe_link - //! initializes the node to an unlinked state. - //! - //! <b>Throws</b>: Nothing. - bs_set_member_hook(); - - //! <b>Effects</b>: If link_mode is \c auto_unlink or \c safe_link - //! initializes the node to an unlinked state. The argument is ignored. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Rationale</b>: Providing a copy-constructor - //! makes classes using the hook STL-compliant without forcing the - //! user to do some additional work. \c swap can be used to emulate - //! move-semantics. - bs_set_member_hook(const bs_set_member_hook& ); - - //! <b>Effects</b>: Empty function. The argument is ignored. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Rationale</b>: Providing an assignment operator - //! makes classes using the hook STL-compliant without forcing the - //! user to do some additional work. \c swap can be used to emulate - //! move-semantics. - bs_set_member_hook& operator=(const bs_set_member_hook& ); - - //! <b>Effects</b>: If link_mode is \c normal_link, the destructor does - //! nothing (ie. no code is generated). If link_mode is \c safe_link and the - //! object is stored in a set an assertion is raised. If link_mode is - //! \c auto_unlink and \c is_linked() is true, the node is unlinked. - //! - //! <b>Throws</b>: Nothing. - ~bs_set_member_hook(); - - //! <b>Effects</b>: Swapping two nodes swaps the position of the elements - //! related to those nodes in one or two containers. That is, if the node - //! this is part of the element e1, the node x is part of the element e2 - //! and both elements are included in the containers s1 and s2, then after - //! the swap-operation e1 is in s2 at the position of e2 and e2 is in s1 - //! at the position of e1. If one element is not in a container, then - //! after the swap-operation the other element is not in a container. - //! Iterators to e1 and e2 related to those nodes are invalidated. - //! - //! <b>Complexity</b>: Constant - //! - //! <b>Throws</b>: Nothing. - void swap_nodes(bs_set_member_hook &other); - - //! <b>Precondition</b>: link_mode must be \c safe_link or \c auto_unlink. - //! - //! <b>Returns</b>: true, if the node belongs to a container, false - //! otherwise. This function can be used to test whether \c set::iterator_to - //! will return a valid iterator. - //! - //! <b>Complexity</b>: Constant - bool is_linked() const; - - //! <b>Effects</b>: Removes the node if it's inserted in a container. - //! This function is only allowed if link_mode is \c auto_unlink. - //! - //! <b>Throws</b>: Nothing. - void unlink(); - #endif -}; - -} //namespace intrusive -} //namespace boost - -#include <boost/intrusive/detail/config_end.hpp> - -#endif //BOOST_INTRUSIVE_BS_SET_HOOK_HPP diff --git a/src/third_party/boost/boost/intrusive/circular_list_algorithms.hpp b/src/third_party/boost/boost/intrusive/circular_list_algorithms.hpp deleted file mode 100644 index c5de423b629..00000000000 --- a/src/third_party/boost/boost/intrusive/circular_list_algorithms.hpp +++ /dev/null @@ -1,413 +0,0 @@ -///////////////////////////////////////////////////////////////////////////// -// -// (C) Copyright Olaf Krzikalla 2004-2006. -// (C) Copyright Ion Gaztanaga 2006-2009 -// -// Distributed under the Boost Software License, Version 1.0. -// (See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) -// -// See http://www.boost.org/libs/intrusive for documentation. -// -///////////////////////////////////////////////////////////////////////////// - -#ifndef BOOST_INTRUSIVE_CIRCULAR_LIST_ALGORITHMS_HPP -#define BOOST_INTRUSIVE_CIRCULAR_LIST_ALGORITHMS_HPP - -#include <boost/intrusive/detail/config_begin.hpp> -#include <boost/intrusive/intrusive_fwd.hpp> -#include <cstddef> - -namespace boost { -namespace intrusive { - -//! circular_list_algorithms provides basic algorithms to manipulate nodes -//! forming a circular doubly linked list. An empty circular list is formed by a node -//! whose pointers point to itself. -//! -//! circular_list_algorithms is configured with a NodeTraits class, which encapsulates the -//! information about the node to be manipulated. NodeTraits must support the -//! following interface: -//! -//! <b>Typedefs</b>: -//! -//! <tt>node</tt>: The type of the node that forms the circular list -//! -//! <tt>node_ptr</tt>: A pointer to a node -//! -//! <tt>const_node_ptr</tt>: A pointer to a const node -//! -//! <b>Static functions</b>: -//! -//! <tt>static node_ptr get_previous(const_node_ptr n);</tt> -//! -//! <tt>static void set_previous(node_ptr n, node_ptr prev);</tt> -//! -//! <tt>static node_ptr get_next(const_node_ptr n);</tt> -//! -//! <tt>static void set_next(node_ptr n, node_ptr next);</tt> -template<class NodeTraits> -class circular_list_algorithms -{ - public: - typedef typename NodeTraits::node node; - typedef typename NodeTraits::node_ptr node_ptr; - typedef typename NodeTraits::const_node_ptr const_node_ptr; - typedef NodeTraits node_traits; - - //! <b>Effects</b>: Constructs an non-used list element, so that - //! inited(this_node) == true - //! - //! <b>Complexity</b>: Constant - //! - //! <b>Throws</b>: Nothing. - static void init(const node_ptr &this_node) - { - NodeTraits::set_next(this_node, node_ptr()); - NodeTraits::set_previous(this_node, node_ptr()); - } - - //! <b>Effects</b>: Returns true is "this_node" is in a non-used state - //! as if it was initialized by the "init" function. - //! - //! <b>Complexity</b>: Constant - //! - //! <b>Throws</b>: Nothing. - static bool inited(const const_node_ptr &this_node) - { return !NodeTraits::get_next(this_node); } - - //! <b>Effects</b>: Constructs an empty list, making this_node the only - //! node of the circular list: - //! <tt>NodeTraits::get_next(this_node) == NodeTraits::get_previous(this_node) - //! == this_node</tt>. - //! - //! <b>Complexity</b>: Constant - //! - //! <b>Throws</b>: Nothing. - static void init_header(const node_ptr &this_node) - { - NodeTraits::set_next(this_node, this_node); - NodeTraits::set_previous(this_node, this_node); - } - - - //! <b>Requires</b>: this_node must be in a circular list or be an empty circular list. - //! - //! <b>Effects</b>: Returns true is "this_node" is the only node of a circular list: - //! <tt>return NodeTraits::get_next(this_node) == this_node</tt> - //! - //! <b>Complexity</b>: Constant - //! - //! <b>Throws</b>: Nothing. - static bool unique(const const_node_ptr &this_node) - { - node_ptr next = NodeTraits::get_next(this_node); - return !next || next == this_node; - } - - //! <b>Requires</b>: this_node must be in a circular list or be an empty circular list. - //! - //! <b>Effects</b>: Returns the number of nodes in a circular list. If the circular list - //! is empty, returns 1. - //! - //! <b>Complexity</b>: Linear - //! - //! <b>Throws</b>: Nothing. - static std::size_t count(const const_node_ptr &this_node) - { - std::size_t result = 0; - const_node_ptr p = this_node; - do{ - p = NodeTraits::get_next(p); - ++result; - }while (p != this_node); - return result; - } - - //! <b>Requires</b>: this_node must be in a circular list or be an empty circular list. - //! - //! <b>Effects</b>: Unlinks the node from the circular list. - //! - //! <b>Complexity</b>: Constant - //! - //! <b>Throws</b>: Nothing. - static node_ptr unlink(const node_ptr &this_node) - { - node_ptr next(NodeTraits::get_next(this_node)); - if(next){ - node_ptr prev(NodeTraits::get_previous(this_node)); - NodeTraits::set_next(prev, next); - NodeTraits::set_previous(next, prev); - return next; - } - else{ - return this_node; - } - } - - //! <b>Requires</b>: b and e must be nodes of the same circular list or an empty range. - //! - //! <b>Effects</b>: Unlinks the node [b, e) from the circular list. - //! - //! <b>Complexity</b>: Constant - //! - //! <b>Throws</b>: Nothing. - static void unlink(const node_ptr &b, const node_ptr &e) - { - if (b != e) { - node_ptr prevb(NodeTraits::get_previous(b)); - NodeTraits::set_previous(e, prevb); - NodeTraits::set_next(prevb, e); - } - } - - //! <b>Requires</b>: nxt_node must be a node of a circular list. - //! - //! <b>Effects</b>: Links this_node before nxt_node in the circular list. - //! - //! <b>Complexity</b>: Constant - //! - //! <b>Throws</b>: Nothing. - static void link_before(const node_ptr &nxt_node, const node_ptr &this_node) - { - node_ptr prev(NodeTraits::get_previous(nxt_node)); - NodeTraits::set_previous(this_node, prev); - NodeTraits::set_next(this_node, nxt_node); - //nxt_node might be an alias for prev->next_ - //so use it before update it before NodeTraits::set_next(prev, ...) - //is called and the reference changes it's value - NodeTraits::set_previous(nxt_node, this_node); - NodeTraits::set_next(prev, this_node); - } - - //! <b>Requires</b>: prev_node must be a node of a circular list. - //! - //! <b>Effects</b>: Links this_node after prev_node in the circular list. - //! - //! <b>Complexity</b>: Constant - //! - //! <b>Throws</b>: Nothing. - static void link_after(const node_ptr &prev_node, const node_ptr &this_node) - { - node_ptr next(NodeTraits::get_next(prev_node)); - NodeTraits::set_previous(this_node, prev_node); - NodeTraits::set_next(this_node, next); - //prev_node might be an alias for next->next_ - //so use it before update it before NodeTraits::set_previous(next, ...) - //is called and the reference changes it's value - NodeTraits::set_next(prev_node, this_node); - NodeTraits::set_previous(next, this_node); - } - - //! <b>Requires</b>: this_node and other_node must be nodes inserted - //! in circular lists or be empty circular lists. - //! - //! <b>Effects</b>: Swaps the position of the nodes: this_node is inserted in - //! other_nodes position in the second circular list and the other_node is inserted - //! in this_node's position in the first circular list. - //! - //! <b>Complexity</b>: Constant - //! - //! <b>Throws</b>: Nothing. -/* - static void swap_nodes(const node_ptr &this_node, const node_ptr &other_node) - { - - if (other_node == this_node) - return; - bool empty1 = unique(this_node); - bool empty2 = unique(other_node); - - node_ptr next_this(NodeTraits::get_next(this_node)); - node_ptr prev_this(NodeTraits::get_previous(this_node)); - node_ptr next_other(NodeTraits::get_next(other_node)); - node_ptr prev_other(NodeTraits::get_previous(other_node)); - - //Do the swap - NodeTraits::set_next(this_node, next_other); - NodeTraits::set_next(other_node, next_this); - - NodeTraits::set_previous(this_node, prev_other); - NodeTraits::set_previous(other_node, prev_this); - - if (empty2){ - init(this_node); - } - else{ - NodeTraits::set_next(prev_other, this_node); - NodeTraits::set_previous(next_other, this_node); - } - if (empty1){ - init(other_node); - } - else{ - NodeTraits::set_next(prev_this, other_node); - NodeTraits::set_previous(next_this, other_node); - } - } -*/ - - //Watanabe version - private: - static void swap_prev(const node_ptr &this_node, const node_ptr &other_node) - { - node_ptr temp(NodeTraits::get_previous(this_node)); - NodeTraits::set_previous(this_node, NodeTraits::get_previous(other_node)); - NodeTraits::set_previous(other_node, temp); - } - static void swap_next(const node_ptr &this_node, const node_ptr &other_node) - { - node_ptr temp(NodeTraits::get_next(this_node)); - NodeTraits::set_next(this_node, NodeTraits::get_next(other_node)); - NodeTraits::set_next(other_node, temp); - } - - public: - static void swap_nodes(const node_ptr &this_node, const node_ptr &other_node) - { - if (other_node == this_node) - return; - bool this_inited = inited(this_node); - bool other_inited = inited(other_node); - if(this_inited){ - init_header(this_node); - } - if(other_inited){ - init_header(other_node); - } - - node_ptr next_this(NodeTraits::get_next(this_node)); - node_ptr prev_this(NodeTraits::get_previous(this_node)); - node_ptr next_other(NodeTraits::get_next(other_node)); - node_ptr prev_other(NodeTraits::get_previous(other_node)); - //these first two swaps must happen before the other two - swap_prev(next_this, next_other); - swap_next(prev_this, prev_other); - swap_next(this_node, other_node); - swap_prev(this_node, other_node); - - if(this_inited){ - init(other_node); - } - if(other_inited){ - init(this_node); - } - } - - //! <b>Requires</b>: b and e must be nodes of the same circular list or an empty range. - //! and p must be a node of a different circular list or may not be an iterator in - // [b, e). - //! - //! <b>Effects</b>: Removes the nodes from [b, e) range from their circular list and inserts - //! them before p in p's circular list. - //! - //! <b>Complexity</b>: Constant - //! - //! <b>Throws</b>: Nothing. - static void transfer(const node_ptr &p, const node_ptr &b, const node_ptr &e) - { - if (b != e) { - node_ptr prev_p(NodeTraits::get_previous(p)); - node_ptr prev_b(NodeTraits::get_previous(b)); - node_ptr prev_e(NodeTraits::get_previous(e)); - NodeTraits::set_next(prev_e, p); - NodeTraits::set_previous(p, prev_e); - NodeTraits::set_next(prev_b, e); - NodeTraits::set_previous(e, prev_b); - NodeTraits::set_next(prev_p, b); - NodeTraits::set_previous(b, prev_p); - } - } - - //! <b>Requires</b>: i must a node of a circular list - //! and p must be a node of a different circular list. - //! - //! <b>Effects</b>: Removes the node i from its circular list and inserts - //! it before p in p's circular list. - //! If p == i or p == NodeTraits::get_next(i), this function is a null operation. - //! - //! <b>Complexity</b>: Constant - //! - //! <b>Throws</b>: Nothing. - static void transfer(const node_ptr &p, const node_ptr &i) - { - node_ptr n(NodeTraits::get_next(i)); - if(n != p && i != p){ - node_ptr prev_p(NodeTraits::get_previous(p)); - node_ptr prev_i(NodeTraits::get_previous(i)); - NodeTraits::set_next(prev_p, i); - NodeTraits::set_previous(i, prev_p); - NodeTraits::set_next(i, p); - NodeTraits::set_previous(p, i); - NodeTraits::set_previous(n, prev_i); - NodeTraits::set_next(prev_i, n); - - } - } - - //! <b>Effects</b>: Reverses the order of elements in the list. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: This function is linear time. - static void reverse(const node_ptr &p) - { - node_ptr f(NodeTraits::get_next(p)); - node_ptr i(NodeTraits::get_next(f)), e(p); - - while(i != e) { - node_ptr n = i; - i = NodeTraits::get_next(i); - transfer(f, n, i); - f = n; - } - } - - //! <b>Effects</b>: Moves the node p n positions towards the end of the list. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Linear to the number of moved positions. - static void move_backwards(const node_ptr &p, std::size_t n) - { - //Null shift, nothing to do - if(!n) return; - node_ptr first = NodeTraits::get_next(p); - //size() == 0 or 1, nothing to do - if(first == NodeTraits::get_previous(p)) return; - unlink(p); - //Now get the new first node - while(n--){ - first = NodeTraits::get_next(first); - } - link_before(first, p); - } - - //! <b>Effects</b>: Moves the node p n positions towards the beginning of the list. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Linear to the number of moved positions. - static void move_forward(const node_ptr &p, std::size_t n) - { - //Null shift, nothing to do - if(!n) return; - node_ptr last = NodeTraits::get_previous(p); - //size() == 0 or 1, nothing to do - if(last == NodeTraits::get_next(p)) return; - - unlink(p); - //Now get the new last node - while(n--){ - last = NodeTraits::get_previous(last); - } - link_after(last, p); - } -}; - -} //namespace intrusive -} //namespace boost - -#include <boost/intrusive/detail/config_end.hpp> - -#endif //BOOST_INTRUSIVE_CIRCULAR_LIST_ALGORITHMS_HPP diff --git a/src/third_party/boost/boost/intrusive/circular_slist_algorithms.hpp b/src/third_party/boost/boost/intrusive/circular_slist_algorithms.hpp deleted file mode 100644 index b843590c153..00000000000 --- a/src/third_party/boost/boost/intrusive/circular_slist_algorithms.hpp +++ /dev/null @@ -1,405 +0,0 @@ -///////////////////////////////////////////////////////////////////////////// -// -// (C) Copyright Olaf Krzikalla 2004-2006. -// (C) Copyright Ion Gaztanaga 2006-2009 -// -// Distributed under the Boost Software License, Version 1.0. -// (See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) -// -// See http://www.boost.org/libs/intrusive for documentation. -// -///////////////////////////////////////////////////////////////////////////// - -#ifndef BOOST_INTRUSIVE_CIRCULAR_SLIST_ALGORITHMS_HPP -#define BOOST_INTRUSIVE_CIRCULAR_SLIST_ALGORITHMS_HPP - -#include <boost/intrusive/detail/config_begin.hpp> -#include <boost/intrusive/intrusive_fwd.hpp> -#include <boost/intrusive/detail/common_slist_algorithms.hpp> -#include <boost/intrusive/detail/assert.hpp> -#include <cstddef> - -namespace boost { -namespace intrusive { - -//! circular_slist_algorithms provides basic algorithms to manipulate nodes -//! forming a circular singly linked list. An empty circular list is formed by a node -//! whose pointer to the next node points to itself. -//! -//! circular_slist_algorithms is configured with a NodeTraits class, which encapsulates the -//! information about the node to be manipulated. NodeTraits must support the -//! following interface: -//! -//! <b>Typedefs</b>: -//! -//! <tt>node</tt>: The type of the node that forms the circular list -//! -//! <tt>node_ptr</tt>: A pointer to a node -//! -//! <tt>const_node_ptr</tt>: A pointer to a const node -//! -//! <b>Static functions</b>: -//! -//! <tt>static node_ptr get_next(const_node_ptr n);</tt> -//! -//! <tt>static void set_next(node_ptr n, node_ptr next);</tt> -template<class NodeTraits> -class circular_slist_algorithms - /// @cond - : public detail::common_slist_algorithms<NodeTraits> - /// @endcond -{ - /// @cond - typedef detail::common_slist_algorithms<NodeTraits> base_t; - /// @endcond - public: - typedef typename NodeTraits::node node; - typedef typename NodeTraits::node_ptr node_ptr; - typedef typename NodeTraits::const_node_ptr const_node_ptr; - typedef NodeTraits node_traits; - - #if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) - - //! <b>Effects</b>: Constructs an non-used list element, putting the next - //! pointer to null: - //! <tt>NodeTraits::get_next(this_node) == node_ptr()</tt> - //! - //! <b>Complexity</b>: Constant - //! - //! <b>Throws</b>: Nothing. - static void init(node_ptr this_node); - - //! <b>Requires</b>: this_node must be in a circular list or be an empty circular list. - //! - //! <b>Effects</b>: Returns true is "this_node" is the only node of a circular list: - //! or it's a not inserted node: - //! <tt>return node_ptr() == NodeTraits::get_next(this_node) || NodeTraits::get_next(this_node) == this_node</tt> - //! - //! <b>Complexity</b>: Constant - //! - //! <b>Throws</b>: Nothing. - static bool unique(const_node_ptr this_node); - - //! <b>Effects</b>: Returns true is "this_node" has the same state as - //! if it was inited using "init(node_ptr)" - //! - //! <b>Complexity</b>: Constant - //! - //! <b>Throws</b>: Nothing. - static bool inited(const_node_ptr this_node); - - //! <b>Requires</b>: prev_node must be in a circular list or be an empty circular list. - //! - //! <b>Effects</b>: Unlinks the next node of prev_node from the circular list. - //! - //! <b>Complexity</b>: Constant - //! - //! <b>Throws</b>: Nothing. - static void unlink_after(node_ptr prev_node); - - //! <b>Requires</b>: prev_node and last_node must be in a circular list - //! or be an empty circular list. - //! - //! <b>Effects</b>: Unlinks the range (prev_node, last_node) from the circular list. - //! - //! <b>Complexity</b>: Constant - //! - //! <b>Throws</b>: Nothing. - static void unlink_after(node_ptr prev_node, node_ptr last_node); - - //! <b>Requires</b>: prev_node must be a node of a circular list. - //! - //! <b>Effects</b>: Links this_node after prev_node in the circular list. - //! - //! <b>Complexity</b>: Constant - //! - //! <b>Throws</b>: Nothing. - static void link_after(node_ptr prev_node, node_ptr this_node); - - //! <b>Requires</b>: b and e must be nodes of the same circular list or an empty range. - //! and p must be a node of a different circular list. - //! - //! <b>Effects</b>: Removes the nodes from (b, e] range from their circular list and inserts - //! them after p in p's circular list. - //! - //! <b>Complexity</b>: Constant - //! - //! <b>Throws</b>: Nothing. - static void transfer_after(node_ptr p, node_ptr b, node_ptr e); - - #endif //#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) - - //! <b>Effects</b>: Constructs an empty list, making this_node the only - //! node of the circular list: - //! <tt>NodeTraits::get_next(this_node) == this_node</tt>. - //! - //! <b>Complexity</b>: Constant - //! - //! <b>Throws</b>: Nothing. - static void init_header(const node_ptr &this_node) - { NodeTraits::set_next(this_node, this_node); } - - //! <b>Requires</b>: this_node and prev_init_node must be in the same circular list. - //! - //! <b>Effects</b>: Returns the previous node of this_node in the circular list starting. - //! the search from prev_init_node. The first node checked for equality - //! is NodeTraits::get_next(prev_init_node). - //! - //! <b>Complexity</b>: Linear to the number of elements between prev_init_node and this_node. - //! - //! <b>Throws</b>: Nothing. - static node_ptr get_previous_node(const node_ptr &prev_init_node, const node_ptr &this_node) - { return base_t::get_previous_node(prev_init_node, this_node); } - - //! <b>Requires</b>: this_node must be in a circular list or be an empty circular list. - //! - //! <b>Effects</b>: Returns the previous node of this_node in the circular list. - //! - //! <b>Complexity</b>: Linear to the number of elements in the circular list. - //! - //! <b>Throws</b>: Nothing. - static node_ptr get_previous_node(const node_ptr & this_node) - { return base_t::get_previous_node(this_node, this_node); } - - //! <b>Requires</b>: this_node must be in a circular list or be an empty circular list. - //! - //! <b>Effects</b>: Returns the previous node of the previous node of this_node in the circular list. - //! - //! <b>Complexity</b>: Linear to the number of elements in the circular list. - //! - //! <b>Throws</b>: Nothing. - static node_ptr get_previous_previous_node(const node_ptr & this_node) - { return get_previous_previous_node(this_node, this_node); } - - //! <b>Requires</b>: this_node and prev_prev_init_node must be in the same circular list. - //! - //! <b>Effects</b>: Returns the previous node of the previous node of this_node in the - //! circular list starting. the search from prev_init_node. The first node checked - //! for equality is NodeTraits::get_next((NodeTraits::get_next(prev_prev_init_node)). - //! - //! <b>Complexity</b>: Linear to the number of elements in the circular list. - //! - //! <b>Throws</b>: Nothing. - static node_ptr get_previous_previous_node(const node_ptr & prev_prev_init_node, const node_ptr & this_node) - { - node_ptr p = prev_prev_init_node; - node_ptr p_next = NodeTraits::get_next(p); - node_ptr p_next_next = NodeTraits::get_next(p_next); - while (this_node != p_next_next){ - p = p_next; - p_next = p_next_next; - p_next_next = NodeTraits::get_next(p_next); - } - return p; - } - - //! <b>Requires</b>: this_node must be in a circular list or be an empty circular list. - //! - //! <b>Effects</b>: Returns the number of nodes in a circular list. If the circular list - //! is empty, returns 1. - //! - //! <b>Complexity</b>: Linear - //! - //! <b>Throws</b>: Nothing. - static std::size_t count(const const_node_ptr & this_node) - { - std::size_t result = 0; - const_node_ptr p = this_node; - do{ - p = NodeTraits::get_next(p); - ++result; - } while (p != this_node); - return result; - } - - //! <b>Requires</b>: this_node must be in a circular list, be an empty circular list or be inited. - //! - //! <b>Effects</b>: Unlinks the node from the circular list. - //! - //! <b>Complexity</b>: Linear to the number of elements in the circular list - //! - //! <b>Throws</b>: Nothing. - static void unlink(const node_ptr & this_node) - { - if(NodeTraits::get_next(this_node)) - base_t::unlink_after(get_previous_node(this_node)); - } - - //! <b>Requires</b>: nxt_node must be a node of a circular list. - //! - //! <b>Effects</b>: Links this_node before nxt_node in the circular list. - //! - //! <b>Complexity</b>: Linear to the number of elements in the circular list. - //! - //! <b>Throws</b>: Nothing. - static void link_before (const node_ptr & nxt_node, const node_ptr & this_node) - { base_t::link_after(get_previous_node(nxt_node), this_node); } - - //! <b>Requires</b>: this_node and other_node must be nodes inserted - //! in circular lists or be empty circular lists. - //! - //! <b>Effects</b>: Swaps the position of the nodes: this_node is inserted in - //! other_nodes position in the second circular list and the other_node is inserted - //! in this_node's position in the first circular list. - //! - //! <b>Complexity</b>: Linear to number of elements of both lists - //! - //! <b>Throws</b>: Nothing. - static void swap_nodes(const node_ptr & this_node, const node_ptr & other_node) - { - if (other_node == this_node) - return; - bool this_inited = base_t::inited(this_node); - bool other_inited = base_t::inited(other_node); - if(this_inited){ - base_t::init_header(this_node); - } - if(other_inited){ - base_t::init_header(other_node); - } - - bool empty1 = base_t::unique(this_node); - bool empty2 = base_t::unique(other_node); - node_ptr prev_this (get_previous_node(this_node)); - node_ptr prev_other(get_previous_node(other_node)); - - node_ptr this_next (NodeTraits::get_next(this_node)); - node_ptr other_next(NodeTraits::get_next(other_node)); - NodeTraits::set_next(this_node, other_next); - NodeTraits::set_next(other_node, this_next); - NodeTraits::set_next(empty1 ? other_node : prev_this, other_node); - NodeTraits::set_next(empty2 ? this_node : prev_other, this_node); - - if(this_inited){ - base_t::init(other_node); - } - if(other_inited){ - base_t::init(this_node); - } - } - - //! <b>Effects</b>: Reverses the order of elements in the list. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: This function is linear to the contained elements. - static void reverse(const node_ptr & p) - { - node_ptr i = NodeTraits::get_next(p), e(p); - for (;;) { - node_ptr nxt(NodeTraits::get_next(i)); - if (nxt == e) - break; - base_t::transfer_after(e, i, nxt); - } - } - - //! <b>Effects</b>: Moves the node p n positions towards the end of the list. - //! - //! <b>Returns</b>: The previous node of p after the function if there has been any movement, - //! Null if n leads to no movement. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Linear to the number of elements plus the number moved positions. - static node_ptr move_backwards(const node_ptr & p, std::size_t n) - { - //Null shift, nothing to do - if(!n) return node_ptr(); - node_ptr first = NodeTraits::get_next(p); - - //count() == 1 or 2, nothing to do - if(NodeTraits::get_next(first) == p) - return node_ptr(); - - bool end_found = false; - node_ptr new_last = node_ptr(); - - //Now find the new last node according to the shift count. - //If we find p before finding the new last node - //unlink p, shortcut the search now that we know the size of the list - //and continue. - for(std::size_t i = 1; i <= n; ++i){ - new_last = first; - first = NodeTraits::get_next(first); - if(first == p){ - //Shortcut the shift with the modulo of the size of the list - n %= i; - if(!n) - return node_ptr(); - i = 0; - //Unlink p and continue the new first node search - first = NodeTraits::get_next(p); - base_t::unlink_after(new_last); - end_found = true; - } - } - - //If the p has not been found in the previous loop, find it - //starting in the new first node and unlink it - if(!end_found){ - base_t::unlink_after(base_t::get_previous_node(first, p)); - } - - //Now link p after the new last node - base_t::link_after(new_last, p); - return new_last; - } - - //! <b>Effects</b>: Moves the node p n positions towards the beginning of the list. - //! - //! <b>Returns</b>: The previous node of p after the function if there has been any movement, - //! Null if n leads equals to no movement. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Linear to the number of elements plus the number moved positions. - static node_ptr move_forward(const node_ptr & p, std::size_t n) - { - //Null shift, nothing to do - if(!n) return node_ptr(); - node_ptr first = node_traits::get_next(p); - - //count() == 1 or 2, nothing to do - if(node_traits::get_next(first) == p) return node_ptr(); - - //Iterate until p is found to know where the current last node is. - //If the shift count is less than the size of the list, we can also obtain - //the position of the new last node after the shift. - node_ptr old_last(first), next_to_it, new_last(p); - std::size_t distance = 1; - while(p != (next_to_it = node_traits::get_next(old_last))){ - if(++distance > n) - new_last = node_traits::get_next(new_last); - old_last = next_to_it; - } - //If the shift was bigger or equal than the size, obtain the equivalent - //forward shifts and find the new last node. - if(distance <= n){ - //Now find the equivalent forward shifts. - //Shortcut the shift with the modulo of the size of the list - std::size_t new_before_last_pos = (distance - (n % distance))% distance; - //If the shift is a multiple of the size there is nothing to do - if(!new_before_last_pos) return node_ptr(); - - for( new_last = p - ; new_before_last_pos-- - ; new_last = node_traits::get_next(new_last)){ - //empty - } - } - - //Now unlink p and link it after the new last node - base_t::unlink_after(old_last); - base_t::link_after(new_last, p); - return new_last; - } -}; - -} //namespace intrusive -} //namespace boost - -#include <boost/intrusive/detail/config_end.hpp> - -#endif //BOOST_INTRUSIVE_CIRCULAR_SLIST_ALGORITHMS_HPP diff --git a/src/third_party/boost/boost/intrusive/derivation_value_traits.hpp b/src/third_party/boost/boost/intrusive/derivation_value_traits.hpp deleted file mode 100644 index 38c5aa57cfe..00000000000 --- a/src/third_party/boost/boost/intrusive/derivation_value_traits.hpp +++ /dev/null @@ -1,70 +0,0 @@ -///////////////////////////////////////////////////////////////////////////// -// -// (C) Copyright Ion Gaztanaga 2006-2009 -// -// Distributed under the Boost Software License, Version 1.0. -// (See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) -// -// See http://www.boost.org/libs/intrusive for documentation. -// -///////////////////////////////////////////////////////////////////////////// - -#ifndef BOOST_INTRUSIVE_DERIVATION_VALUE_TRAITS_HPP -#define BOOST_INTRUSIVE_DERIVATION_VALUE_TRAITS_HPP - -#include <boost/intrusive/link_mode.hpp> -#include <boost/pointer_cast.hpp> -#include <boost/pointer_to_other.hpp> -#include <iterator> - -namespace boost { -namespace intrusive { - -//!This value traits template is used to create value traits -//!from user defined node traits where value_traits::value_type will -//!derive from node_traits::node -template<class T, class NodeTraits, link_mode_type LinkMode = safe_link> -struct derivation_value_traits -{ - public: - typedef NodeTraits node_traits; - typedef T value_type; - typedef typename node_traits::node node; - typedef typename node_traits::node_ptr node_ptr; - typedef typename node_traits::const_node_ptr const_node_ptr; - typedef typename boost::pointer_to_other<node_ptr, T>::type pointer; - typedef typename boost::pointer_to_other<node_ptr, const T>::type const_pointer; - typedef typename boost::intrusive:: - pointer_traits<pointer>::reference reference; - typedef typename boost::intrusive:: - pointer_traits<const_pointer>::reference const_reference; - static const link_mode_type link_mode = LinkMode; - - static node_ptr to_node_ptr(reference value) - { return node_ptr(&value); } - - static const_node_ptr to_node_ptr(const_reference value) - { return node_ptr(&value); } - - static pointer to_value_ptr(const node_ptr &n) - { -// This still fails in gcc < 4.4 so forget about it -// using ::boost::static_pointer_cast; -// return static_pointer_cast<value_type>(n)); - return pointer(&static_cast<value_type&>(*n)); - } - - static const_pointer to_value_ptr(const const_node_ptr &n) - { -// This still fails in gcc < 4.4 so forget about it -// using ::boost::static_pointer_cast; -// return static_pointer_cast<const value_type>(n)); - return const_pointer(&static_cast<const value_type&>(*n)); - } -}; - -} //namespace intrusive -} //namespace boost - -#endif //BOOST_INTRUSIVE_DERIVATION_VALUE_TRAITS_HPP diff --git a/src/third_party/boost/boost/intrusive/detail/any_node_and_algorithms.hpp b/src/third_party/boost/boost/intrusive/detail/any_node_and_algorithms.hpp deleted file mode 100644 index bda9ad3c45a..00000000000 --- a/src/third_party/boost/boost/intrusive/detail/any_node_and_algorithms.hpp +++ /dev/null @@ -1,297 +0,0 @@ -///////////////////////////////////////////////////////////////////////////// -// -// (C) Copyright Ion Gaztanaga 2006-2009 -// -// Distributed under the Boost Software License, Version 1.0. -// (See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) -// -// See http://www.boost.org/libs/intrusive for documentation. -// -///////////////////////////////////////////////////////////////////////////// - -#ifndef BOOST_INTRUSIVE_ANY_NODE_HPP -#define BOOST_INTRUSIVE_ANY_NODE_HPP - -#include <boost/intrusive/detail/config_begin.hpp> -#include <iterator> -#include <boost/intrusive/detail/assert.hpp> -#include <boost/intrusive/pointer_traits.hpp> -#include <cstddef> -#include <boost/intrusive/detail/mpl.hpp> -#include <boost/pointer_cast.hpp> - -namespace boost { -namespace intrusive { - -template<class VoidPointer> -struct any_node -{ - typedef typename pointer_traits - <VoidPointer>::template rebind_pointer<any_node>::type node_ptr; - node_ptr node_ptr_1; - node_ptr node_ptr_2; - node_ptr node_ptr_3; - std::size_t size_t_1; -}; - -template<class VoidPointer> -struct any_list_node_traits -{ - typedef any_node<VoidPointer> node; - typedef typename pointer_traits - <VoidPointer>::template rebind_pointer<node>::type node_ptr; - typedef typename pointer_traits - <VoidPointer>::template rebind_pointer<const node>::type const_node_ptr; - - static const node_ptr &get_next(const const_node_ptr & n) - { return n->node_ptr_1; } - - static void set_next(const node_ptr & n, const node_ptr & next) - { n->node_ptr_1 = next; } - - static const node_ptr &get_previous(const const_node_ptr & n) - { return n->node_ptr_2; } - - static void set_previous(const node_ptr & n, const node_ptr & prev) - { n->node_ptr_2 = prev; } -}; - - -template<class VoidPointer> -struct any_slist_node_traits -{ - typedef any_node<VoidPointer> node; - typedef typename pointer_traits - <VoidPointer>::template rebind_pointer<node>::type node_ptr; - typedef typename pointer_traits - <VoidPointer>::template rebind_pointer<const node>::type const_node_ptr; - - static const node_ptr &get_next(const const_node_ptr & n) - { return n->node_ptr_1; } - - static void set_next(const node_ptr & n, const node_ptr & next) - { n->node_ptr_1 = next; } -}; - - -template<class VoidPointer> -struct any_unordered_node_traits - : public any_slist_node_traits<VoidPointer> -{ - typedef any_slist_node_traits<VoidPointer> reduced_slist_node_traits; - typedef typename reduced_slist_node_traits::node node; - typedef typename reduced_slist_node_traits::node_ptr node_ptr; - typedef typename reduced_slist_node_traits::const_node_ptr const_node_ptr; - - static const bool store_hash = true; - static const bool optimize_multikey = true; - - static const node_ptr &get_next(const const_node_ptr & n) - { return n->node_ptr_1; } - - static void set_next(const node_ptr & n, const node_ptr & next) - { n->node_ptr_1 = next; } - - static node_ptr get_prev_in_group(const const_node_ptr & n) - { return n->node_ptr_2; } - - static void set_prev_in_group(const node_ptr & n, const node_ptr & prev) - { n->node_ptr_2 = prev; } - - static std::size_t get_hash(const const_node_ptr & n) - { return n->size_t_1; } - - static void set_hash(const node_ptr & n, std::size_t h) - { n->size_t_1 = h; } -}; - - -template<class VoidPointer> -struct any_rbtree_node_traits -{ - typedef any_node<VoidPointer> node; - - typedef typename pointer_traits - <VoidPointer>::template rebind_pointer<node>::type node_ptr; - typedef typename pointer_traits - <VoidPointer>::template rebind_pointer<const node>::type const_node_ptr; - - typedef std::size_t color; - - static const node_ptr &get_parent(const const_node_ptr & n) - { return n->node_ptr_1; } - - static void set_parent(const node_ptr & n, const node_ptr & p) - { n->node_ptr_1 = p; } - - static const node_ptr &get_left(const const_node_ptr & n) - { return n->node_ptr_2; } - - static void set_left(const node_ptr & n, const node_ptr & l) - { n->node_ptr_2 = l; } - - static const node_ptr &get_right(const const_node_ptr & n) - { return n->node_ptr_3; } - - static void set_right(const node_ptr & n, const node_ptr & r) - { n->node_ptr_3 = r; } - - static color get_color(const const_node_ptr & n) - { return n->size_t_1; } - - static void set_color(const node_ptr & n, color c) - { n->size_t_1 = c; } - - static color black() - { return 0u; } - - static color red() - { return 1u; } -}; - - -template<class VoidPointer> -struct any_avltree_node_traits -{ - typedef any_node<VoidPointer> node; - - typedef typename pointer_traits - <VoidPointer>::template rebind_pointer<node>::type node_ptr; - typedef typename pointer_traits - <VoidPointer>::template rebind_pointer<const node>::type const_node_ptr; - typedef std::size_t balance; - - static const node_ptr &get_parent(const const_node_ptr & n) - { return n->node_ptr_1; } - - static void set_parent(const node_ptr & n, const node_ptr & p) - { n->node_ptr_1 = p; } - - static const node_ptr &get_left(const const_node_ptr & n) - { return n->node_ptr_2; } - - static void set_left(const node_ptr & n, const node_ptr & l) - { n->node_ptr_2 = l; } - - static const node_ptr &get_right(const const_node_ptr & n) - { return n->node_ptr_3; } - - static void set_right(const node_ptr & n, const node_ptr & r) - { n->node_ptr_3 = r; } - - static balance get_balance(const const_node_ptr & n) - { return n->size_t_1; } - - static void set_balance(const node_ptr & n, balance b) - { n->size_t_1 = b; } - - static balance negative() - { return 0u; } - - static balance zero() - { return 1u; } - - static balance positive() - { return 2u; } -}; - - -template<class VoidPointer> -struct any_tree_node_traits -{ - typedef any_node<VoidPointer> node; - - typedef typename pointer_traits - <VoidPointer>::template rebind_pointer<node>::type node_ptr; - typedef typename pointer_traits - <VoidPointer>::template rebind_pointer<const node>::type const_node_ptr; - - static const node_ptr &get_parent(const const_node_ptr & n) - { return n->node_ptr_1; } - - static void set_parent(const node_ptr & n, const node_ptr & p) - { n->node_ptr_1 = p; } - - static const node_ptr &get_left(const const_node_ptr & n) - { return n->node_ptr_2; } - - static void set_left(const node_ptr & n, const node_ptr & l) - { n->node_ptr_2 = l; } - - static const node_ptr &get_right(const const_node_ptr & n) - { return n->node_ptr_3; } - - static void set_right(const node_ptr & n, const node_ptr & r) - { n->node_ptr_3 = r; } -}; - -template<class VoidPointer> -class any_node_traits -{ - public: - typedef any_node<VoidPointer> node; - typedef typename pointer_traits - <VoidPointer>::template rebind_pointer<node>::type node_ptr; - typedef typename pointer_traits - <VoidPointer>::template rebind_pointer<const node>::type const_node_ptr; -}; - -template<class VoidPointer> -class any_algorithms -{ - template <class T> - static void function_not_available_for_any_hooks(typename detail::enable_if<detail::is_same<T, bool> >::type) - {} - - public: - typedef any_node<VoidPointer> node; - typedef typename pointer_traits - <VoidPointer>::template rebind_pointer<node>::type node_ptr; - typedef typename pointer_traits - <VoidPointer>::template rebind_pointer<const node>::type const_node_ptr; - typedef any_node_traits<VoidPointer> node_traits; - - //! <b>Requires</b>: node must not be part of any tree. - //! - //! <b>Effects</b>: After the function unique(node) == true. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Nodes</b>: If node is inserted in a tree, this function corrupts the tree. - static void init(const node_ptr & node) - { node->node_ptr_1 = 0; }; - - //! <b>Effects</b>: Returns true if node is in the same state as if called init(node) - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - static bool inited(const const_node_ptr & node) - { return !node->node_ptr_1; }; - - static bool unique(const const_node_ptr & node) - { return 0 == node->node_ptr_1; } - - static void unlink(const node_ptr &) - { - //Auto-unlink hooks and unlink() are not available for any hooks - any_algorithms<VoidPointer>::template function_not_available_for_any_hooks<node_ptr>(); - } - - static void swap_nodes(const node_ptr & l, const node_ptr & r) - { - //Any nodes have no swap_nodes capability because they don't know - //what algorithm they must use to unlink the node from the container - any_algorithms<VoidPointer>::template function_not_available_for_any_hooks<node_ptr>(); - } -}; - -} //namespace intrusive -} //namespace boost - -#include <boost/intrusive/detail/config_end.hpp> - -#endif //BOOST_INTRUSIVE_ANY_NODE_HPP diff --git a/src/third_party/boost/boost/intrusive/detail/assert.hpp b/src/third_party/boost/boost/intrusive/detail/assert.hpp deleted file mode 100644 index cfe392bfb08..00000000000 --- a/src/third_party/boost/boost/intrusive/detail/assert.hpp +++ /dev/null @@ -1,41 +0,0 @@ -///////////////////////////////////////////////////////////////////////////// -// -// (C) Copyright Ion Gaztanaga 2006-2009 -// -// Distributed under the Boost Software License, Version 1.0. -// (See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) -// -// See http://www.boost.org/libs/intrusive for documentation. -// -///////////////////////////////////////////////////////////////////////////// - -#ifndef BOOST_INTRUSIVE_DETAIL_ASSERT_HPP -#define BOOST_INTRUSIVE_DETAIL_ASSERT_HPP - -#if defined(_MSC_VER)&&(_MSC_VER>=1200) -#pragma once -#endif - -#if !defined(BOOST_INTRUSIVE_INVARIANT_ASSERT) - #include <boost/assert.hpp> - #define BOOST_INTRUSIVE_INVARIANT_ASSERT BOOST_ASSERT -#elif defined(BOOST_INTRUSIVE_INVARIANT_ASSERT_INCLUDE) - #include BOOST_INTRUSIVE_INVARIANT_ASSERT_INCLUDE -#endif - -#if !defined(BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT) - #include <boost/assert.hpp> - #define BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT BOOST_ASSERT -#elif defined(BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT_INCLUDE) - #include BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT_INCLUDE -#endif - -#if !defined(BOOST_INTRUSIVE_SAFE_HOOK_DESTRUCTOR_ASSERT) - #include <boost/assert.hpp> - #define BOOST_INTRUSIVE_SAFE_HOOK_DESTRUCTOR_ASSERT BOOST_ASSERT -#elif defined(BOOST_INTRUSIVE_SAFE_HOOK_DESTRUCTOR_ASSERT_INCLUDE) - #include BOOST_INTRUSIVE_SAFE_HOOK_DESTRUCTOR_ASSERT_INCLUDE -#endif - -#endif //BOOST_INTRUSIVE_DETAIL_ASSERT_HPP diff --git a/src/third_party/boost/boost/intrusive/detail/avltree_node.hpp b/src/third_party/boost/boost/intrusive/detail/avltree_node.hpp deleted file mode 100644 index dc600e6695f..00000000000 --- a/src/third_party/boost/boost/intrusive/detail/avltree_node.hpp +++ /dev/null @@ -1,185 +0,0 @@ -///////////////////////////////////////////////////////////////////////////// -// -// (C) Copyright Ion Gaztanaga 2007. -// -// Distributed under the Boost Software License, Version 1.0. -// (See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) -// -// See http://www.boost.org/libs/intrusive for documentation. -// -///////////////////////////////////////////////////////////////////////////// - -#ifndef BOOST_INTRUSIVE_AVLTREE_NODE_HPP -#define BOOST_INTRUSIVE_AVLTREE_NODE_HPP - -#include <boost/intrusive/detail/config_begin.hpp> -#include <iterator> -#include <boost/intrusive/pointer_traits.hpp> -#include <boost/intrusive/avltree_algorithms.hpp> -#include <boost/intrusive/pointer_plus_bits.hpp> -#include <boost/intrusive/detail/mpl.hpp> - -namespace boost { -namespace intrusive { - -///////////////////////////////////////////////////////////////////////////// -// // -// Generic node_traits for any pointer type // -// // -///////////////////////////////////////////////////////////////////////////// - -//This is the compact representation: 3 pointers -template<class VoidPointer> -struct compact_avltree_node -{ - typedef typename pointer_traits - <VoidPointer>::template rebind_pointer - <compact_avltree_node<VoidPointer> >::type node_ptr; - enum balance { negative_t, zero_t, positive_t }; - node_ptr parent_, left_, right_; -}; - -//This is the normal representation: 3 pointers + enum -template<class VoidPointer> -struct avltree_node -{ - typedef typename pointer_traits - <VoidPointer>::template rebind_pointer - <avltree_node<VoidPointer> >::type node_ptr; - enum balance { negative_t, zero_t, positive_t }; - node_ptr parent_, left_, right_; - balance balance_; -}; - -//This is the default node traits implementation -//using a node with 3 generic pointers plus an enum -template<class VoidPointer> -struct default_avltree_node_traits_impl -{ - typedef avltree_node<VoidPointer> node; - - typedef typename pointer_traits - <VoidPointer>::template rebind_pointer - <node>::type node_ptr; - typedef typename pointer_traits - <VoidPointer>::template rebind_pointer - <const node>::type const_node_ptr; - - typedef typename node::balance balance; - - static const node_ptr & get_parent(const const_node_ptr & n) - { return n->parent_; } - - static void set_parent(const node_ptr & n, const node_ptr & p) - { n->parent_ = p; } - - static const node_ptr & get_left(const const_node_ptr & n) - { return n->left_; } - - static void set_left(const node_ptr & n, const node_ptr & l) - { n->left_ = l; } - - static const node_ptr & get_right(const const_node_ptr & n) - { return n->right_; } - - static void set_right(const node_ptr & n, const node_ptr & r) - { n->right_ = r; } - - static balance get_balance(const const_node_ptr & n) - { return n->balance_; } - - static void set_balance(const node_ptr & n, balance b) - { n->balance_ = b; } - - static balance negative() - { return node::negative_t; } - - static balance zero() - { return node::zero_t; } - - static balance positive() - { return node::positive_t; } -}; - -//This is the compact node traits implementation -//using a node with 3 generic pointers -template<class VoidPointer> -struct compact_avltree_node_traits_impl -{ - typedef compact_avltree_node<VoidPointer> node; - - typedef typename pointer_traits - <VoidPointer>::template rebind_pointer - <node>::type node_ptr; - typedef typename pointer_traits - <VoidPointer>::template rebind_pointer - <const node>::type const_node_ptr; - typedef typename node::balance balance; - - typedef pointer_plus_bits<node_ptr, 2> ptr_bit; - - static node_ptr get_parent(const const_node_ptr & n) - { return ptr_bit::get_pointer(n->parent_); } - - static void set_parent(const node_ptr & n, const node_ptr & p) - { ptr_bit::set_pointer(n->parent_, p); } - - static const node_ptr & get_left(const const_node_ptr & n) - { return n->left_; } - - static void set_left(const node_ptr & n, const node_ptr & l) - { n->left_ = l; } - - static const node_ptr & get_right(const const_node_ptr & n) - { return n->right_; } - - static void set_right(const node_ptr & n, const node_ptr & r) - { n->right_ = r; } - - static balance get_balance(const const_node_ptr & n) - { return (balance)ptr_bit::get_bits(n->parent_); } - - static void set_balance(const node_ptr & n, balance b) - { ptr_bit::set_bits(n->parent_, (std::size_t)b); } - - static balance negative() - { return node::negative_t; } - - static balance zero() - { return node::zero_t; } - - static balance positive() - { return node::positive_t; } -}; - -//Dispatches the implementation based on the boolean -template<class VoidPointer, bool Compact> -struct avltree_node_traits_dispatch - : public default_avltree_node_traits_impl<VoidPointer> -{}; - -template<class VoidPointer> -struct avltree_node_traits_dispatch<VoidPointer, true> - : public compact_avltree_node_traits_impl<VoidPointer> -{}; - -//Inherit from the detail::link_dispatch depending on the embedding capabilities -template<class VoidPointer, bool OptimizeSize = false> -struct avltree_node_traits - : public avltree_node_traits_dispatch - < VoidPointer - , OptimizeSize && - max_pointer_plus_bits - < VoidPointer - , detail::alignment_of<compact_avltree_node<VoidPointer> >::value - >::value >= 2u - > -{}; - -} //namespace intrusive -} //namespace boost - -#include <boost/intrusive/detail/config_end.hpp> - -#endif //BOOST_INTRUSIVE_AVLTREE_NODE_HPP diff --git a/src/third_party/boost/boost/intrusive/detail/clear_on_destructor_base.hpp b/src/third_party/boost/boost/intrusive/detail/clear_on_destructor_base.hpp deleted file mode 100644 index 6765dfa05df..00000000000 --- a/src/third_party/boost/boost/intrusive/detail/clear_on_destructor_base.hpp +++ /dev/null @@ -1,36 +0,0 @@ -//////} // /////////////////////////////////////////////////////////////////////// -// -// (C) Copyright Ion Gaztanaga 2008-2009. Distributed under the Boost -// Software License, Version 1.0. (See accompanying file -// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -// -// See http://www.boost.org/libs/intrusive for documentation. -// -///////////////////////////////////////////////////////////////////////////// - -#ifndef BOOST_INTRUSIVE_DETAIL_CLEAR_ON_DESTRUCTOR_HPP -#define BOOST_INTRUSIVE_DETAIL_CLEAR_ON_DESTRUCTOR_HPP - -#include <boost/intrusive/detail/config_begin.hpp> - -namespace boost { -namespace intrusive { -namespace detail { - -template<class Derived> -class clear_on_destructor_base -{ - protected: - ~clear_on_destructor_base() - { - static_cast<Derived*>(this)->clear(); - } -}; - -} // namespace detail { -} // namespace intrusive { -} // namespace boost { - -#include <boost/intrusive/detail/config_end.hpp> - -#endif //#ifndef BOOST_INTRUSIVE_DETAIL_CLEAR_ON_DESTRUCTOR_HPP diff --git a/src/third_party/boost/boost/intrusive/detail/common_slist_algorithms.hpp b/src/third_party/boost/boost/intrusive/detail/common_slist_algorithms.hpp deleted file mode 100644 index 15d6b3ff29b..00000000000 --- a/src/third_party/boost/boost/intrusive/detail/common_slist_algorithms.hpp +++ /dev/null @@ -1,103 +0,0 @@ -///////////////////////////////////////////////////////////////////////////// -// -// (C) Copyright Ion Gaztanaga 2007-2009 -// -// Distributed under the Boost Software License, Version 1.0. -// (See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) -// -// See http://www.boost.org/libs/intrusive for documentation. -// -///////////////////////////////////////////////////////////////////////////// - -#ifndef BOOST_INTRUSIVE_COMMON_SLIST_ALGORITHMS_HPP -#define BOOST_INTRUSIVE_COMMON_SLIST_ALGORITHMS_HPP - -#include <boost/intrusive/detail/config_begin.hpp> -#include <boost/intrusive/intrusive_fwd.hpp> -#include <boost/intrusive/detail/assert.hpp> -#include <cstddef> - -namespace boost { -namespace intrusive { -namespace detail { - -template<class NodeTraits> -class common_slist_algorithms -{ - public: - typedef typename NodeTraits::node node; - typedef typename NodeTraits::node_ptr node_ptr; - typedef typename NodeTraits::const_node_ptr const_node_ptr; - typedef NodeTraits node_traits; - - static node_ptr get_previous_node(const node_ptr & prev_init_node, const node_ptr & this_node) - { - node_ptr p = prev_init_node; - for( node_ptr p_next - ; this_node != (p_next = NodeTraits::get_next(p)) - ; p = p_next){ - //Logic error: possible use of linear lists with - //operations only permitted with lists - BOOST_INTRUSIVE_INVARIANT_ASSERT(p); - } - return p; - } - - static void init_header(const node_ptr & this_node) - { NodeTraits::set_next(this_node, this_node); } - - static void init(const node_ptr & this_node) - { NodeTraits::set_next(this_node, node_ptr()); } - - static bool unique(const const_node_ptr & this_node) - { - node_ptr next = NodeTraits::get_next(this_node); - return !next || next == this_node; - } - - static bool inited(const const_node_ptr & this_node) - { return !NodeTraits::get_next(this_node); } - - static void unlink_after(const node_ptr & prev_node) - { - const_node_ptr this_node(NodeTraits::get_next(prev_node)); - NodeTraits::set_next(prev_node, NodeTraits::get_next(this_node)); - } - - static void unlink_after(const node_ptr & prev_node, const node_ptr & last_node) - { NodeTraits::set_next(prev_node, last_node); } - - static void link_after(const node_ptr & prev_node, const node_ptr & this_node) - { - NodeTraits::set_next(this_node, NodeTraits::get_next(prev_node)); - NodeTraits::set_next(prev_node, this_node); - } - - static void incorporate_after(const node_ptr & bp, const node_ptr & b, const node_ptr & be) - { - node_ptr p(NodeTraits::get_next(bp)); - NodeTraits::set_next(bp, b); - NodeTraits::set_next(be, p); - } - - static void transfer_after(const node_ptr & bp, const node_ptr & bb, const node_ptr & be) - { - if (bp != bb && bp != be && bb != be) { - node_ptr next_b = NodeTraits::get_next(bb); - node_ptr next_e = NodeTraits::get_next(be); - node_ptr next_p = NodeTraits::get_next(bp); - NodeTraits::set_next(bb, next_e); - NodeTraits::set_next(be, next_p); - NodeTraits::set_next(bp, next_b); - } - } -}; - -} //namespace detail -} //namespace intrusive -} //namespace boost - -#include <boost/intrusive/detail/config_end.hpp> - -#endif //BOOST_INTRUSIVE_COMMON_SLIST_ALGORITHMS_HPP diff --git a/src/third_party/boost/boost/intrusive/detail/config_begin.hpp b/src/third_party/boost/boost/intrusive/detail/config_begin.hpp deleted file mode 100644 index bb126fcdf06..00000000000 --- a/src/third_party/boost/boost/intrusive/detail/config_begin.hpp +++ /dev/null @@ -1,52 +0,0 @@ -///////////////////////////////////////////////////////////////////////////// -// -// (C) Copyright Ion Gaztanaga 2006-2009 -// -// Distributed under the Boost Software License, Version 1.0. -// (See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) -// -// See http://www.boost.org/libs/intrusive for documentation. -// -///////////////////////////////////////////////////////////////////////////// - -#ifndef BOOST_INTRUSIVE_CONFIG_INCLUDED -#define BOOST_INTRUSIVE_CONFIG_INCLUDED -#include <boost/config.hpp> -#endif - -#ifdef BOOST_MSVC - - #pragma warning (push) - // - //'function' : resolved overload was found by argument-dependent lookup - //A function found by argument-dependent lookup (Koenig lookup) was eventually - //chosen by overload resolution. - // - //In Visual C++ .NET and earlier compilers, a different function would have - //been called. To pick the original function, use an explicitly qualified name. - // - - //warning C4275: non dll-interface class 'x' used as base for - //dll-interface class 'Y' - #pragma warning (disable : 4275) - //warning C4251: 'x' : class 'y' needs to have dll-interface to - //be used by clients of class 'z' - #pragma warning (disable : 4251) - #pragma warning (disable : 4675) - #pragma warning (disable : 4996) - #pragma warning (disable : 4503) - #pragma warning (disable : 4284) // odd return type for operator-> - #pragma warning (disable : 4244) // possible loss of data - #pragma warning (disable : 4521) ////Disable "multiple copy constructors specified" - #pragma warning (disable : 4522) - #pragma warning (disable : 4146) - #pragma warning (disable : 4267) //conversion from 'X' to 'Y', possible loss of data - #pragma warning (disable : 4127) //conditional expression is constant - #pragma warning (disable : 4706) //assignment within conditional expression - #pragma warning (disable : 4541) //'typeid' used on polymorphic type 'boost::exception' with /GR- - #pragma warning (disable : 4512) //'typeid' used on polymorphic type 'boost::exception' with /GR- -#endif - -//#define BOOST_INTRUSIVE_USE_ITERATOR_FACADE -//#define BOOST_INTRUSIVE_USE_ITERATOR_ENABLE_IF_CONVERTIBLE diff --git a/src/third_party/boost/boost/intrusive/detail/config_end.hpp b/src/third_party/boost/boost/intrusive/detail/config_end.hpp deleted file mode 100644 index 4277cb576f8..00000000000 --- a/src/third_party/boost/boost/intrusive/detail/config_end.hpp +++ /dev/null @@ -1,15 +0,0 @@ -///////////////////////////////////////////////////////////////////////////// -// -// (C) Copyright Ion Gaztanaga 2006-2009 -// -// Distributed under the Boost Software License, Version 1.0. -// (See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) -// -// See http://www.boost.org/libs/intrusive for documentation. -// -///////////////////////////////////////////////////////////////////////////// - -#if defined BOOST_MSVC - #pragma warning (pop) -#endif diff --git a/src/third_party/boost/boost/intrusive/detail/ebo_functor_holder.hpp b/src/third_party/boost/boost/intrusive/detail/ebo_functor_holder.hpp deleted file mode 100644 index d4c2d1593bf..00000000000 --- a/src/third_party/boost/boost/intrusive/detail/ebo_functor_holder.hpp +++ /dev/null @@ -1,95 +0,0 @@ -///////////////////////////////////////////////////////////////////////////// -// -// (C) Copyright Joaquin M Lopez Munoz 2006-2009 -// -// Distributed under the Boost Software License, Version 1.0. -// (See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) -// -// See http://www.boost.org/libs/intrusive for documentation. -// -///////////////////////////////////////////////////////////////////////////// - -#ifndef BOOST_INTRUSIVE_DETAIL_EBO_HOLDER_HPP -#define BOOST_INTRUSIVE_DETAIL_EBO_HOLDER_HPP - -#include <boost/intrusive/detail/config_begin.hpp> -#include <boost/intrusive/detail/mpl.hpp> - -namespace boost { -namespace intrusive { -namespace detail { - -template<typename T, bool IsEmpty = true> -class ebo_functor_holder_impl -{ - public: - ebo_functor_holder_impl() - {} - ebo_functor_holder_impl(const T& t) - : t_(t) - {} - template<class Arg1, class Arg2> - ebo_functor_holder_impl(const Arg1& arg1, const Arg2& arg2) - : t_(arg1, arg2) - {} - - T& get(){return t_;} - const T& get()const{return t_;} - - private: - T t_; -}; - -template<typename T> -class ebo_functor_holder_impl<T, false> - : public T -{ - public: - ebo_functor_holder_impl() - {} - ebo_functor_holder_impl(const T& t) - : T(t) - {} - template<class Arg1, class Arg2> - ebo_functor_holder_impl(const Arg1& arg1, const Arg2& arg2) - : T(arg1, arg2) - {} - - T& get(){return *this;} - const T& get()const{return *this;} -}; - -template<typename T> -class ebo_functor_holder - : public ebo_functor_holder_impl<T, is_unary_or_binary_function<T>::value> -{ - private: - typedef ebo_functor_holder_impl<T, is_unary_or_binary_function<T>::value> super; - - public: - ebo_functor_holder(){} - ebo_functor_holder(const T& t) - : super(t) - {} - - template<class Arg1, class Arg2> - ebo_functor_holder(const Arg1& arg1, const Arg2& arg2) - : super(arg1, arg2) - {} - - ebo_functor_holder& operator=(const ebo_functor_holder& x) - { - this->get()=x.get(); - return *this; - } -}; - - -} //namespace detail { -} //namespace intrusive { -} //namespace boost { - -#include <boost/intrusive/detail/config_end.hpp> - -#endif //#ifndef BOOST_INTRUSIVE_DETAIL_EBO_HOLDER_HPP diff --git a/src/third_party/boost/boost/intrusive/detail/function_detector.hpp b/src/third_party/boost/boost/intrusive/detail/function_detector.hpp deleted file mode 100644 index e00a7efcf21..00000000000 --- a/src/third_party/boost/boost/intrusive/detail/function_detector.hpp +++ /dev/null @@ -1,88 +0,0 @@ -///////////////////////////////////////////////////////////////////////////// -// -// (C) Copyright Ion Gaztanaga 2009-2009. -// -// Distributed under the Boost Software License, Version 1.0. -// (See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) -// -// See http://www.boost.org/libs/intrusive for documentation. -// -///////////////////////////////////////////////////////////////////////////// -// This code was modified from the code posted by Alexandre Courpron in his -// article "Interface Detection" in The Code Project: -// http://www.codeproject.com/KB/architecture/Detector.aspx -/////////////////////////////////////////////////////////////////////////////// -// Copyright 2007 Alexandre Courpron -// -// Permission to use, copy, modify, redistribute and sell this software, -// provided that this copyright notice appears on all copies of the software. -/////////////////////////////////////////////////////////////////////////////// - -#ifndef BOOST_INTRUSIVE_DETAIL_FUNCTION_DETECTOR_HPP -#define BOOST_INTRUSIVE_DETAIL_FUNCTION_DETECTOR_HPP - -#include <boost/intrusive/detail/config_begin.hpp> - -namespace boost { -namespace intrusive { -namespace function_detector { - - typedef char NotFoundType; - struct StaticFunctionType { NotFoundType x [2]; }; - struct NonStaticFunctionType { NotFoundType x [3]; }; - - enum - { NotFound = 0, - StaticFunction = sizeof( StaticFunctionType ) - sizeof( NotFoundType ), - NonStaticFunction = sizeof( NonStaticFunctionType ) - sizeof( NotFoundType ) - }; - -} //namespace boost { -} //namespace intrusive { -} //namespace function_detector { - -#define BOOST_INTRUSIVE_CREATE_FUNCTION_DETECTOR(Identifier, InstantiationKey) \ - namespace boost { \ - namespace intrusive { \ - namespace function_detector { \ - template < class T, \ - class NonStaticType, \ - class NonStaticConstType, \ - class StaticType > \ - class DetectMember_##InstantiationKey_##Identifier { \ - template < NonStaticType > \ - struct TestNonStaticNonConst ; \ - \ - template < NonStaticConstType > \ - struct TestNonStaticConst ; \ - \ - template < StaticType > \ - struct TestStatic ; \ - \ - template <class U > \ - static NonStaticFunctionType Test( TestNonStaticNonConst<&U::Identifier>*, int ); \ - \ - template <class U > \ - static NonStaticFunctionType Test( TestNonStaticConst<&U::Identifier>*, int ); \ - \ - template <class U> \ - static StaticFunctionType Test( TestStatic<&U::Identifier>*, int ); \ - \ - template <class U> \ - static NotFoundType Test( ... ); \ - public : \ - static const int check = NotFound + (sizeof(Test<T>(0, 0)) - sizeof(NotFoundType));\ - };\ -}}} //namespace boost::intrusive::function_detector { - -#define BOOST_INTRUSIVE_DETECT_FUNCTION(Class, InstantiationKey, ReturnType, Identifier, Params) \ - ::boost::intrusive::function_detector::DetectMember_##InstantiationKey_##Identifier< Class,\ - ReturnType (Class::*)Params,\ - ReturnType (Class::*)Params const,\ - ReturnType (*)Params \ - >::check - -#include <boost/intrusive/detail/config_end.hpp> - -#endif //@ifndef BOOST_INTRUSIVE_DETAIL_FUNCTION_DETECTOR_HPP diff --git a/src/third_party/boost/boost/intrusive/detail/generic_hook.hpp b/src/third_party/boost/boost/intrusive/detail/generic_hook.hpp deleted file mode 100644 index fc35610b8d4..00000000000 --- a/src/third_party/boost/boost/intrusive/detail/generic_hook.hpp +++ /dev/null @@ -1,209 +0,0 @@ -///////////////////////////////////////////////////////////////////////////// -// -// (C) Copyright Ion Gaztanaga 2007-2009 -// -// Distributed under the Boost Software License, Version 1.0. -// (See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) -// -// See http://www.boost.org/libs/intrusive for documentation. -// -///////////////////////////////////////////////////////////////////////////// - -#ifndef BOOST_INTRUSIVE_GENERIC_HOOK_HPP -#define BOOST_INTRUSIVE_GENERIC_HOOK_HPP - -#include <boost/intrusive/detail/config_begin.hpp> -#include <boost/intrusive/intrusive_fwd.hpp> -#include <boost/intrusive/pointer_traits.hpp> -#include <boost/intrusive/link_mode.hpp> -#include <boost/intrusive/detail/utilities.hpp> -#include <boost/intrusive/detail/mpl.hpp> -#include <boost/intrusive/pointer_traits.hpp> -#include <boost/static_assert.hpp> - -namespace boost { -namespace intrusive { -namespace detail { - -/// @cond - -enum -{ NoBaseHook -, ListBaseHook -, SlistBaseHook -, SetBaseHook -, UsetBaseHook -, SplaySetBaseHook -, AvlSetBaseHook -, BsSetBaseHook -, AnyBaseHook -}; - -struct no_default_definer{}; - -template <class Hook, unsigned int> -struct default_definer; - -template <class Hook> -struct default_definer<Hook, ListBaseHook> -{ typedef Hook default_list_hook; }; - -template <class Hook> -struct default_definer<Hook, SlistBaseHook> -{ typedef Hook default_slist_hook; }; - -template <class Hook> -struct default_definer<Hook, SetBaseHook> -{ typedef Hook default_set_hook; }; - -template <class Hook> -struct default_definer<Hook, UsetBaseHook> -{ typedef Hook default_uset_hook; }; - -template <class Hook> -struct default_definer<Hook, SplaySetBaseHook> -{ typedef Hook default_splay_set_hook; }; - -template <class Hook> -struct default_definer<Hook, AvlSetBaseHook> -{ typedef Hook default_avl_set_hook; }; - -template <class Hook> -struct default_definer<Hook, BsSetBaseHook> -{ typedef Hook default_bs_set_hook; }; - -template <class Hook> -struct default_definer<Hook, AnyBaseHook> -{ typedef Hook default_any_hook; }; - -template <class Hook, unsigned int BaseHookType> -struct make_default_definer -{ - typedef typename detail::if_c - < BaseHookType != 0 - , default_definer<Hook, BaseHookType> - , no_default_definer>::type type; -}; - -template - < class GetNodeAlgorithms - , class Tag - , link_mode_type LinkMode - , int HookType - > -struct make_node_holder -{ - typedef typename detail::if_c - <!detail::is_same<Tag, member_tag>::value - , detail::node_holder - < typename GetNodeAlgorithms::type::node - , Tag - , LinkMode - , HookType> - , typename GetNodeAlgorithms::type::node - >::type type; -}; - -/// @endcond - -template - < class GetNodeAlgorithms - , class Tag - , link_mode_type LinkMode - , int HookType - > -class generic_hook - /// @cond - - //If the hook is a base hook, derive generic hook from detail::node_holder - //so that a unique base class is created to convert from the node - //to the type. This mechanism will be used by base_hook_traits. - // - //If the hook is a member hook, generic hook will directly derive - //from the hook. - : public make_default_definer - < generic_hook<GetNodeAlgorithms, Tag, LinkMode, HookType> - , detail::is_same<Tag, default_tag>::value*HookType - >::type - , public make_node_holder<GetNodeAlgorithms, Tag, LinkMode, HookType>::type - /// @endcond -{ - /// @cond - typedef typename GetNodeAlgorithms::type node_algorithms; - typedef typename node_algorithms::node node; - typedef typename node_algorithms::node_ptr node_ptr; - typedef typename node_algorithms::const_node_ptr const_node_ptr; - - public: - struct boost_intrusive_tags - { - static const int hook_type = HookType; - static const link_mode_type link_mode = LinkMode; - typedef Tag tag; - typedef typename GetNodeAlgorithms::type::node_traits node_traits; - static const bool is_base_hook = !detail::is_same<Tag, member_tag>::value; - static const bool safemode_or_autounlink = - (int)link_mode == (int)auto_unlink || (int)link_mode == (int)safe_link; - }; - - node_ptr this_ptr() - { return pointer_traits<node_ptr>::pointer_to(static_cast<node&>(*this)); } - - const_node_ptr this_ptr() const - { return pointer_traits<const_node_ptr>::pointer_to(static_cast<const node&>(*this)); } - - public: - /// @endcond - - generic_hook() - { - if(boost_intrusive_tags::safemode_or_autounlink){ - node_algorithms::init(this->this_ptr()); - } - } - - generic_hook(const generic_hook& ) - { - if(boost_intrusive_tags::safemode_or_autounlink){ - node_algorithms::init(this->this_ptr()); - } - } - - generic_hook& operator=(const generic_hook& ) - { return *this; } - - ~generic_hook() - { - destructor_impl - (*this, detail::link_dispatch<boost_intrusive_tags::link_mode>()); - } - - void swap_nodes(generic_hook &other) - { - node_algorithms::swap_nodes - (this->this_ptr(), other.this_ptr()); - } - - bool is_linked() const - { - //is_linked() can be only used in safe-mode or auto-unlink - BOOST_STATIC_ASSERT(( boost_intrusive_tags::safemode_or_autounlink )); - return !node_algorithms::unique(this->this_ptr()); - } - - void unlink() - { - BOOST_STATIC_ASSERT(( (int)boost_intrusive_tags::link_mode == (int)auto_unlink )); - node_algorithms::unlink(this->this_ptr()); - node_algorithms::init(this->this_ptr()); - } -}; - -} //namespace detail -} //namespace intrusive -} //namespace boost - -#include <boost/intrusive/detail/config_end.hpp> - -#endif //BOOST_INTRUSIVE_GENERIC_HOOK_HPP diff --git a/src/third_party/boost/boost/intrusive/detail/has_member_function_callable_with.hpp b/src/third_party/boost/boost/intrusive/detail/has_member_function_callable_with.hpp deleted file mode 100644 index b833f051a30..00000000000 --- a/src/third_party/boost/boost/intrusive/detail/has_member_function_callable_with.hpp +++ /dev/null @@ -1,362 +0,0 @@ -////////////////////////////////////////////////////////////////////////////// -// -// (C) Copyright Ion Gaztanaga 2011-2011. Distributed under the Boost -// Software License, Version 1.0. (See accompanying file -// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -// -// See http://www.boost.org/libs/intrusive for documentation. -// -////////////////////////////////////////////////////////////////////////////// - -// sample.h - -#if !BOOST_PP_IS_ITERATING - - #ifndef BOOST_INTRUSIVE_DETAIL_HAS_MEMBER_FUNCTION_CALLABLE_WITH_DETAILS_INCLUDED - #define BOOST_INTRUSIVE_DETAIL_HAS_MEMBER_FUNCTION_CALLABLE_WITH_DETAILS_INCLUDED - - #include <boost/intrusive/detail/config_begin.hpp> - #include <boost/intrusive/detail/workaround.hpp> - #include <boost/intrusive/detail/preprocessor.hpp> - #include <boost/static_assert.hpp> - #include <boost/move/move.hpp> - - //Mark that we don't support 0 arg calls due to compiler ICE in GCC 3.4/4.0/4.1 and - //wrong SFINAE for GCC 4.2/4.3 - #if defined(__GNUC__) && !defined(__clang__) && ((__GNUC__*100 + __GNUC_MINOR__*10) >= 340) && ((__GNUC__*100 + __GNUC_MINOR__*10) <= 430) - #define BOOST_INTRUSIVE_DETAIL_HAS_MEMBER_FUNCTION_CALLABLE_WITH_0_ARGS_UNSUPPORTED - #elif defined(BOOST_INTEL) && (BOOST_INTEL < 1200 ) - #define BOOST_INTRUSIVE_DETAIL_HAS_MEMBER_FUNCTION_CALLABLE_WITH_0_ARGS_UNSUPPORTED - #endif - - namespace boost_intrusive_has_member_function_callable_with { - - struct dont_care - { - dont_care(...); - }; - - struct private_type - { - static private_type p; - private_type const &operator,(int) const; - }; - - typedef char yes_type; // sizeof(yes_type) == 1 - struct no_type{ char dummy[2]; }; // sizeof(no_type) == 2 - - template<typename T> - no_type is_private_type(T const &); - yes_type is_private_type(private_type const &); - - } //boost_intrusive_has_member_function_callable_with - - #include <boost/intrusive/detail/config_end.hpp> - - #endif //BOOST_INTRUSIVE_DETAIL_HAS_MEMBER_FUNCTION_CALLABLE_WITH_DETAILS_INCLUDED - -#else //!BOOST_PP_IS_ITERATING - - #ifndef BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME - #error "BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME not defined!" - #endif - - #ifndef BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_BEGIN - #error "BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_BEGIN not defined!" - #endif - - #ifndef BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_END - #error "BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_END not defined!" - #endif - - #if BOOST_PP_ITERATION_START() != 0 - #error "BOOST_PP_ITERATION_START() must be zero (0)" - #endif - - #if BOOST_PP_ITERATION() == 0 - - BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_BEGIN - - template <typename Type> - class BOOST_PP_CAT(has_member_function_named_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME) - { - struct BaseMixin - { - void BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME(); - }; - - struct Base : public Type, public BaseMixin { Base(); }; - template <typename T, T t> class Helper{}; - - template <typename U> - static boost_intrusive_has_member_function_callable_with::no_type deduce - (U*, Helper<void (BaseMixin::*)(), &U::BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME>* = 0); - static boost_intrusive_has_member_function_callable_with::yes_type deduce(...); - - public: - static const bool value = - sizeof(boost_intrusive_has_member_function_callable_with::yes_type) == sizeof(deduce((Base*)(0))); - }; - - #if !defined(BOOST_INTRUSIVE_PERFECT_FORWARDING) - - template<typename Fun, bool HasFunc - BOOST_PP_ENUM_TRAILING(BOOST_PP_ITERATION_FINISH(), BOOST_INTRUSIVE_PP_TEMPLATE_PARAM_VOID_DEFAULT, _)> - struct BOOST_PP_CAT(BOOST_PP_CAT(has_member_function_callable_with_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME), _impl); - //! - - template<typename Fun BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION_FINISH(), class P)> - struct BOOST_PP_CAT(BOOST_PP_CAT(has_member_function_callable_with_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME), _impl) - <Fun, false BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION_FINISH(), P)> - { - static const bool value = false; - }; - //! - - #if !defined(_MSC_VER) || (_MSC_VER != 1600) - - #if defined(BOOST_INTRUSIVE_DETAIL_HAS_MEMBER_FUNCTION_CALLABLE_WITH_0_ARGS_UNSUPPORTED) - - template<typename Fun> - struct BOOST_PP_CAT(BOOST_PP_CAT(has_member_function_callable_with_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME),_impl) - <Fun, true BOOST_PP_ENUM_TRAILING(BOOST_PP_SUB(BOOST_PP_ITERATION_FINISH(), BOOST_PP_ITERATION()), BOOST_INTRUSIVE_PP_IDENTITY, void)> - { - //Mark that we don't support 0 arg calls due to compiler ICE in GCC 3.4/4.0/4.1 and - //wrong SFINAE for GCC 4.2/4.3 - static const bool value = true; - }; - - #else - - //Special case for 0 args - template< class F - , std::size_t N = - sizeof((boost::move_detail::declval<F>(). - BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME (), 0))> - struct BOOST_PP_CAT(zeroarg_checker_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME) - { - boost_intrusive_has_member_function_callable_with::yes_type dummy; - BOOST_PP_CAT(zeroarg_checker_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)(int); - }; - - //For buggy compilers like MSVC 7.1+ ((F*)0)->func() does not - //SFINAE-out the zeroarg_checker_ instantiation but sizeof yields to 0. - template<class F> - struct BOOST_PP_CAT(zeroarg_checker_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)<F, 0> - { - boost_intrusive_has_member_function_callable_with::no_type dummy; - BOOST_PP_CAT(zeroarg_checker_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)(int); - }; - - template<typename Fun> - struct BOOST_PP_CAT(BOOST_PP_CAT(has_member_function_callable_with_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME),_impl) - <Fun, true BOOST_PP_ENUM_TRAILING(BOOST_PP_SUB(BOOST_PP_ITERATION_FINISH(), BOOST_PP_ITERATION()), BOOST_INTRUSIVE_PP_IDENTITY, void)> - { -#ifdef BOOST_MSVC - template<class U> - static decltype(boost::move_detail::declval<Fun>().BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME() - , boost_intrusive_has_member_function_callable_with::yes_type()) - Test(Fun*); -#else - template<class U> - static BOOST_PP_CAT(zeroarg_checker_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME) - <U> Test(BOOST_PP_CAT(zeroarg_checker_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)<U>*); -#endif - template <class U> - static boost_intrusive_has_member_function_callable_with::no_type Test(...); - - static const bool value = sizeof(Test< Fun >(0)) - == sizeof(boost_intrusive_has_member_function_callable_with::yes_type); - }; - #endif - - #else //#if !defined(_MSC_VER) || (_MSC_VER != 1600) - template<typename Fun> - struct BOOST_PP_CAT(BOOST_PP_CAT(has_member_function_callable_with_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME),_impl) - <Fun, true BOOST_PP_ENUM_TRAILING(BOOST_PP_SUB(BOOST_PP_ITERATION_FINISH(), BOOST_PP_ITERATION()), BOOST_INTRUSIVE_PP_IDENTITY, void)> - { - template<class U> - static decltype( boost::move_detail::declval<Fun>().BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME() - , boost_intrusive_has_member_function_callable_with::yes_type()) - Test(Fun*); - - template<class U> - static boost_intrusive_has_member_function_callable_with::no_type Test(...); - - static const bool value = sizeof(Test<Fun>(0)) - == sizeof(boost_intrusive_has_member_function_callable_with::yes_type); - }; - #endif //#if !defined(_MSC_VER) || (_MSC_VER != 1600) - - #else //#if !defined(BOOST_INTRUSIVE_PERFECT_FORWARDING) - - template<typename Fun, bool HasFunc, class ...Args> - struct BOOST_PP_CAT(BOOST_PP_CAT(has_member_function_callable_with_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME),_impl); - - template<typename Fun, class ...Args> - struct BOOST_PP_CAT(BOOST_PP_CAT(has_member_function_callable_with_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME),_impl) - <Fun, false, Args...> - { - static const bool value = false; - }; - - //Special case for 0 args - template< class F - , std::size_t N = - sizeof((boost::move_detail::declval<F>(). - BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME (), 0))> - struct BOOST_PP_CAT(zeroarg_checker_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME) - { - boost_intrusive_has_member_function_callable_with::yes_type dummy; - BOOST_PP_CAT(zeroarg_checker_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)(int); - }; - - //For buggy compilers like MSVC 7.1+ ((F*)0)->func() does not - //SFINAE-out the zeroarg_checker_ instantiation but sizeof yields to 0. - template<class F> - struct BOOST_PP_CAT(zeroarg_checker_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)<F, 0> - { - boost_intrusive_has_member_function_callable_with::no_type dummy; - BOOST_PP_CAT(zeroarg_checker_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)(int); - }; - - template<typename Fun> - struct BOOST_PP_CAT(BOOST_PP_CAT(has_member_function_callable_with_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME),_impl) - <Fun, true> - { - template<class U> - static BOOST_PP_CAT(zeroarg_checker_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME) - <U> Test(BOOST_PP_CAT(zeroarg_checker_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)<U>*); - - template <class U> - static boost_intrusive_has_member_function_callable_with::no_type Test(...); - - static const bool value = sizeof(Test< Fun >(0)) - == sizeof(boost_intrusive_has_member_function_callable_with::yes_type); - }; - - template<typename Fun, class ...DontCares> - struct BOOST_PP_CAT( funwrap_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME ) - : Fun - { - BOOST_PP_CAT( funwrap_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME )(); - using Fun::BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME; - - boost_intrusive_has_member_function_callable_with::private_type - BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME - ( DontCares...) const; - }; - - template<typename Fun, class ...Args> - struct BOOST_PP_CAT( BOOST_PP_CAT(has_member_function_callable_with_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME), _impl) - <Fun, true , Args...> - { - template<class T> - struct make_dontcare - { - typedef boost_intrusive_has_member_function_callable_with::dont_care type; - }; - - typedef BOOST_PP_CAT( funwrap_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME ) - <Fun, typename make_dontcare<Args>::type...> FunWrap; - - static bool const value = (sizeof(boost_intrusive_has_member_function_callable_with::no_type) == - sizeof(boost_intrusive_has_member_function_callable_with::is_private_type - ( (::boost::move_detail::declval< FunWrap >(). - BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME - ( ::boost::move_detail::declval<Args>()... ), 0) ) - ) - ); - }; - - template<typename Fun, class ...Args> - struct BOOST_PP_CAT( has_member_function_callable_with_ - , BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME) - : public BOOST_PP_CAT( BOOST_PP_CAT(has_member_function_callable_with_ - , BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME),_impl) - < Fun - , BOOST_PP_CAT( has_member_function_named_ - , BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME )<Fun>::value - , Args... > - {}; - - #endif //#if !defined(BOOST_INTRUSIVE_PERFECT_FORWARDING) - - BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_END - - #else //BOOST_PP_ITERATION() == 0 - - #if !defined(BOOST_INTRUSIVE_PERFECT_FORWARDING) - - BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_BEGIN - - template<typename Fun> - struct BOOST_PP_CAT( BOOST_PP_CAT(funwrap, BOOST_PP_ITERATION()) - , BOOST_PP_CAT(_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)) - : Fun - { - BOOST_PP_CAT( BOOST_PP_CAT(funwrap, BOOST_PP_ITERATION()) - , BOOST_PP_CAT(_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME))(); - - using Fun::BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME; - boost_intrusive_has_member_function_callable_with::private_type - BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME - ( BOOST_PP_ENUM(BOOST_PP_ITERATION() - , BOOST_INTRUSIVE_PP_IDENTITY - , boost_intrusive_has_member_function_callable_with::dont_care)) const; - }; - - template<typename Fun BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION(), class P)> - struct BOOST_PP_CAT( BOOST_PP_CAT(has_member_function_callable_with_ - , BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME),_impl) - <Fun, true - BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION(), P) - BOOST_PP_ENUM_TRAILING( BOOST_PP_SUB(BOOST_PP_ITERATION_FINISH(), BOOST_PP_ITERATION()) - , BOOST_INTRUSIVE_PP_IDENTITY - , void)> - { - typedef BOOST_PP_CAT( BOOST_PP_CAT(funwrap, BOOST_PP_ITERATION()) - , BOOST_PP_CAT(_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME))<Fun> - FunWrap; - static bool const value = - (sizeof(boost_intrusive_has_member_function_callable_with::no_type) == - sizeof(boost_intrusive_has_member_function_callable_with::is_private_type - ( (boost::move_detail::declval<FunWrap>(). - BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME - ( BOOST_PP_ENUM( BOOST_PP_ITERATION(), BOOST_INTRUSIVE_PP_DECLVAL, _) ), 0 - ) - ) - ) - ); - }; - - BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_END - #endif //#if !defined(BOOST_INTRUSIVE_PERFECT_FORWARDING) - - #endif //BOOST_PP_ITERATION() == 0 - - #if BOOST_PP_ITERATION() == BOOST_PP_ITERATION_FINISH() - - #if !defined(BOOST_INTRUSIVE_PERFECT_FORWARDING) - - BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_BEGIN - - template<typename Fun - BOOST_PP_ENUM_TRAILING(BOOST_PP_ITERATION_FINISH(), BOOST_INTRUSIVE_PP_TEMPLATE_PARAM_VOID_DEFAULT, _)> - struct BOOST_PP_CAT(has_member_function_callable_with_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME) - : public BOOST_PP_CAT(BOOST_PP_CAT(has_member_function_callable_with_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME), _impl) - <Fun, BOOST_PP_CAT(has_member_function_named_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)<Fun>::value - BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION_FINISH(), P) > - {}; - - BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_END - - #endif //#if !defined(BOOST_INTRUSIVE_PERFECT_FORWARDING) - - #undef BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME - #undef BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_BEGIN - #undef BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_END - - #endif //#if BOOST_PP_ITERATION() == BOOST_PP_ITERATION_FINISH() - -#endif //!BOOST_PP_IS_ITERATING diff --git a/src/third_party/boost/boost/intrusive/detail/hashtable_node.hpp b/src/third_party/boost/boost/intrusive/detail/hashtable_node.hpp deleted file mode 100644 index ac6ab81948c..00000000000 --- a/src/third_party/boost/boost/intrusive/detail/hashtable_node.hpp +++ /dev/null @@ -1,249 +0,0 @@ -///////////////////////////////////////////////////////////////////////////// -// -// (C) Copyright Ion Gaztanaga 2007-2009 -// -// Distributed under the Boost Software License, Version 1.0. -// (See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) -// -// See http://www.boost.org/libs/intrusive for documentation. -// -///////////////////////////////////////////////////////////////////////////// - -#ifndef BOOST_INTRUSIVE_HASHTABLE_NODE_HPP -#define BOOST_INTRUSIVE_HASHTABLE_NODE_HPP - -#include <boost/intrusive/detail/config_begin.hpp> -#include <iterator> -#include <boost/intrusive/detail/assert.hpp> -#include <boost/intrusive/pointer_traits.hpp> -#include <boost/intrusive/circular_list_algorithms.hpp> -#include <boost/intrusive/detail/mpl.hpp> -#include <boost/intrusive/detail/utilities.hpp> -//#include <boost/intrusive/detail/slist_node.hpp> //remove-me -#include <boost/intrusive/pointer_traits.hpp> -#include <cstddef> -#include <boost/pointer_cast.hpp> -#include <boost/move/move.hpp> - - -namespace boost { -namespace intrusive { -namespace detail { - -template<int Dummy = 0> -struct prime_list_holder -{ - static const std::size_t prime_list[]; - static const std::size_t prime_list_size; -}; - -template<int Dummy> -const std::size_t prime_list_holder<Dummy>::prime_list[] = { - 3ul, 7ul, 11ul, 17ul, 29ul, - 53ul, 97ul, 193ul, 389ul, 769ul, - 1543ul, 3079ul, 6151ul, 12289ul, 24593ul, - 49157ul, 98317ul, 196613ul, 393241ul, 786433ul, - 1572869ul, 3145739ul, 6291469ul, 12582917ul, 25165843ul, - 50331653ul, 100663319ul, 201326611ul, 402653189ul, 805306457ul, - 1610612741ul, 3221225473ul, 4294967291ul }; - -template<int Dummy> -const std::size_t prime_list_holder<Dummy>::prime_list_size - = sizeof(prime_list)/sizeof(std::size_t); - -template <class Slist> -struct bucket_impl : public Slist -{ - typedef Slist slist_type; - bucket_impl() - {} - - bucket_impl(const bucket_impl &) - {} - - ~bucket_impl() - { - //This bucket is still being used! - BOOST_INTRUSIVE_INVARIANT_ASSERT(Slist::empty()); - } - - bucket_impl &operator=(const bucket_impl&) - { - //This bucket is still in use! - BOOST_INTRUSIVE_INVARIANT_ASSERT(Slist::empty()); - //Slist::clear(); - return *this; - } -}; - -template<class Slist> -struct bucket_traits_impl -{ - private: - BOOST_COPYABLE_AND_MOVABLE(bucket_traits_impl) - - public: - /// @cond - - typedef typename pointer_traits - <typename Slist::pointer>::template rebind_pointer - < bucket_impl<Slist> >::type bucket_ptr; - typedef typename Slist::size_type size_type; - /// @endcond - - bucket_traits_impl(bucket_ptr buckets, size_type len) - : buckets_(buckets), buckets_len_(len) - {} - - bucket_traits_impl(const bucket_traits_impl &x) - : buckets_(x.buckets_), buckets_len_(x.buckets_len_) - {} - - - bucket_traits_impl(BOOST_RV_REF(bucket_traits_impl) x) - : buckets_(x.buckets_), buckets_len_(x.buckets_len_) - { x.buckets_ = bucket_ptr(); x.buckets_len_ = 0; } - - bucket_traits_impl& operator=(BOOST_RV_REF(bucket_traits_impl) x) - { - buckets_ = x.buckets_; buckets_len_ = x.buckets_len_; - x.buckets_ = bucket_ptr(); x.buckets_len_ = 0; return *this; - } - - bucket_traits_impl& operator=(BOOST_COPY_ASSIGN_REF(bucket_traits_impl) x) - { - buckets_ = x.buckets_; buckets_len_ = x.buckets_len_; return *this; - } - - const bucket_ptr &bucket_begin() const - { return buckets_; } - - size_type bucket_count() const - { return buckets_len_; } - - private: - bucket_ptr buckets_; - size_type buckets_len_; -}; - -template<class Container, bool IsConst> -class hashtable_iterator - : public std::iterator - < std::forward_iterator_tag - , typename Container::value_type - , typename pointer_traits<typename Container::value_type*>::difference_type - , typename detail::add_const_if_c - <typename Container::value_type, IsConst>::type * - , typename detail::add_const_if_c - <typename Container::value_type, IsConst>::type & - > -{ - typedef typename Container::real_value_traits real_value_traits; - typedef typename Container::siterator siterator; - typedef typename Container::const_siterator const_siterator; - typedef typename Container::bucket_type bucket_type; - - typedef typename pointer_traits - <typename Container::pointer>::template rebind_pointer - < const Container >::type const_cont_ptr; - typedef typename Container::size_type size_type; - - static typename Container::node_ptr downcast_bucket(typename bucket_type::node_ptr p) - { - return pointer_traits<typename Container::node_ptr>:: - pointer_to(static_cast<typename Container::node&>(*p)); - } - - public: - typedef typename Container::value_type value_type; - typedef typename detail::add_const_if_c - <typename Container::value_type, IsConst>::type *pointer; - typedef typename detail::add_const_if_c - <typename Container::value_type, IsConst>::type &reference; - - hashtable_iterator () - {} - - explicit hashtable_iterator(siterator ptr, const Container *cont) - : slist_it_ (ptr), cont_ (cont ? pointer_traits<const_cont_ptr>::pointer_to(*cont) : const_cont_ptr() ) - {} - - hashtable_iterator(const hashtable_iterator<Container, false> &other) - : slist_it_(other.slist_it()), cont_(other.get_container()) - {} - - const siterator &slist_it() const - { return slist_it_; } - - hashtable_iterator<Container, false> unconst() const - { return hashtable_iterator<Container, false>(this->slist_it(), this->get_container()); } - - public: - hashtable_iterator& operator++() - { this->increment(); return *this; } - - hashtable_iterator operator++(int) - { - hashtable_iterator result (*this); - this->increment(); - return result; - } - - friend bool operator== (const hashtable_iterator& i, const hashtable_iterator& i2) - { return i.slist_it_ == i2.slist_it_; } - - friend bool operator!= (const hashtable_iterator& i, const hashtable_iterator& i2) - { return !(i == i2); } - - reference operator*() const - { return *this->operator ->(); } - - pointer operator->() const - { - return boost::intrusive::detail::to_raw_pointer(this->get_real_value_traits()->to_value_ptr - (downcast_bucket(slist_it_.pointed_node()))); - } - - const const_cont_ptr &get_container() const - { return cont_; } - - const real_value_traits *get_real_value_traits() const - { return &this->get_container()->get_real_value_traits(); } - - private: - void increment() - { - const Container *cont = boost::intrusive::detail::to_raw_pointer(cont_); - bucket_type* buckets = boost::intrusive::detail::to_raw_pointer(cont->bucket_pointer()); - size_type buckets_len = cont->bucket_count(); - - ++slist_it_; - if(buckets[0].cend().pointed_node() <= slist_it_.pointed_node() && - slist_it_.pointed_node()<= buckets[buckets_len].cend().pointed_node() ){ - //Now get the bucket_impl from the iterator - const bucket_type &b = static_cast<const bucket_type&> - (bucket_type::slist_type::container_from_end_iterator(slist_it_)); - - //Now just calculate the index b has in the bucket array - size_type n_bucket = static_cast<size_type>(&b - &buckets[0]); - do{ - if (++n_bucket == buckets_len){ - slist_it_ = (&buckets[0] + buckets_len)->end(); - break; - } - slist_it_ = buckets[n_bucket].begin(); - } - while (slist_it_ == buckets[n_bucket].end()); - } - } - - siterator slist_it_; - const_cont_ptr cont_; -}; - -} //namespace detail { -} //namespace intrusive { -} //namespace boost { - -#endif diff --git a/src/third_party/boost/boost/intrusive/detail/is_stateful_value_traits.hpp b/src/third_party/boost/boost/intrusive/detail/is_stateful_value_traits.hpp deleted file mode 100644 index e38f4de4592..00000000000 --- a/src/third_party/boost/boost/intrusive/detail/is_stateful_value_traits.hpp +++ /dev/null @@ -1,77 +0,0 @@ -///////////////////////////////////////////////////////////////////////////// -// -// (C) Copyright Ion Gaztanaga 2009-2009. -// -// Distributed under the Boost Software License, Version 1.0. -// (See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) -// -// See http://www.boost.org/libs/intrusive for documentation. -// -///////////////////////////////////////////////////////////////////////////// - -#ifndef BOOST_INTRUSIVE_DETAIL_IS_STATEFUL_VALUE_TRAITS_HPP -#define BOOST_INTRUSIVE_DETAIL_IS_STATEFUL_VALUE_TRAITS_HPP - -#include <boost/intrusive/detail/config_begin.hpp> - -#if defined(_MSC_VER) && (_MSC_VER <= 1310) - -#include <boost/intrusive/detail/mpl.hpp> - -namespace boost { -namespace intrusive { -namespace detail { - -template<class ValueTraits> -struct is_stateful_value_traits -{ - static const bool value = !detail::is_empty_class<ValueTraits>::value; -}; - -}}} - -#else - -#include <boost/intrusive/detail/function_detector.hpp> - -BOOST_INTRUSIVE_CREATE_FUNCTION_DETECTOR(to_node_ptr, boost_intrusive) -BOOST_INTRUSIVE_CREATE_FUNCTION_DETECTOR(to_value_ptr, boost_intrusive) - -namespace boost { -namespace intrusive { -namespace detail { - -template<class ValueTraits> -struct is_stateful_value_traits -{ - typedef typename ValueTraits::node_ptr node_ptr; - typedef typename ValueTraits::pointer pointer; - typedef typename ValueTraits::value_type value_type; - typedef typename ValueTraits::const_node_ptr const_node_ptr; - typedef typename ValueTraits::const_pointer const_pointer; - - typedef ValueTraits value_traits; - - static const bool value = - (boost::intrusive::function_detector::NonStaticFunction == - (BOOST_INTRUSIVE_DETECT_FUNCTION(ValueTraits, boost_intrusive, node_ptr, to_node_ptr, (value_type&) ))) - || - (boost::intrusive::function_detector::NonStaticFunction == - (BOOST_INTRUSIVE_DETECT_FUNCTION(ValueTraits, boost_intrusive, pointer, to_value_ptr, (node_ptr) ))) - || - (boost::intrusive::function_detector::NonStaticFunction == - (BOOST_INTRUSIVE_DETECT_FUNCTION(ValueTraits, boost_intrusive, const_node_ptr, to_node_ptr, (const value_type&) ))) - || - (boost::intrusive::function_detector::NonStaticFunction == - (BOOST_INTRUSIVE_DETECT_FUNCTION(ValueTraits, boost_intrusive, const_pointer, to_value_ptr, (const_node_ptr) ))) - ; -}; - -}}} - -#endif - -#include <boost/intrusive/detail/config_end.hpp> - -#endif //@ifndef BOOST_INTRUSIVE_DETAIL_IS_STATEFUL_VALUE_TRAITS_HPP diff --git a/src/third_party/boost/boost/intrusive/detail/list_node.hpp b/src/third_party/boost/boost/intrusive/detail/list_node.hpp deleted file mode 100644 index df99912dd23..00000000000 --- a/src/third_party/boost/boost/intrusive/detail/list_node.hpp +++ /dev/null @@ -1,190 +0,0 @@ -///////////////////////////////////////////////////////////////////////////// -// -// (C) Copyright Olaf Krzikalla 2004-2006. -// (C) Copyright Ion Gaztanaga 2006-2009 -// -// Distributed under the Boost Software License, Version 1.0. -// (See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) -// -// See http://www.boost.org/libs/intrusive for documentation. -// -///////////////////////////////////////////////////////////////////////////// - -#ifndef BOOST_INTRUSIVE_LIST_NODE_HPP -#define BOOST_INTRUSIVE_LIST_NODE_HPP - -#include <boost/intrusive/detail/config_begin.hpp> -#include <iterator> -#include <boost/intrusive/detail/assert.hpp> -#include <boost/intrusive/pointer_traits.hpp> - -namespace boost { -namespace intrusive { - -// list_node_traits can be used with circular_list_algorithms and supplies -// a list_node holding the pointers needed for a double-linked list -// it is used by list_derived_node and list_member_node - -template<class VoidPointer> -struct list_node -{ - typedef typename pointer_traits - <VoidPointer>:: template rebind_pointer<list_node>::type node_ptr; - node_ptr next_; - node_ptr prev_; -}; - -template<class VoidPointer> -struct list_node_traits -{ - typedef list_node<VoidPointer> node; - typedef typename pointer_traits - <VoidPointer>:: template rebind_pointer<node>::type node_ptr; - typedef typename pointer_traits - <VoidPointer>:: template rebind_pointer<const node>::type const_node_ptr; - - static const node_ptr &get_previous(const const_node_ptr & n) - { return n->prev_; } - - static void set_previous(const node_ptr & n, const node_ptr & prev) - { n->prev_ = prev; } - - static const node_ptr &get_next(const const_node_ptr & n) - { return n->next_; } - - static void set_next(const node_ptr & n, const node_ptr & next) - { n->next_ = next; } -}; - -// list_iterator provides some basic functions for a -// node oriented bidirectional iterator: -template<class Container, bool IsConst> -class list_iterator - : public std::iterator - < std::bidirectional_iterator_tag - , typename Container::value_type - , typename Container::difference_type - , typename detail::if_c<IsConst,typename Container::const_pointer,typename Container::pointer>::type - , typename detail::if_c<IsConst,typename Container::const_reference,typename Container::reference>::type - > -{ - protected: - typedef typename Container::real_value_traits real_value_traits; - typedef typename real_value_traits::node_traits node_traits; - typedef typename node_traits::node node; - typedef typename node_traits::node_ptr node_ptr; - typedef typename pointer_traits<node_ptr>:: - template rebind_pointer<void>::type void_pointer; - static const bool store_container_ptr = - detail::store_cont_ptr_on_it<Container>::value; - - public: - typedef typename Container::value_type value_type; - typedef typename detail::if_c<IsConst,typename Container::const_pointer,typename Container::pointer>::type pointer; - typedef typename detail::if_c<IsConst,typename Container::const_reference,typename Container::reference>::type reference; - - list_iterator() - : members_ (node_ptr(), 0) - {} - - explicit list_iterator(const node_ptr & node, const Container *cont_ptr) - : members_ (node, cont_ptr) - {} - - list_iterator(list_iterator<Container, false> const& other) - : members_(other.pointed_node(), other.get_container()) - {} - - const node_ptr &pointed_node() const - { return members_.nodeptr_; } - - list_iterator &operator=(const node_ptr &node) - { members_.nodeptr_ = node; return static_cast<list_iterator&>(*this); } - - public: - list_iterator& operator++() - { - node_ptr p = node_traits::get_next(members_.nodeptr_); - members_.nodeptr_ = p; - //members_.nodeptr_ = node_traits::get_next(members_.nodeptr_); - return static_cast<list_iterator&> (*this); - } - - list_iterator operator++(int) - { - list_iterator result (*this); - members_.nodeptr_ = node_traits::get_next(members_.nodeptr_); - return result; - } - - list_iterator& operator--() - { - members_.nodeptr_ = node_traits::get_previous(members_.nodeptr_); - return static_cast<list_iterator&> (*this); - } - - list_iterator operator--(int) - { - list_iterator result (*this); - members_.nodeptr_ = node_traits::get_previous(members_.nodeptr_); - return result; - } - - friend bool operator== (const list_iterator& l, const list_iterator& r) - { return l.pointed_node() == r.pointed_node(); } - - friend bool operator!= (const list_iterator& l, const list_iterator& r) - { return !(l == r); } - - reference operator*() const - { return *operator->(); } - - pointer operator->() const - { return this->get_real_value_traits()->to_value_ptr(members_.nodeptr_); } - - const Container *get_container() const - { - if(store_container_ptr){ - const Container* c = static_cast<const Container*>(members_.get_ptr()); - BOOST_INTRUSIVE_INVARIANT_ASSERT(c != 0); - return c; - } - else{ - return 0; - } - } - - const real_value_traits *get_real_value_traits() const - { - if(store_container_ptr) - return &this->get_container()->get_real_value_traits(); - else - return 0; - } - - list_iterator<Container, false> unconst() const - { return list_iterator<Container, false>(this->pointed_node(), this->get_container()); } - - private: - struct members - : public detail::select_constptr - <void_pointer, store_container_ptr>::type - { - typedef typename detail::select_constptr - <void_pointer, store_container_ptr>::type Base; - - members(const node_ptr &n_ptr, const void *cont) - : Base(cont), nodeptr_(n_ptr) - {} - - node_ptr nodeptr_; - } members_; -}; - -} //namespace intrusive -} //namespace boost - -#include <boost/intrusive/detail/config_end.hpp> - -#endif //BOOST_INTRUSIVE_LIST_NODE_HPP diff --git a/src/third_party/boost/boost/intrusive/detail/memory_util.hpp b/src/third_party/boost/boost/intrusive/detail/memory_util.hpp deleted file mode 100644 index ad026c6d618..00000000000 --- a/src/third_party/boost/boost/intrusive/detail/memory_util.hpp +++ /dev/null @@ -1,279 +0,0 @@ -////////////////////////////////////////////////////////////////////////////// -// -// (C) Copyright Pablo Halpern 2009. Distributed under the Boost -// Software License, Version 1.0. (See accompanying file -// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -// -////////////////////////////////////////////////////////////////////////////// -// -// (C) Copyright Ion Gaztanaga 2011-2011. Distributed under the Boost -// Software License, Version 1.0. (See accompanying file -// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -// -// See http://www.boost.org/libs/intrusive for documentation. -// -////////////////////////////////////////////////////////////////////////////// - -#ifndef BOOST_INTRUSIVE_ALLOCATOR_MEMORY_UTIL_HPP -#define BOOST_INTRUSIVE_ALLOCATOR_MEMORY_UTIL_HPP - -#if (defined _MSC_VER) && (_MSC_VER >= 1200) -# pragma once -#endif - -#include <boost/intrusive/detail/config_begin.hpp> -#include <boost/intrusive/detail/workaround.hpp> -#include <boost/intrusive/detail/mpl.hpp> -#include <boost/intrusive/detail/preprocessor.hpp> - -namespace boost { -namespace intrusive { -namespace detail { - -template <typename T> -inline T* addressof(T& obj) -{ - return static_cast<T*> - (static_cast<void*> - (const_cast<char*> - (&reinterpret_cast<const char&>(obj)) - ) - ); -} - -template <typename T> struct unvoid { typedef T type; }; -template <> struct unvoid<void> { struct type { }; }; -template <> struct unvoid<const void> { struct type { }; }; - -template <typename T> -struct LowPriorityConversion -{ - // Convertible from T with user-defined-conversion rank. - LowPriorityConversion(const T&) { } -}; - -// Infrastructure for providing a default type for T::TNAME if absent. -#define BOOST_INTRUSIVE_INSTANTIATE_DEFAULT_TYPE_TMPLT(TNAME) \ - template <typename T, typename DefaultType> \ - struct boost_intrusive_default_type_ ## TNAME \ - { \ - template <typename X> \ - static char test(int, typename X::TNAME*); \ - \ - template <typename X> \ - static int test(boost::intrusive::detail:: \ - LowPriorityConversion<int>, void*); \ - \ - struct DefaultWrap { typedef DefaultType TNAME; }; \ - \ - static const bool value = (1 == sizeof(test<T>(0, 0))); \ - \ - typedef typename \ - ::boost::intrusive::detail::if_c \ - <value, T, DefaultWrap>::type::TNAME type; \ - }; \ - \ - template <typename T, typename DefaultType> \ - struct boost_intrusive_eval_default_type_ ## TNAME \ - { \ - template <typename X> \ - static char test(int, typename X::TNAME*); \ - \ - template <typename X> \ - static int test(boost::intrusive::detail:: \ - LowPriorityConversion<int>, void*); \ - \ - struct DefaultWrap \ - { typedef typename DefaultType::type TNAME; }; \ - \ - static const bool value = (1 == sizeof(test<T>(0, 0))); \ - \ - typedef typename \ - ::boost::intrusive::detail::eval_if_c \ - < value \ - , ::boost::intrusive::detail::identity<T> \ - , ::boost::intrusive::detail::identity<DefaultWrap> \ - >::type::TNAME type; \ - }; \ -// - -#define BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_DEFAULT(INSTANTIATION_NS_PREFIX, T, TNAME, TIMPL) \ - typename INSTANTIATION_NS_PREFIX \ - boost_intrusive_default_type_ ## TNAME< T, TIMPL >::type \ -// - -#define BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_EVAL_DEFAULT(INSTANTIATION_NS_PREFIX, T, TNAME, TIMPL) \ - typename INSTANTIATION_NS_PREFIX \ - boost_intrusive_eval_default_type_ ## TNAME< T, TIMPL >::type \ -// - -}}} //namespace boost::intrusive::detail - -#include <boost/intrusive/detail/has_member_function_callable_with.hpp> - -#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME pointer_to -#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_BEGIN namespace boost { namespace intrusive { namespace detail { -#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_END }}} -#define BOOST_PP_ITERATION_PARAMS_1 (3, (0, 1, <boost/intrusive/detail/has_member_function_callable_with.hpp>)) -#include BOOST_PP_ITERATE() - -#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME static_cast_from -#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_BEGIN namespace boost { namespace intrusive { namespace detail { -#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_END }}} -#define BOOST_PP_ITERATION_PARAMS_1 (3, (0, 1, <boost/intrusive/detail/has_member_function_callable_with.hpp>)) -#include BOOST_PP_ITERATE() - -#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME const_cast_from -#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_BEGIN namespace boost { namespace intrusive { namespace detail { -#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_END }}} -#define BOOST_PP_ITERATION_PARAMS_1 (3, (0, 1, <boost/intrusive/detail/has_member_function_callable_with.hpp>)) -#include BOOST_PP_ITERATE() - -#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME dynamic_cast_from -#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_BEGIN namespace boost { namespace intrusive { namespace detail { -#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_END }}} -#define BOOST_PP_ITERATION_PARAMS_1 (3, (0, 1, <boost/intrusive/detail/has_member_function_callable_with.hpp>)) -#include BOOST_PP_ITERATE() - -namespace boost { -namespace intrusive { -namespace detail { - -BOOST_INTRUSIVE_INSTANTIATE_DEFAULT_TYPE_TMPLT(element_type) -BOOST_INTRUSIVE_INSTANTIATE_DEFAULT_TYPE_TMPLT(difference_type) - -////////////////////// -//struct first_param -////////////////////// - -template <typename T> struct first_param -{ typedef void type; }; - -#if !defined(BOOST_NO_VARIADIC_TEMPLATES) - - template <template <typename, typename...> class TemplateClass, typename T, typename... Args> - struct first_param< TemplateClass<T, Args...> > - { - typedef T type; - }; - -#else //C++03 compilers - - #define BOOST_PP_LOCAL_MACRO(n) \ - template < template <typename \ - BOOST_PP_ENUM_TRAILING(n, BOOST_INTRUSIVE_PP_IDENTITY, typename) > \ - class TemplateClass \ - , typename T BOOST_PP_ENUM_TRAILING_PARAMS(n, class P)> \ - struct first_param \ - < TemplateClass<T BOOST_PP_ENUM_TRAILING_PARAMS(n, P)> > \ - { \ - typedef T type; \ - }; \ - // - #define BOOST_PP_LOCAL_LIMITS (0, BOOST_INTRUSIVE_MAX_CONSTRUCTOR_PARAMETERS) - #include BOOST_PP_LOCAL_ITERATE() - -#endif //!defined(BOOST_NO_VARIADIC_TEMPLATES) - -/////////////////////////// -//struct type_rebind_mode -/////////////////////////// -template <typename Ptr, typename T> -struct type_has_rebind -{ - template <typename X> - static char test(int, typename X::template rebind<T>*); - - template <typename X> - static int test(boost::intrusive::detail::LowPriorityConversion<int>, void*); - - static const bool value = (1 == sizeof(test<Ptr>(0, 0))); -}; - -template <typename Ptr, typename T> -struct type_has_rebind_other -{ - template <typename X> - static char test(int, typename X::template rebind<T>::other*); - - template <typename X> - static int test(boost::intrusive::detail::LowPriorityConversion<int>, void*); - - static const bool value = (1 == sizeof(test<Ptr>(0, 0))); -}; - -template <typename Ptr, typename T> -struct type_rebind_mode -{ - template <typename X> - static char test(int, typename X::template rebind<T>::other*); - - template <typename X> - static int test(boost::intrusive::detail::LowPriorityConversion<int>, void*); - - static const unsigned int rebind = (unsigned int)type_has_rebind<Ptr, T>::value; - static const unsigned int rebind_other = (unsigned int)type_has_rebind_other<Ptr, T>::value; - static const unsigned int mode = rebind + rebind*rebind_other; -}; - -//////////////////////// -//struct type_rebinder -//////////////////////// -template <typename Ptr, typename U, unsigned int RebindMode = type_rebind_mode<Ptr, U>::mode> -struct type_rebinder; - -// Implementation of pointer_traits<Ptr>::rebind if Ptr has -// its own rebind::other type (C++03) -template <typename Ptr, typename U> -struct type_rebinder< Ptr, U, 2u > -{ - typedef typename Ptr::template rebind<U>::other type; -}; - -// Implementation of pointer_traits<Ptr>::rebind if Ptr has -// its own rebind template. -template <typename Ptr, typename U> -struct type_rebinder< Ptr, U, 1u > -{ - typedef typename Ptr::template rebind<U> type; -}; - -// Specialization of pointer_traits<Ptr>::rebind if Ptr does not -// have its own rebind template but has a the form Ptr<class T, -// OtherArgs>, where OtherArgs comprises zero or more type parameters. -// Many pointers fit this form, hence many pointers will get a -// reasonable default for rebind. -#if !defined(BOOST_NO_VARIADIC_TEMPLATES) - -template <template <class, class...> class Ptr, typename T, class... Tn, class U> -struct type_rebinder<Ptr<T, Tn...>, U, 0u > -{ - typedef Ptr<U, Tn...> type; -}; - -#else //C++03 compilers - -#define BOOST_PP_LOCAL_MACRO(n) \ -template < template <typename \ - BOOST_PP_ENUM_TRAILING(n, BOOST_INTRUSIVE_PP_IDENTITY, typename) > \ - class Ptr \ - , typename T BOOST_PP_ENUM_TRAILING_PARAMS(n, class P) \ - , class U> \ -struct type_rebinder \ - < Ptr<T BOOST_PP_ENUM_TRAILING_PARAMS(n, P)>, U, 0u > \ -{ \ - typedef Ptr<U BOOST_PP_ENUM_TRAILING_PARAMS(n, P)> type; \ -}; \ -// -#define BOOST_PP_LOCAL_LIMITS (0, BOOST_INTRUSIVE_MAX_CONSTRUCTOR_PARAMETERS) -#include BOOST_PP_LOCAL_ITERATE() - -#endif //!defined(BOOST_NO_VARIADIC_TEMPLATES) - -} //namespace detail { -} //namespace intrusive { -} //namespace boost { - -#include <boost/intrusive/detail/config_end.hpp> - -#endif // ! defined(BOOST_INTRUSIVE_ALLOCATOR_MEMORY_UTIL_HPP) diff --git a/src/third_party/boost/boost/intrusive/detail/mpl.hpp b/src/third_party/boost/boost/intrusive/detail/mpl.hpp deleted file mode 100644 index 075381cae28..00000000000 --- a/src/third_party/boost/boost/intrusive/detail/mpl.hpp +++ /dev/null @@ -1,355 +0,0 @@ -///////////////////////////////////////////////////////////////////////////// -// -// (C) Copyright Ion Gaztanaga 2006-2009 -// -// Distributed under the Boost Software License, Version 1.0. -// (See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) -// -// See http://www.boost.org/libs/intrusive for documentation. -// -///////////////////////////////////////////////////////////////////////////// - -#ifndef BOOST_INTRUSIVE_DETAIL_MPL_HPP -#define BOOST_INTRUSIVE_DETAIL_MPL_HPP - -#include <boost/intrusive/detail/config_begin.hpp> -#include <cstddef> - -namespace boost { -namespace intrusive { -namespace detail { - -typedef char one; -struct two {one _[2];}; - -template< bool C_ > -struct bool_ -{ - static const bool value = C_; -}; - -typedef bool_<true> true_; -typedef bool_<false> false_; - -typedef true_ true_type; -typedef false_ false_type; - -typedef char yes_type; -struct no_type -{ - char padding[8]; -}; - -template <bool B, class T = void> -struct enable_if_c { - typedef T type; -}; - -template <class T> -struct enable_if_c<false, T> {}; - -template <class Cond, class T = void> -struct enable_if : public enable_if_c<Cond::value, T>{}; - -template<class F, class Param> -struct apply -{ - typedef typename F::template apply<Param>::type type; -}; - -template <class T, class U> -class is_convertible -{ - typedef char true_t; - class false_t { char dummy[2]; }; - static true_t dispatch(U); - static false_t dispatch(...); - static const T &trigger(); - public: - static const bool value = sizeof(dispatch(trigger())) == sizeof(true_t); -}; - -template< - bool C - , typename T1 - , typename T2 - > -struct if_c -{ - typedef T1 type; -}; - -template< - typename T1 - , typename T2 - > -struct if_c<false,T1,T2> -{ - typedef T2 type; -}; - -template< - typename C - , typename T1 - , typename T2 - > -struct if_ -{ - typedef typename if_c<0 != C::value, T1, T2>::type type; -}; - -template< - bool C - , typename F1 - , typename F2 - > -struct eval_if_c - : if_c<C,F1,F2>::type -{}; - -template< - typename C - , typename T1 - , typename T2 - > -struct eval_if - : if_<C,T1,T2>::type -{}; - -// identity is an extension: it is not part of the standard. -template <class T> -struct identity -{ - typedef T type; -}; - -#if defined(BOOST_MSVC) || defined(__BORLANDC_) -#define BOOST_INTRUSIVE_TT_DECL __cdecl -#else -#define BOOST_INTRUSIVE_TT_DECL -#endif - -#if defined(_MSC_EXTENSIONS) && !defined(__BORLAND__) && !defined(_WIN64) -#define BOOST_INTRUSIVE_TT_TEST_MSC_FUNC_SIGS -#endif - -template <typename T> -struct is_unary_or_binary_function_impl -{ static const bool value = false; }; - -// see boost ticket #4094 -// avoid duplicate definitions of is_unary_or_binary_function_impl -#ifndef BOOST_INTRUSIVE_TT_TEST_MSC_FUNC_SIGS - -template <typename R> -struct is_unary_or_binary_function_impl<R (*)()> -{ static const bool value = true; }; - -template <typename R> -struct is_unary_or_binary_function_impl<R (*)(...)> -{ static const bool value = true; }; - -#else // BOOST_INTRUSIVE_TT_TEST_MSC_FUNC_SIGS - -template <typename R> -struct is_unary_or_binary_function_impl<R (__stdcall*)()> -{ static const bool value = true; }; - -template <typename R> -struct is_unary_or_binary_function_impl<R (__fastcall*)()> -{ static const bool value = true; }; - -template <typename R> -struct is_unary_or_binary_function_impl<R (__cdecl*)()> -{ static const bool value = true; }; - -template <typename R> -struct is_unary_or_binary_function_impl<R (__cdecl*)(...)> -{ static const bool value = true; }; - -#endif - -// see boost ticket #4094 -// avoid duplicate definitions of is_unary_or_binary_function_impl -#ifndef BOOST_INTRUSIVE_TT_TEST_MSC_FUNC_SIGS - -template <typename R, class T0> -struct is_unary_or_binary_function_impl<R (*)(T0)> -{ static const bool value = true; }; - -template <typename R, class T0> -struct is_unary_or_binary_function_impl<R (*)(T0...)> -{ static const bool value = true; }; - -#else // BOOST_INTRUSIVE_TT_TEST_MSC_FUNC_SIGS - -template <typename R, class T0> -struct is_unary_or_binary_function_impl<R (__stdcall*)(T0)> -{ static const bool value = true; }; - -template <typename R, class T0> -struct is_unary_or_binary_function_impl<R (__fastcall*)(T0)> -{ static const bool value = true; }; - -template <typename R, class T0> -struct is_unary_or_binary_function_impl<R (__cdecl*)(T0)> -{ static const bool value = true; }; - -template <typename R, class T0> -struct is_unary_or_binary_function_impl<R (__cdecl*)(T0...)> -{ static const bool value = true; }; - -#endif - -// see boost ticket #4094 -// avoid duplicate definitions of is_unary_or_binary_function_impl -#ifndef BOOST_INTRUSIVE_TT_TEST_MSC_FUNC_SIGS - -template <typename R, class T0, class T1> -struct is_unary_or_binary_function_impl<R (*)(T0, T1)> -{ static const bool value = true; }; - -template <typename R, class T0, class T1> -struct is_unary_or_binary_function_impl<R (*)(T0, T1...)> -{ static const bool value = true; }; - -#else // BOOST_INTRUSIVE_TT_TEST_MSC_FUNC_SIGS - -template <typename R, class T0, class T1> -struct is_unary_or_binary_function_impl<R (__stdcall*)(T0, T1)> -{ static const bool value = true; }; - -template <typename R, class T0, class T1> -struct is_unary_or_binary_function_impl<R (__fastcall*)(T0, T1)> -{ static const bool value = true; }; - -template <typename R, class T0, class T1> -struct is_unary_or_binary_function_impl<R (__cdecl*)(T0, T1)> -{ static const bool value = true; }; - -template <typename R, class T0, class T1> -struct is_unary_or_binary_function_impl<R (__cdecl*)(T0, T1...)> -{ static const bool value = true; }; -#endif - -template <typename T> -struct is_unary_or_binary_function_impl<T&> -{ static const bool value = false; }; - -template<typename T> -struct is_unary_or_binary_function -{ static const bool value = is_unary_or_binary_function_impl<T>::value; }; - -//boost::alignment_of yields to 10K lines of preprocessed code, so we -//need an alternative -template <typename T> struct alignment_of; - -template <typename T> -struct alignment_of_hack -{ - char c; - T t; - alignment_of_hack(); -}; - -template <unsigned A, unsigned S> -struct alignment_logic -{ - static const std::size_t value = A < S ? A : S; -}; - -template< typename T > -struct alignment_of -{ - static const std::size_t value = alignment_logic - < sizeof(alignment_of_hack<T>) - sizeof(T) - , sizeof(T) - >::value; -}; - -template <typename T, typename U> -struct is_same -{ - typedef char yes_type; - struct no_type - { - char padding[8]; - }; - - template <typename V> - static yes_type is_same_tester(V*, V*); - static no_type is_same_tester(...); - - static T *t; - static U *u; - - static const bool value = sizeof(yes_type) == sizeof(is_same_tester(t,u)); -}; - -template<typename T> -struct add_const -{ typedef const T type; }; - -template<typename T> -struct remove_const -{ typedef T type; }; - -template<typename T> -struct remove_const<const T> -{ typedef T type; }; - -template<class T> -struct remove_reference -{ - typedef T type; -}; - -template<class T> -struct remove_reference<T&> -{ - typedef T type; -}; - -template<class Class> -class is_empty_class -{ - template <typename T> - struct empty_helper_t1 : public T - { - empty_helper_t1(); - int i[256]; - }; - - struct empty_helper_t2 - { int i[256]; }; - - public: - static const bool value = sizeof(empty_helper_t1<Class>) == sizeof(empty_helper_t2); -}; - -template<std::size_t S> -struct ls_zeros -{ - static const std::size_t value = (S & std::size_t(1)) ? 0 : (1 + ls_zeros<(S>>1u)>::value); -}; - -template<> -struct ls_zeros<0> -{ - static const std::size_t value = 0; -}; - -template<> -struct ls_zeros<1> -{ - static const std::size_t value = 0; -}; - -} //namespace detail -} //namespace intrusive -} //namespace boost - -#include <boost/intrusive/detail/config_end.hpp> - -#endif //BOOST_INTRUSIVE_DETAIL_MPL_HPP diff --git a/src/third_party/boost/boost/intrusive/detail/parent_from_member.hpp b/src/third_party/boost/boost/intrusive/detail/parent_from_member.hpp deleted file mode 100644 index c06d932a70c..00000000000 --- a/src/third_party/boost/boost/intrusive/detail/parent_from_member.hpp +++ /dev/null @@ -1,69 +0,0 @@ -///////////////////////////////////////////////////////////////////////////// -// -// (C) Copyright Ion Gaztanaga 2007-2009 -// -// Distributed under the Boost Software License, Version 1.0. -// (See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) -// -// See http://www.boost.org/libs/intrusive for documentation. -// -///////////////////////////////////////////////////////////////////////////// -#ifndef BOOST_INTRUSIVE_DETAIL_PARENT_FROM_MEMBER_HPP -#define BOOST_INTRUSIVE_DETAIL_PARENT_FROM_MEMBER_HPP - -#include <boost/intrusive/detail/config_begin.hpp> -#include <cstddef> - -#if defined(BOOST_MSVC) || ((defined(_WIN32) || defined(__WIN32__) || defined(WIN32)) && defined(BOOST_INTEL)) - -#define BOOST_INTRUSIVE_MSVC_COMPLIANT_PTR_TO_MEMBER -#include <boost/cstdint.hpp> -#endif - -namespace boost { -namespace intrusive { -namespace detail { - -template<class Parent, class Member> -inline std::ptrdiff_t offset_from_pointer_to_member(const Member Parent::* ptr_to_member) -{ - //The implementation of a pointer to member is compiler dependent. - #if defined(BOOST_INTRUSIVE_MSVC_COMPLIANT_PTR_TO_MEMBER) - //msvc compliant compilers use their the first 32 bits as offset (even in 64 bit mode) - return *(const boost::int32_t*)(void*)&ptr_to_member; - //This works with gcc, msvc, ac++, ibmcpp - #elif defined(__GNUC__) || defined(__HP_aCC) || defined(BOOST_INTEL) || \ - defined(__IBMCPP__) || defined(__DECCXX) - const Parent * const parent = 0; - const char *const member = reinterpret_cast<const char*>(&(parent->*ptr_to_member)); - return std::ptrdiff_t(member - reinterpret_cast<const char*>(parent)); - #else - //This is the traditional C-front approach: __MWERKS__, __DMC__, __SUNPRO_CC - return (*(const std::ptrdiff_t*)(void*)&ptr_to_member) - 1; - #endif -} - -template<class Parent, class Member> -inline Parent *parent_from_member(Member *member, const Member Parent::* ptr_to_member) -{ - return (Parent*)((char*)member - offset_from_pointer_to_member(ptr_to_member)); -} - -template<class Parent, class Member> -inline const Parent *parent_from_member(const Member *member, const Member Parent::* ptr_to_member) -{ - return (const Parent*)((const char*)member - offset_from_pointer_to_member(ptr_to_member)); -} - -} //namespace detail { -} //namespace intrusive { -} //namespace boost { - -#ifdef BOOST_INTRUSIVE_MSVC_COMPLIANT_PTR_TO_MEMBER -#undef BOOST_INTRUSIVE_MSVC_COMPLIANT_PTR_TO_MEMBER -#endif - -#include <boost/intrusive/detail/config_end.hpp> - -#endif //#ifndef BOOST_INTRUSIVE_DETAIL_PARENT_FROM_MEMBER_HPP diff --git a/src/third_party/boost/boost/intrusive/detail/preprocessor.hpp b/src/third_party/boost/boost/intrusive/detail/preprocessor.hpp deleted file mode 100644 index de662809e3d..00000000000 --- a/src/third_party/boost/boost/intrusive/detail/preprocessor.hpp +++ /dev/null @@ -1,52 +0,0 @@ -////////////////////////////////////////////////////////////////////////////// -// -// (C) Copyright Ion Gaztanaga 2008-2011. Distributed under the Boost -// Software License, Version 1.0. (See accompanying file -// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -// -// See http://www.boost.org/libs/intrusive for documentation. -// -////////////////////////////////////////////////////////////////////////////// - -#ifndef BOOST_INTRUSIVE_DETAIL_PREPROCESSOR_HPP -#define BOOST_INTRUSIVE_DETAIL_PREPROCESSOR_HPP - -#if (defined _MSC_VER) && (_MSC_VER >= 1200) -# pragma once -#endif - -#include <boost/intrusive/detail/config_begin.hpp> -#include <boost/intrusive/detail/workaround.hpp> - -#include <boost/preprocessor/iteration/local.hpp> -#include <boost/preprocessor/punctuation/paren_if.hpp> -#include <boost/preprocessor/punctuation/comma_if.hpp> -#include <boost/preprocessor/control/expr_if.hpp> -#include <boost/preprocessor/cat.hpp> -#include <boost/preprocessor/repetition/enum.hpp> -#include <boost/preprocessor/repetition/enum_params.hpp> -#include <boost/preprocessor/repetition/enum_trailing_params.hpp> -#include <boost/preprocessor/repetition/enum_trailing.hpp> -#include <boost/preprocessor/repetition/enum_shifted_params.hpp> -#include <boost/preprocessor/repetition/enum_shifted.hpp> -#include <boost/preprocessor/repetition/repeat.hpp> -#include <boost/preprocessor/logical/not.hpp> -#include <boost/preprocessor/arithmetic/sub.hpp> -#include <boost/preprocessor/arithmetic/add.hpp> -#include <boost/preprocessor/iteration/iterate.hpp> - -#define BOOST_INTRUSIVE_MAX_CONSTRUCTOR_PARAMETERS 10 - -#define BOOST_INTRUSIVE_PP_IDENTITY(z, n, data) data - -#define BOOST_INTRUSIVE_PP_DECLVAL(z, n, data) \ -boost::move_detail::declval< BOOST_PP_CAT(P, n) >() \ -//! - -#define BOOST_INTRUSIVE_PP_TEMPLATE_PARAM_VOID_DEFAULT(z, n, data) \ - BOOST_PP_CAT(class P, n) = void \ -//! - -#include <boost/intrusive/detail/config_end.hpp> - -#endif //#ifndef BOOST_INTRUSIVE_DETAIL_PREPROCESSOR_HPP diff --git a/src/third_party/boost/boost/intrusive/detail/rbtree_node.hpp b/src/third_party/boost/boost/intrusive/detail/rbtree_node.hpp deleted file mode 100644 index dbe0130024a..00000000000 --- a/src/third_party/boost/boost/intrusive/detail/rbtree_node.hpp +++ /dev/null @@ -1,177 +0,0 @@ -///////////////////////////////////////////////////////////////////////////// -// -// (C) Copyright Olaf Krzikalla 2004-2006. -// (C) Copyright Ion Gaztanaga 2006-2009. -// -// Distributed under the Boost Software License, Version 1.0. -// (See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) -// -// See http://www.boost.org/libs/intrusive for documentation. -// -///////////////////////////////////////////////////////////////////////////// - -#ifndef BOOST_INTRUSIVE_RBTREE_NODE_HPP -#define BOOST_INTRUSIVE_RBTREE_NODE_HPP - -#include <boost/intrusive/detail/config_begin.hpp> -#include <iterator> -#include <boost/intrusive/pointer_traits.hpp> -#include <boost/intrusive/rbtree_algorithms.hpp> -#include <boost/intrusive/pointer_plus_bits.hpp> -#include <boost/intrusive/detail/mpl.hpp> - -namespace boost { -namespace intrusive { - -///////////////////////////////////////////////////////////////////////////// -// // -// Generic node_traits for any pointer type // -// // -///////////////////////////////////////////////////////////////////////////// - -//This is the compact representation: 3 pointers -template<class VoidPointer> -struct compact_rbtree_node -{ - typedef typename pointer_traits - <VoidPointer>::template rebind_pointer - <compact_rbtree_node<VoidPointer> >::type node_ptr; - enum color { red_t, black_t }; - node_ptr parent_, left_, right_; -}; - -//This is the normal representation: 3 pointers + enum -template<class VoidPointer> -struct rbtree_node -{ - typedef typename pointer_traits - <VoidPointer>::template rebind_pointer - <rbtree_node<VoidPointer> >::type node_ptr; - - enum color { red_t, black_t }; - node_ptr parent_, left_, right_; - color color_; -}; - -//This is the default node traits implementation -//using a node with 3 generic pointers plus an enum -template<class VoidPointer> -struct default_rbtree_node_traits_impl -{ - typedef rbtree_node<VoidPointer> node; - - typedef typename pointer_traits - <VoidPointer>::template rebind_pointer<node>::type node_ptr; - typedef typename pointer_traits - <VoidPointer>::template rebind_pointer<const node>::type const_node_ptr; - - typedef typename node::color color; - - static const node_ptr & get_parent(const const_node_ptr & n) - { return n->parent_; } - - static void set_parent(const node_ptr & n, const node_ptr & p) - { n->parent_ = p; } - - static const node_ptr & get_left(const const_node_ptr & n) - { return n->left_; } - - static void set_left(const node_ptr & n, const node_ptr & l) - { n->left_ = l; } - - static const node_ptr & get_right(const const_node_ptr & n) - { return n->right_; } - - static void set_right(const node_ptr & n, const node_ptr & r) - { n->right_ = r; } - - static color get_color(const const_node_ptr & n) - { return n->color_; } - - static void set_color(const node_ptr & n, color c) - { n->color_ = c; } - - static color black() - { return node::black_t; } - - static color red() - { return node::red_t; } -}; - -//This is the compact node traits implementation -//using a node with 3 generic pointers -template<class VoidPointer> -struct compact_rbtree_node_traits_impl -{ - typedef compact_rbtree_node<VoidPointer> node; - typedef typename pointer_traits - <VoidPointer>::template rebind_pointer<node>::type node_ptr; - typedef typename pointer_traits - <VoidPointer>::template rebind_pointer<const node>::type const_node_ptr; - - typedef pointer_plus_bits<node_ptr, 1> ptr_bit; - - typedef typename node::color color; - - static node_ptr get_parent(const const_node_ptr & n) - { return ptr_bit::get_pointer(n->parent_); } - - static void set_parent(const node_ptr & n, const node_ptr & p) - { ptr_bit::set_pointer(n->parent_, p); } - - static const node_ptr & get_left(const const_node_ptr & n) - { return n->left_; } - - static void set_left(const node_ptr & n, const node_ptr & l) - { n->left_ = l; } - - static const node_ptr & get_right(const const_node_ptr & n) - { return n->right_; } - - static void set_right(const node_ptr & n, const node_ptr & r) - { n->right_ = r; } - - static color get_color(const const_node_ptr & n) - { return (color)ptr_bit::get_bits(n->parent_); } - - static void set_color(const node_ptr & n, color c) - { ptr_bit::set_bits(n->parent_, c != 0); } - - static color black() - { return node::black_t; } - - static color red() - { return node::red_t; } -}; - -//Dispatches the implementation based on the boolean -template<class VoidPointer, bool Compact> -struct rbtree_node_traits_dispatch - : public default_rbtree_node_traits_impl<VoidPointer> -{}; - -template<class VoidPointer> -struct rbtree_node_traits_dispatch<VoidPointer, true> - : public compact_rbtree_node_traits_impl<VoidPointer> -{}; - -//Inherit from the detail::link_dispatch depending on the embedding capabilities -template<class VoidPointer, bool OptimizeSize = false> -struct rbtree_node_traits - : public rbtree_node_traits_dispatch - < VoidPointer - , OptimizeSize && - (max_pointer_plus_bits - < VoidPointer - , detail::alignment_of<compact_rbtree_node<VoidPointer> >::value - >::value >= 1) - > -{}; - -} //namespace intrusive -} //namespace boost - -#include <boost/intrusive/detail/config_end.hpp> - -#endif //BOOST_INTRUSIVE_RBTREE_NODE_HPP diff --git a/src/third_party/boost/boost/intrusive/detail/slist_node.hpp b/src/third_party/boost/boost/intrusive/detail/slist_node.hpp deleted file mode 100644 index 5b96c097425..00000000000 --- a/src/third_party/boost/boost/intrusive/detail/slist_node.hpp +++ /dev/null @@ -1,163 +0,0 @@ -///////////////////////////////////////////////////////////////////////////// -// -// (C) Copyright Olaf Krzikalla 2004-2006. -// (C) Copyright Ion Gaztanaga 2006-2009 -// -// Distributed under the Boost Software License, Version 1.0. -// (See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) -// -// See http://www.boost.org/libs/intrusive for documentation. -// -///////////////////////////////////////////////////////////////////////////// - -#ifndef BOOST_INTRUSIVE_SLIST_NODE_HPP -#define BOOST_INTRUSIVE_SLIST_NODE_HPP - -#include <boost/intrusive/detail/config_begin.hpp> -#include <iterator> -#include <boost/intrusive/detail/assert.hpp> -#include <boost/intrusive/pointer_traits.hpp> - -namespace boost { -namespace intrusive { - -template<class VoidPointer> -struct slist_node -{ - typedef typename pointer_traits - <VoidPointer>::template rebind_pointer<slist_node>::type node_ptr; - node_ptr next_; -}; - -// slist_node_traits can be used with circular_slist_algorithms and supplies -// a slist_node holding the pointers needed for a singly-linked list -// it is used by slist_base_hook and slist_member_hook -template<class VoidPointer> -struct slist_node_traits -{ - typedef slist_node<VoidPointer> node; - typedef typename pointer_traits - <VoidPointer>::template rebind_pointer<node>::type node_ptr; - typedef typename pointer_traits - <VoidPointer>::template rebind_pointer<const node>::type const_node_ptr; - - static const node_ptr &get_next(const const_node_ptr & n) - { return n->next_; } - - static void set_next(const node_ptr & n, const node_ptr & next) - { n->next_ = next; } -}; - -// slist_iterator provides some basic functions for a -// node oriented bidirectional iterator: -template<class Container, bool IsConst> -class slist_iterator - : public std::iterator - < std::forward_iterator_tag - , typename Container::value_type - , typename Container::difference_type - , typename detail::if_c<IsConst,typename Container::const_pointer,typename Container::pointer>::type - , typename detail::if_c<IsConst,typename Container::const_reference,typename Container::reference>::type - > -{ - protected: - typedef typename Container::real_value_traits real_value_traits; - typedef typename real_value_traits::node_traits node_traits; - typedef typename node_traits::node node; - typedef typename node_traits::node_ptr node_ptr; - typedef typename pointer_traits - <node_ptr>::template rebind_pointer <void>::type void_pointer; - static const bool store_container_ptr = - detail::store_cont_ptr_on_it<Container>::value; - - public: - typedef typename Container::value_type value_type; - typedef typename detail::if_c<IsConst,typename Container::const_pointer,typename Container::pointer>::type pointer; - typedef typename detail::if_c<IsConst,typename Container::const_reference,typename Container::reference>::type reference; - - slist_iterator() - : members_ (node_ptr(), 0) - {} - - explicit slist_iterator(const node_ptr & node, const Container *cont_ptr) - : members_ (node, cont_ptr) - {} - - slist_iterator(slist_iterator<Container, false> const& other) - : members_(other.pointed_node(), other.get_container()) - {} - - const node_ptr &pointed_node() const - { return members_.nodeptr_; } - - slist_iterator &operator=(const node_ptr &node) - { members_.nodeptr_ = node; return static_cast<slist_iterator&>(*this); } - - public: - slist_iterator& operator++() - { - members_.nodeptr_ = node_traits::get_next(members_.nodeptr_); - return static_cast<slist_iterator&> (*this); - } - - slist_iterator operator++(int) - { - slist_iterator result (*this); - members_.nodeptr_ = node_traits::get_next(members_.nodeptr_); - return result; - } - - friend bool operator== (const slist_iterator& l, const slist_iterator& r) - { return l.pointed_node() == r.pointed_node(); } - - friend bool operator!= (const slist_iterator& l, const slist_iterator& r) - { return !(l == r); } - - reference operator*() const - { return *operator->(); } - - pointer operator->() const - { return this->get_real_value_traits()->to_value_ptr(members_.nodeptr_); } - - const Container *get_container() const - { - if(store_container_ptr) - return static_cast<const Container*>(members_.get_ptr()); - else - return 0; - } - - slist_iterator<Container, false> unconst() const - { return slist_iterator<Container, false>(this->pointed_node(), this->get_container()); } - - const real_value_traits *get_real_value_traits() const - { - if(store_container_ptr) - return &this->get_container()->get_real_value_traits(); - else - return 0; - } - - private: - struct members - : public detail::select_constptr - <void_pointer, store_container_ptr>::type - { - typedef typename detail::select_constptr - <void_pointer, store_container_ptr>::type Base; - - members(const node_ptr &n_ptr, const void *cont) - : Base(cont), nodeptr_(n_ptr) - {} - - node_ptr nodeptr_; - } members_; -}; - -} //namespace intrusive -} //namespace boost - -#include <boost/intrusive/detail/config_end.hpp> - -#endif //BOOST_INTRUSIVE_SLIST_NODE_HPP diff --git a/src/third_party/boost/boost/intrusive/detail/transform_iterator.hpp b/src/third_party/boost/boost/intrusive/detail/transform_iterator.hpp deleted file mode 100644 index 15ef3ab2c97..00000000000 --- a/src/third_party/boost/boost/intrusive/detail/transform_iterator.hpp +++ /dev/null @@ -1,173 +0,0 @@ -///////////////////////////////////////////////////////////////////////////// -// -// (C) Copyright Ion Gaztanaga 2007-2009 -// -// Distributed under the Boost Software License, Version 1.0. -// (See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) -// -// See http://www.boost.org/libs/intrusive for documentation. -// -///////////////////////////////////////////////////////////////////////////// - -#ifndef BOOST_INTRUSIVE_DETAIL_TRANSFORM_ITERATOR_HPP -#define BOOST_INTRUSIVE_DETAIL_TRANSFORM_ITERATOR_HPP - -#include <boost/intrusive/detail/config_begin.hpp> -#include <iterator> -#include <boost/intrusive/detail/mpl.hpp> - -namespace boost { -namespace intrusive { -namespace detail { - -template <class PseudoReference> -struct operator_arrow_proxy -{ - operator_arrow_proxy(const PseudoReference &px) - : m_value(px) - {} - - PseudoReference* operator->() const { return &m_value; } - // This function is needed for MWCW and BCC, which won't call operator-> - // again automatically per 13.3.1.2 para 8 -// operator T*() const { return &m_value; } - mutable PseudoReference m_value; -}; - -template <class T> -struct operator_arrow_proxy<T&> -{ - operator_arrow_proxy(T &px) - : m_value(px) - {} - - T* operator->() const { return &m_value; } - // This function is needed for MWCW and BCC, which won't call operator-> - // again automatically per 13.3.1.2 para 8 -// operator T*() const { return &m_value; } - T &m_value; -}; - -template <class Iterator, class UnaryFunction> -class transform_iterator - : public std::iterator - < typename Iterator::iterator_category - , typename detail::remove_reference<typename UnaryFunction::result_type>::type - , typename Iterator::difference_type - , operator_arrow_proxy<typename UnaryFunction::result_type> - , typename UnaryFunction::result_type> -{ - public: - explicit transform_iterator(const Iterator &it, const UnaryFunction &f = UnaryFunction()) - : members_(it, f) - {} - - explicit transform_iterator() - : members_() - {} - - Iterator get_it() const - { return members_.m_it; } - - //Constructors - transform_iterator& operator++() - { increment(); return *this; } - - transform_iterator operator++(int) - { - transform_iterator result (*this); - increment(); - return result; - } - - friend bool operator== (const transform_iterator& i, const transform_iterator& i2) - { return i.equal(i2); } - - friend bool operator!= (const transform_iterator& i, const transform_iterator& i2) - { return !(i == i2); } - -/* - friend bool operator> (const transform_iterator& i, const transform_iterator& i2) - { return i2 < i; } - - friend bool operator<= (const transform_iterator& i, const transform_iterator& i2) - { return !(i > i2); } - - friend bool operator>= (const transform_iterator& i, const transform_iterator& i2) - { return !(i < i2); } -*/ - friend typename Iterator::difference_type operator- (const transform_iterator& i, const transform_iterator& i2) - { return i2.distance_to(i); } - - //Arithmetic - transform_iterator& operator+=(typename Iterator::difference_type off) - { this->advance(off); return *this; } - - transform_iterator operator+(typename Iterator::difference_type off) const - { - transform_iterator other(*this); - other.advance(off); - return other; - } - - friend transform_iterator operator+(typename Iterator::difference_type off, const transform_iterator& right) - { return right + off; } - - transform_iterator& operator-=(typename Iterator::difference_type off) - { this->advance(-off); return *this; } - - transform_iterator operator-(typename Iterator::difference_type off) const - { return *this + (-off); } - - typename UnaryFunction::result_type operator*() const - { return dereference(); } - - operator_arrow_proxy<typename UnaryFunction::result_type> - operator->() const - { return operator_arrow_proxy<typename UnaryFunction::result_type>(dereference()); } - - private: - struct members - : UnaryFunction - { - members(const Iterator &it, const UnaryFunction &f) - : UnaryFunction(f), m_it(it) - {} - - members() - {} - - Iterator m_it; - } members_; - - - void increment() - { ++members_.m_it; } - - void decrement() - { --members_.m_it; } - - bool equal(const transform_iterator &other) const - { return members_.m_it == other.members_.m_it; } - - bool less(const transform_iterator &other) const - { return other.members_.m_it < members_.m_it; } - - typename UnaryFunction::result_type dereference() const - { return members_(*members_.m_it); } - - void advance(typename Iterator::difference_type n) - { std::advance(members_.m_it, n); } - - typename Iterator::difference_type distance_to(const transform_iterator &other)const - { return std::distance(other.members_.m_it, members_.m_it); } -}; - -} //namespace detail -} //namespace intrusive -} //namespace boost - -#include <boost/intrusive/detail/config_end.hpp> - -#endif //BOOST_INTRUSIVE_DETAIL_TRANSFORM_ITERATOR_HPP diff --git a/src/third_party/boost/boost/intrusive/detail/tree_algorithms.hpp b/src/third_party/boost/boost/intrusive/detail/tree_algorithms.hpp deleted file mode 100644 index 8d31d9d710e..00000000000 --- a/src/third_party/boost/boost/intrusive/detail/tree_algorithms.hpp +++ /dev/null @@ -1,1697 +0,0 @@ -///////////////////////////////////////////////////////////////////////////// -// -// (C) Copyright Ion Gaztanaga 2007. -// -// Distributed under the Boost Software License, Version 1.0. -// (See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) -// -// See http://www.boost.org/libs/intrusive for documentation. -// -///////////////////////////////////////////////////////////////////////////// - -#ifndef BOOST_INTRUSIVE_TREE_ALGORITHMS_HPP -#define BOOST_INTRUSIVE_TREE_ALGORITHMS_HPP - -#include <boost/intrusive/detail/config_begin.hpp> -#include <boost/intrusive/detail/assert.hpp> -#include <boost/intrusive/intrusive_fwd.hpp> -#include <cstddef> -#include <boost/intrusive/detail/utilities.hpp> -#include <boost/intrusive/pointer_traits.hpp> - -namespace boost { -namespace intrusive { -namespace detail { - -//! This is an implementation of a binary search tree. -//! A node in the search tree has references to its children and its parent. This -//! is to allow traversal of the whole tree from a given node making the -//! implementation of iterator a pointer to a node. -//! At the top of the tree a node is used specially. This node's parent pointer -//! is pointing to the root of the tree. Its left pointer points to the -//! leftmost node in the tree and the right pointer to the rightmost one. -//! This node is used to represent the end-iterator. -//! -//! +---------+ -//! header------------------------------>| | -//! | | -//! +----------(left)--------| |--------(right)---------+ -//! | +---------+ | -//! | | | -//! | | (parent) | -//! | | | -//! | | | -//! | +---------+ | -//! root of tree ..|......................> | | | -//! | | D | | -//! | | | | -//! | +-------+---------+-------+ | -//! | | | | -//! | | | | -//! | | | | -//! | | | | -//! | | | | -//! | +---------+ +---------+ | -//! | | | | | | -//! | | B | | F | | -//! | | | | | | -//! | +--+---------+--+ +--+---------+--+ | -//! | | | | | | -//! | | | | | | -//! | | | | | | -//! | +---+-----+ +-----+---+ +---+-----+ +-----+---+ | -//! +-->| | | | | | | |<--+ -//! | A | | C | | E | | G | -//! | | | | | | | | -//! +---------+ +---------+ +---------+ +---------+ -//! - -//! tree_algorithms is configured with a NodeTraits class, which encapsulates the -//! information about the node to be manipulated. NodeTraits must support the -//! following interface: -//! -//! <b>Typedefs</b>: -//! -//! <tt>node</tt>: The type of the node that forms the circular list -//! -//! <tt>node_ptr</tt>: A pointer to a node -//! -//! <tt>const_node_ptr</tt>: A pointer to a const node -//! -//! <b>Static functions</b>: -//! -//! <tt>static node_ptr get_parent(const_node_ptr n);</tt> -//! -//! <tt>static void set_parent(node_ptr n, node_ptr parent);</tt> -//! -//! <tt>static node_ptr get_left(const_node_ptr n);</tt> -//! -//! <tt>static void set_left(node_ptr n, node_ptr left);</tt> -//! -//! <tt>static node_ptr get_right(const_node_ptr n);</tt> -//! -//! <tt>static void set_right(node_ptr n, node_ptr right);</tt> -template<class NodeTraits> -class tree_algorithms -{ - public: - typedef typename NodeTraits::node node; - typedef NodeTraits node_traits; - typedef typename NodeTraits::node_ptr node_ptr; - typedef typename NodeTraits::const_node_ptr const_node_ptr; - - //! This type is the information that will be filled by insert_unique_check - struct insert_commit_data - { - insert_commit_data() - : link_left(false) - , node() - {} - bool link_left; - node_ptr node; - }; - - struct nop_erase_fixup - { - void operator()(const node_ptr&, const node_ptr&){} - }; - - /// @cond - private: - template<class Disposer> - struct dispose_subtree_disposer - { - dispose_subtree_disposer(Disposer &disp, const node_ptr & subtree) - : disposer_(&disp), subtree_(subtree) - {} - - void release() - { disposer_ = 0; } - - ~dispose_subtree_disposer() - { - if(disposer_){ - dispose_subtree(subtree_, *disposer_); - } - } - Disposer *disposer_; - node_ptr subtree_; - }; - - static node_ptr uncast(const const_node_ptr & ptr) - { return pointer_traits<node_ptr>::const_cast_from(ptr); } - - /// @endcond - - public: - static node_ptr begin_node(const const_node_ptr & header) - { return node_traits::get_left(header); } - - static node_ptr end_node(const const_node_ptr & header) - { return uncast(header); } - - //! <b>Requires</b>: 'node' is a node of the tree or an node initialized - //! by init(...) or init_node. - //! - //! <b>Effects</b>: Returns true if the node is initialized by init() or init_node(). - //! - //! <b>Complexity</b>: Constant time. - //! - //! <b>Throws</b>: Nothing. - static bool unique(const const_node_ptr & node) - { return !NodeTraits::get_parent(node); } - - static node_ptr get_header(const const_node_ptr & node) - { - node_ptr h = uncast(node); - if(NodeTraits::get_parent(node)){ - h = NodeTraits::get_parent(node); - while(!is_header(h)) - h = NodeTraits::get_parent(h); - } - return h; - } - - //! <b>Requires</b>: node1 and node2 can't be header nodes - //! of two trees. - //! - //! <b>Effects</b>: Swaps two nodes. After the function node1 will be inserted - //! in the position node2 before the function. node2 will be inserted in the - //! position node1 had before the function. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: This function will break container ordering invariants if - //! node1 and node2 are not equivalent according to the ordering rules. - //! - //!Experimental function - static void swap_nodes(const node_ptr & node1, const node_ptr & node2) - { - if(node1 == node2) - return; - - node_ptr header1(get_header(node1)), header2(get_header(node2)); - swap_nodes(node1, header1, node2, header2); - } - - //! <b>Requires</b>: node1 and node2 can't be header nodes - //! of two trees with header header1 and header2. - //! - //! <b>Effects</b>: Swaps two nodes. After the function node1 will be inserted - //! in the position node2 before the function. node2 will be inserted in the - //! position node1 had before the function. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: This function will break container ordering invariants if - //! node1 and node2 are not equivalent according to the ordering rules. - //! - //!Experimental function - static void swap_nodes(const node_ptr & node1, const node_ptr & header1, const node_ptr & node2, const node_ptr & header2) - { - if(node1 == node2) - return; - - //node1 and node2 must not be header nodes - //BOOST_INTRUSIVE_INVARIANT_ASSERT((header1 != node1 && header2 != node2)); - if(header1 != header2){ - //Update header1 if necessary - if(node1 == NodeTraits::get_left(header1)){ - NodeTraits::set_left(header1, node2); - } - - if(node1 == NodeTraits::get_right(header1)){ - NodeTraits::set_right(header1, node2); - } - - if(node1 == NodeTraits::get_parent(header1)){ - NodeTraits::set_parent(header1, node2); - } - - //Update header2 if necessary - if(node2 == NodeTraits::get_left(header2)){ - NodeTraits::set_left(header2, node1); - } - - if(node2 == NodeTraits::get_right(header2)){ - NodeTraits::set_right(header2, node1); - } - - if(node2 == NodeTraits::get_parent(header2)){ - NodeTraits::set_parent(header2, node1); - } - } - else{ - //If both nodes are from the same tree - //Update header if necessary - if(node1 == NodeTraits::get_left(header1)){ - NodeTraits::set_left(header1, node2); - } - else if(node2 == NodeTraits::get_left(header2)){ - NodeTraits::set_left(header2, node1); - } - - if(node1 == NodeTraits::get_right(header1)){ - NodeTraits::set_right(header1, node2); - } - else if(node2 == NodeTraits::get_right(header2)){ - NodeTraits::set_right(header2, node1); - } - - if(node1 == NodeTraits::get_parent(header1)){ - NodeTraits::set_parent(header1, node2); - } - else if(node2 == NodeTraits::get_parent(header2)){ - NodeTraits::set_parent(header2, node1); - } - - //Adjust data in nodes to be swapped - //so that final link swap works as expected - if(node1 == NodeTraits::get_parent(node2)){ - NodeTraits::set_parent(node2, node2); - - if(node2 == NodeTraits::get_right(node1)){ - NodeTraits::set_right(node1, node1); - } - else{ - NodeTraits::set_left(node1, node1); - } - } - else if(node2 == NodeTraits::get_parent(node1)){ - NodeTraits::set_parent(node1, node1); - - if(node1 == NodeTraits::get_right(node2)){ - NodeTraits::set_right(node2, node2); - } - else{ - NodeTraits::set_left(node2, node2); - } - } - } - - //Now swap all the links - node_ptr temp; - //swap left link - temp = NodeTraits::get_left(node1); - NodeTraits::set_left(node1, NodeTraits::get_left(node2)); - NodeTraits::set_left(node2, temp); - //swap right link - temp = NodeTraits::get_right(node1); - NodeTraits::set_right(node1, NodeTraits::get_right(node2)); - NodeTraits::set_right(node2, temp); - //swap parent link - temp = NodeTraits::get_parent(node1); - NodeTraits::set_parent(node1, NodeTraits::get_parent(node2)); - NodeTraits::set_parent(node2, temp); - - //Now adjust adjacent nodes for newly inserted node 1 - if((temp = NodeTraits::get_left(node1))){ - NodeTraits::set_parent(temp, node1); - } - if((temp = NodeTraits::get_right(node1))){ - NodeTraits::set_parent(temp, node1); - } - if((temp = NodeTraits::get_parent(node1)) && - //The header has been already updated so avoid it - temp != header2){ - if(NodeTraits::get_left(temp) == node2){ - NodeTraits::set_left(temp, node1); - } - if(NodeTraits::get_right(temp) == node2){ - NodeTraits::set_right(temp, node1); - } - } - //Now adjust adjacent nodes for newly inserted node 2 - if((temp = NodeTraits::get_left(node2))){ - NodeTraits::set_parent(temp, node2); - } - if((temp = NodeTraits::get_right(node2))){ - NodeTraits::set_parent(temp, node2); - } - if((temp = NodeTraits::get_parent(node2)) && - //The header has been already updated so avoid it - temp != header1){ - if(NodeTraits::get_left(temp) == node1){ - NodeTraits::set_left(temp, node2); - } - if(NodeTraits::get_right(temp) == node1){ - NodeTraits::set_right(temp, node2); - } - } - } - - //! <b>Requires</b>: node_to_be_replaced must be inserted in a tree - //! and new_node must not be inserted in a tree. - //! - //! <b>Effects</b>: Replaces node_to_be_replaced in its position in the - //! tree with new_node. The tree does not need to be rebalanced - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: This function will break container ordering invariants if - //! 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 - static void replace_node(const node_ptr & node_to_be_replaced, const node_ptr & new_node) - { - if(node_to_be_replaced == new_node) - return; - replace_node(node_to_be_replaced, get_header(node_to_be_replaced), new_node); - } - - //! <b>Requires</b>: node_to_be_replaced must be inserted in a tree - //! with header "header" and new_node must not be inserted in a tree. - //! - //! <b>Effects</b>: Replaces node_to_be_replaced in its position in the - //! tree with new_node. The tree does not need to be rebalanced - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: This function will break container ordering invariants if - //! 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 or comparison is needed. - //! - //!Experimental function - static void replace_node(const node_ptr & node_to_be_replaced, const node_ptr & header, const node_ptr & new_node) - { - if(node_to_be_replaced == new_node) - return; - - //Update header if necessary - if(node_to_be_replaced == NodeTraits::get_left(header)){ - NodeTraits::set_left(header, new_node); - } - - if(node_to_be_replaced == NodeTraits::get_right(header)){ - NodeTraits::set_right(header, new_node); - } - - if(node_to_be_replaced == NodeTraits::get_parent(header)){ - NodeTraits::set_parent(header, new_node); - } - - //Now set data from the original node - node_ptr temp; - NodeTraits::set_left(new_node, NodeTraits::get_left(node_to_be_replaced)); - NodeTraits::set_right(new_node, NodeTraits::get_right(node_to_be_replaced)); - NodeTraits::set_parent(new_node, NodeTraits::get_parent(node_to_be_replaced)); - - //Now adjust adjacent nodes for newly inserted node - if((temp = NodeTraits::get_left(new_node))){ - NodeTraits::set_parent(temp, new_node); - } - if((temp = NodeTraits::get_right(new_node))){ - NodeTraits::set_parent(temp, new_node); - } - if((temp = NodeTraits::get_parent(new_node)) && - //The header has been already updated so avoid it - temp != header){ - if(NodeTraits::get_left(temp) == node_to_be_replaced){ - NodeTraits::set_left(temp, new_node); - } - if(NodeTraits::get_right(temp) == node_to_be_replaced){ - NodeTraits::set_right(temp, new_node); - } - } - } - - //! <b>Requires</b>: 'node' is a node from the tree except the header. - //! - //! <b>Effects</b>: Returns the next node of the tree. - //! - //! <b>Complexity</b>: Average constant time. - //! - //! <b>Throws</b>: Nothing. - static node_ptr next_node(const node_ptr & node) - { - node_ptr p_right(NodeTraits::get_right(node)); - if(p_right){ - return minimum(p_right); - } - else { - node_ptr p(node); - node_ptr x = NodeTraits::get_parent(p); - while(p == NodeTraits::get_right(x)){ - p = x; - x = NodeTraits::get_parent(x); - } - return NodeTraits::get_right(p) != x ? x : uncast(p); - } - } - - //! <b>Requires</b>: 'node' is a node from the tree except the leftmost node. - //! - //! <b>Effects</b>: Returns the previous node of the tree. - //! - //! <b>Complexity</b>: Average constant time. - //! - //! <b>Throws</b>: Nothing. - static node_ptr prev_node(const node_ptr & node) - { - if(is_header(node)){ - return NodeTraits::get_right(node); - //return maximum(NodeTraits::get_parent(node)); - } - else if(NodeTraits::get_left(node)){ - return maximum(NodeTraits::get_left(node)); - } - else { - node_ptr p(node); - node_ptr x = NodeTraits::get_parent(p); - while(p == NodeTraits::get_left(x)){ - p = x; - x = NodeTraits::get_parent(x); - } - return x; - } - } - - //! <b>Requires</b>: 'node' is a node of a tree but not the header. - //! - //! <b>Effects</b>: Returns the minimum node of the subtree starting at p. - //! - //! <b>Complexity</b>: Logarithmic to the size of the subtree. - //! - //! <b>Throws</b>: Nothing. - static node_ptr minimum (const node_ptr & node) - { - node_ptr p(node); - for(node_ptr p_left = NodeTraits::get_left(p) - ;p_left - ;p_left = NodeTraits::get_left(p)){ - p = p_left; - } - return p; - } - - //! <b>Requires</b>: 'node' is a node of a tree but not the header. - //! - //! <b>Effects</b>: Returns the maximum node of the subtree starting at p. - //! - //! <b>Complexity</b>: Logarithmic to the size of the subtree. - //! - //! <b>Throws</b>: Nothing. - static node_ptr maximum(const node_ptr & node) - { - node_ptr p(node); - for(node_ptr p_right = NodeTraits::get_right(p) - ;p_right - ;p_right = NodeTraits::get_right(p)){ - p = p_right; - } - return p; - } - - //! <b>Requires</b>: 'node' must not be part of any tree. - //! - //! <b>Effects</b>: After the function unique(node) == true. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Nodes</b>: If node is inserted in a tree, this function corrupts the tree. - static void init(const node_ptr & node) - { - NodeTraits::set_parent(node, node_ptr()); - NodeTraits::set_left(node, node_ptr()); - NodeTraits::set_right(node, node_ptr()); - }; - - //! <b>Effects</b>: Returns true if node is in the same state as if called init(node) - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - static bool inited(const const_node_ptr & node) - { - return !NodeTraits::get_parent(node) && - !NodeTraits::get_left(node) && - !NodeTraits::get_right(node) ; - }; - - //! <b>Requires</b>: node must not be part of any tree. - //! - //! <b>Effects</b>: Initializes the header to represent an empty tree. - //! unique(header) == true. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Nodes</b>: If node is inserted in a tree, this function corrupts the tree. - static void init_header(const node_ptr & header) - { - NodeTraits::set_parent(header, node_ptr()); - NodeTraits::set_left(header, header); - NodeTraits::set_right(header, header); - } - - //! <b>Requires</b>: "disposer" must be an object function - //! taking a node_ptr parameter and shouldn't throw. - //! - //! <b>Effects</b>: Empties the target tree calling - //! <tt>void disposer::operator()(const node_ptr &)</tt> for every node of the tree - //! except the header. - //! - //! <b>Complexity</b>: Linear to the number of element of the source tree plus the. - //! number of elements of tree target tree when calling this function. - //! - //! <b>Throws</b>: If cloner functor throws. If this happens target nodes are disposed. - template<class Disposer> - static void clear_and_dispose(const node_ptr & header, Disposer disposer) - { - node_ptr source_root = NodeTraits::get_parent(header); - if(!source_root) - return; - dispose_subtree(source_root, disposer); - init_header(header); - } - - //! <b>Requires</b>: header is the header of a tree. - //! - //! <b>Effects</b>: Unlinks the leftmost node from the tree, and - //! updates the header link to the new leftmost node. - //! - //! <b>Complexity</b>: Average complexity is constant time. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Notes</b>: This function breaks the tree and the tree can - //! only be used for more unlink_leftmost_without_rebalance calls. - //! This function is normally used to achieve a step by step - //! controlled destruction of the tree. - static node_ptr unlink_leftmost_without_rebalance(const node_ptr & header) - { - node_ptr leftmost = NodeTraits::get_left(header); - if (leftmost == header) - return node_ptr(); - node_ptr leftmost_parent(NodeTraits::get_parent(leftmost)); - node_ptr leftmost_right (NodeTraits::get_right(leftmost)); - bool is_root = leftmost_parent == header; - - if (leftmost_right){ - NodeTraits::set_parent(leftmost_right, leftmost_parent); - NodeTraits::set_left(header, tree_algorithms::minimum(leftmost_right)); - - if (is_root) - NodeTraits::set_parent(header, leftmost_right); - else - NodeTraits::set_left(NodeTraits::get_parent(header), leftmost_right); - } - else if (is_root){ - NodeTraits::set_parent(header, node_ptr()); - NodeTraits::set_left(header, header); - NodeTraits::set_right(header, header); - } - else{ - NodeTraits::set_left(leftmost_parent, node_ptr()); - NodeTraits::set_left(header, leftmost_parent); - } - return leftmost; - } - - //! <b>Requires</b>: node is a node of the tree but it's not the header. - //! - //! <b>Effects</b>: Returns the number of nodes of the subtree. - //! - //! <b>Complexity</b>: Linear time. - //! - //! <b>Throws</b>: Nothing. - static std::size_t count(const const_node_ptr & subtree) - { - if(!subtree) return 0; - std::size_t count = 0; - node_ptr p = minimum(uncast(subtree)); - bool continue_looping = true; - while(continue_looping){ - ++count; - node_ptr p_right(NodeTraits::get_right(p)); - if(p_right){ - p = minimum(p_right); - } - else { - for(;;){ - node_ptr q; - if (p == subtree){ - continue_looping = false; - break; - } - q = p; - p = NodeTraits::get_parent(p); - if (NodeTraits::get_left(p) == q) - break; - } - } - } - return count; - } - - //! <b>Requires</b>: node is a node of the tree but it's not the header. - //! - //! <b>Effects</b>: Returns the number of nodes of the subtree. - //! - //! <b>Complexity</b>: Linear time. - //! - //! <b>Throws</b>: Nothing. - static std::size_t size(const const_node_ptr & header) - { - node_ptr beg(begin_node(header)); - node_ptr end(end_node(header)); - std::size_t i = 0; - for(;beg != end; beg = next_node(beg)) ++i; - return i; - } - - //! <b>Requires</b>: header1 and header2 must be the header nodes - //! of two trees. - //! - //! <b>Effects</b>: Swaps two trees. After the function header1 will contain - //! links to the second tree and header2 will have links to the first tree. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - static void swap_tree(const node_ptr & header1, const node_ptr & header2) - { - if(header1 == header2) - return; - - node_ptr tmp; - - //Parent swap - tmp = NodeTraits::get_parent(header1); - NodeTraits::set_parent(header1, NodeTraits::get_parent(header2)); - NodeTraits::set_parent(header2, tmp); - //Left swap - tmp = NodeTraits::get_left(header1); - NodeTraits::set_left(header1, NodeTraits::get_left(header2)); - NodeTraits::set_left(header2, tmp); - //Right swap - tmp = NodeTraits::get_right(header1); - NodeTraits::set_right(header1, NodeTraits::get_right(header2)); - NodeTraits::set_right(header2, tmp); - - //Now test parent - node_ptr h1_parent(NodeTraits::get_parent(header1)); - if(h1_parent){ - NodeTraits::set_parent(h1_parent, header1); - } - else{ - NodeTraits::set_left(header1, header1); - NodeTraits::set_right(header1, header1); - } - - node_ptr h2_parent(NodeTraits::get_parent(header2)); - if(h2_parent){ - NodeTraits::set_parent(h2_parent, header2); - } - else{ - NodeTraits::set_left(header2, header2); - NodeTraits::set_right(header2, header2); - } - } - - static bool is_header(const const_node_ptr & p) - { - node_ptr p_left (NodeTraits::get_left(p)); - node_ptr p_right(NodeTraits::get_right(p)); - if(!NodeTraits::get_parent(p) || //Header condition when empty tree - (p_left && p_right && //Header always has leftmost and rightmost - (p_left == p_right || //Header condition when only node - (NodeTraits::get_parent(p_left) != p || - NodeTraits::get_parent(p_right) != p )) - //When tree size > 1 headers can't be leftmost's - //and rightmost's parent - )){ - return true; - } - return false; - } - - //! <b>Requires</b>: "header" must be the header node of a tree. - //! KeyNodePtrCompare is a function object that induces a strict weak - //! ordering compatible with the strict weak ordering used to create the - //! the tree. KeyNodePtrCompare can compare KeyType with tree's node_ptrs. - //! - //! <b>Effects</b>: Returns an node_ptr to the element that is equivalent to - //! "key" according to "comp" or "header" if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If "comp" throws. - template<class KeyType, class KeyNodePtrCompare> - static node_ptr find - (const const_node_ptr & header, const KeyType &key, KeyNodePtrCompare comp) - { - node_ptr end = uncast(header); - node_ptr y = lower_bound(header, key, comp); - return (y == end || comp(key, y)) ? end : y; - } - - //! <b>Requires</b>: "header" must be the header node of a tree. - //! KeyNodePtrCompare is a function object that induces a strict weak - //! ordering compatible with the strict weak ordering used to create the - //! the tree. KeyNodePtrCompare can compare KeyType with tree's node_ptrs. - //! - //! <b>Effects</b>: Returns an a pair of node_ptr delimiting a range containing - //! all elements that are equivalent to "key" according to "comp" or an - //! empty range that indicates the position where those elements would be - //! if they there are no equivalent elements. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If "comp" throws. - template<class KeyType, class KeyNodePtrCompare> - static std::pair<node_ptr, node_ptr> equal_range - (const const_node_ptr & header, const KeyType &key, KeyNodePtrCompare comp) - { - node_ptr y = uncast(header); - node_ptr x = NodeTraits::get_parent(header); - - while(x){ - if(comp(x, key)){ - x = NodeTraits::get_right(x); - } - else if(comp(key, x)){ - y = x; - x = NodeTraits::get_left(x); - } - else{ - node_ptr xu(x), yu(y); - y = x, x = NodeTraits::get_left(x); - xu = NodeTraits::get_right(xu); - - while(x){ - if(comp(x, key)){ - x = NodeTraits::get_right(x); - } - else { - y = x; - x = NodeTraits::get_left(x); - } - } - - while(xu){ - if(comp(key, xu)){ - yu = xu; - xu = NodeTraits::get_left(xu); - } - else { - xu = NodeTraits::get_right(xu); - } - } - return std::pair<node_ptr,node_ptr> (y, yu); - } - } - return std::pair<node_ptr,node_ptr> (y, y); - } - - //! <b>Requires</b>: "header" must be the header node of a tree. - //! KeyNodePtrCompare is a function object that induces a strict weak - //! ordering compatible with the strict weak ordering used to create the - //! the tree. KeyNodePtrCompare can compare KeyType with tree's node_ptrs. - //! - //! <b>Effects</b>: Returns an node_ptr to the first element that is - //! not less than "key" according to "comp" or "header" if that element does - //! not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If "comp" throws. - template<class KeyType, class KeyNodePtrCompare> - static node_ptr lower_bound - (const const_node_ptr & header, const KeyType &key, KeyNodePtrCompare comp) - { - node_ptr y = uncast(header); - node_ptr x = NodeTraits::get_parent(header); - while(x){ - if(comp(x, key)){ - x = NodeTraits::get_right(x); - } - else { - y = x; - x = NodeTraits::get_left(x); - } - } - return y; - } - - //! <b>Requires</b>: "header" must be the header node of a tree. - //! KeyNodePtrCompare is a function object that induces a strict weak - //! ordering compatible with the strict weak ordering used to create the - //! the tree. KeyNodePtrCompare can compare KeyType with tree's node_ptrs. - //! - //! <b>Effects</b>: Returns an node_ptr to the first element that is greater - //! than "key" according to "comp" or "header" if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If "comp" throws. - template<class KeyType, class KeyNodePtrCompare> - static node_ptr upper_bound - (const const_node_ptr & header, const KeyType &key, KeyNodePtrCompare comp) - { - node_ptr y = uncast(header); - node_ptr x = NodeTraits::get_parent(header); - while(x){ - if(comp(key, x)){ - y = x; - x = NodeTraits::get_left(x); - } - else { - x = NodeTraits::get_right(x); - } - } - return y; - } - - //! <b>Requires</b>: "header" must be the header node of a tree. - //! "commit_data" must have been obtained from a previous call to - //! "insert_unique_check". No objects should have been inserted or erased - //! from the set between the "insert_unique_check" that filled "commit_data" - //! and the call to "insert_commit". - //! - //! - //! <b>Effects</b>: Inserts new_node in the set using the information obtained - //! from the "commit_data" that a previous "insert_check" filled. - //! - //! <b>Complexity</b>: Constant time. - //! - //! <b>Throws</b>: Nothing. - //! - //! <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. - static void insert_unique_commit - (const node_ptr & header, const node_ptr & new_value, const insert_commit_data &commit_data) - { return insert_commit(header, new_value, commit_data); } - - static void insert_commit - (const node_ptr & header, const node_ptr & new_node, const insert_commit_data &commit_data) - { - //Check if commit_data has not been initialized by a insert_unique_check call. - BOOST_INTRUSIVE_INVARIANT_ASSERT(commit_data.node != node_ptr()); - node_ptr parent_node(commit_data.node); - if(parent_node == header){ - NodeTraits::set_parent(header, new_node); - NodeTraits::set_right(header, new_node); - NodeTraits::set_left(header, new_node); - } - else if(commit_data.link_left){ - NodeTraits::set_left(parent_node, new_node); - if(parent_node == NodeTraits::get_left(header)) - NodeTraits::set_left(header, new_node); - } - else{ - NodeTraits::set_right(parent_node, new_node); - if(parent_node == NodeTraits::get_right(header)) - NodeTraits::set_right(header, new_node); - } - NodeTraits::set_parent(new_node, parent_node); - NodeTraits::set_right(new_node, node_ptr()); - NodeTraits::set_left(new_node, node_ptr()); - } - - //! <b>Requires</b>: "header" must be the header node of a tree. - //! KeyNodePtrCompare is a function object that induces a strict weak - //! ordering compatible with the strict weak ordering used to create the - //! the tree. NodePtrCompare compares KeyType with a node_ptr. - //! - //! <b>Effects</b>: Checks if there is an equivalent node to "key" in the - //! tree according to "comp" and obtains the needed information to realize - //! a constant-time node insertion if there is no equivalent node. - //! - //! <b>Returns</b>: If there is an equivalent value - //! returns a pair containing a node_ptr to the already present node - //! and false. If there is not equivalent key can be inserted returns true - //! in the returned pair's boolean and fills "commit_data" that is meant to - //! be used with the "insert_commit" function to achieve a constant-time - //! insertion function. - //! - //! <b>Complexity</b>: Average complexity is at most logarithmic. - //! - //! <b>Throws</b>: If "comp" throws. - //! - //! <b>Notes</b>: This function is used to improve performance when constructing - //! a node is expensive and the user does not want to have two equivalent nodes - //! in the tree: if there is an equivalent value - //! the constructed object must be discarded. Many times, the part of the - //! node that is used to impose the order is much cheaper to construct - //! than the node and this function offers the possibility to use that part - //! to check if the insertion will be successful. - //! - //! If the check is successful, the user can construct the node and use - //! "insert_commit" to insert the node in constant-time. This gives a total - //! logarithmic complexity to the insertion: check(O(log(N)) + commit(O(1)). - //! - //! "commit_data" remains valid for a subsequent "insert_unique_commit" only - //! if no more objects are inserted or erased from the set. - template<class KeyType, class KeyNodePtrCompare> - static std::pair<node_ptr, bool> insert_unique_check - (const const_node_ptr & header, const KeyType &key - ,KeyNodePtrCompare comp, insert_commit_data &commit_data, std::size_t *pdepth = 0) - { - std::size_t depth = 0; - node_ptr h(uncast(header)); - node_ptr y(h); - node_ptr x(NodeTraits::get_parent(y)); - node_ptr prev = node_ptr(); - - //Find the upper bound, cache the previous value and if we should - //store it in the left or right node - bool left_child = true; - while(x){ - ++depth; - y = x; - x = (left_child = comp(key, x)) ? - NodeTraits::get_left(x) : (prev = y, NodeTraits::get_right(x)); - } - - if(pdepth) *pdepth = depth; - - //Since we've found the upper bound there is no other value with the same key if: - // - There is no previous node - // - The previous node is less than the key - if(!prev || comp(prev, key)){ - commit_data.link_left = left_child; - commit_data.node = y; - return std::pair<node_ptr, bool>(node_ptr(), true); - } - //If the previous value was not less than key, it means that it's equal - //(because we've checked the upper bound) - else{ - return std::pair<node_ptr, bool>(prev, false); - } - } - - template<class KeyType, class KeyNodePtrCompare> - static std::pair<node_ptr, bool> insert_unique_check - (const const_node_ptr & header, const node_ptr &hint, const KeyType &key - ,KeyNodePtrCompare comp, insert_commit_data &commit_data, std::size_t *pdepth = 0) - { - //hint must be bigger than the key - if(hint == header || comp(key, hint)){ - node_ptr prev(hint); - //Previous value should be less than the key - if(hint == begin_node(header)|| comp((prev = prev_node(hint)), key)){ - commit_data.link_left = unique(header) || !NodeTraits::get_left(hint); - commit_data.node = commit_data.link_left ? hint : prev; - if(pdepth){ - *pdepth = commit_data.node == header ? 0 : depth(commit_data.node) + 1; - } - return std::pair<node_ptr, bool>(node_ptr(), true); - } - } - //Hint was wrong, use hintless insertion - return insert_unique_check(header, key, comp, commit_data, pdepth); - } - - template<class NodePtrCompare> - static void insert_equal_check - (const node_ptr &header, const node_ptr & hint, const node_ptr & new_node, NodePtrCompare comp - , insert_commit_data &commit_data, std::size_t *pdepth = 0) - { - if(hint == header || !comp(hint, new_node)){ - node_ptr prev(hint); - if(hint == NodeTraits::get_left(header) || - !comp(new_node, (prev = prev_node(hint)))){ - bool link_left = unique(header) || !NodeTraits::get_left(hint); - commit_data.link_left = link_left; - commit_data.node = link_left ? hint : prev; - if(pdepth){ - *pdepth = commit_data.node == header ? 0 : depth(commit_data.node) + 1; - } - } - else{ - insert_equal_upper_bound_check(header, new_node, comp, commit_data, pdepth); - } - } - else{ - insert_equal_lower_bound_check(header, new_node, comp, commit_data, pdepth); - } - } - - template<class NodePtrCompare> - static void insert_equal_upper_bound_check - (const node_ptr & h, const node_ptr & new_node, NodePtrCompare comp, insert_commit_data & commit_data, std::size_t *pdepth = 0) - { insert_equal_check_impl(true, h, new_node, comp, commit_data, pdepth); } - - template<class NodePtrCompare> - static void insert_equal_lower_bound_check - (const node_ptr & h, const node_ptr & new_node, NodePtrCompare comp, insert_commit_data & commit_data, std::size_t *pdepth = 0) - { insert_equal_check_impl(false, h, new_node, comp, commit_data, pdepth); } - - template<class NodePtrCompare> - static node_ptr insert_equal - (const node_ptr & h, const node_ptr & hint, const node_ptr & new_node, NodePtrCompare comp, std::size_t *pdepth = 0) - { - insert_commit_data commit_data; - insert_equal_check(h, hint, new_node, comp, commit_data, pdepth); - insert_commit(h, new_node, commit_data); - return new_node; - } - - template<class NodePtrCompare> - static node_ptr insert_equal_upper_bound - (const node_ptr & h, const node_ptr & new_node, NodePtrCompare comp, std::size_t *pdepth = 0) - { - insert_commit_data commit_data; - insert_equal_upper_bound_check(h, new_node, comp, commit_data, pdepth); - insert_commit(h, new_node, commit_data); - return new_node; - } - - template<class NodePtrCompare> - static node_ptr insert_equal_lower_bound - (const node_ptr & h, const node_ptr & new_node, NodePtrCompare comp, std::size_t *pdepth = 0) - { - insert_commit_data commit_data; - insert_equal_lower_bound_check(h, new_node, comp, commit_data, pdepth); - insert_commit(h, new_node, commit_data); - return new_node; - } - - static node_ptr insert_before - (const node_ptr & header, const node_ptr & pos, const node_ptr & new_node, std::size_t *pdepth = 0) - { - insert_commit_data commit_data; - insert_before_check(header, pos, commit_data, pdepth); - insert_commit(header, new_node, commit_data); - return new_node; - } - - static void insert_before_check - (const node_ptr &header, const node_ptr & pos - , insert_commit_data &commit_data, std::size_t *pdepth = 0) - { - node_ptr prev(pos); - if(pos != NodeTraits::get_left(header)) - prev = prev_node(pos); - bool link_left = unique(header) || !NodeTraits::get_left(pos); - commit_data.link_left = link_left; - commit_data.node = link_left ? pos : prev; - if(pdepth){ - *pdepth = commit_data.node == header ? 0 : depth(commit_data.node) + 1; - } - } - - static void push_back - (const node_ptr & header, const node_ptr & new_node, std::size_t *pdepth = 0) - { - insert_commit_data commit_data; - push_back_check(header, commit_data, pdepth); - insert_commit(header, new_node, commit_data); - } - - static void push_back_check - (const node_ptr & header, insert_commit_data &commit_data, std::size_t *pdepth = 0) - { - node_ptr prev(NodeTraits::get_right(header)); - if(pdepth){ - *pdepth = prev == header ? 0 : depth(prev) + 1; - } - commit_data.link_left = false; - commit_data.node = prev; - } - - static void push_front - (const node_ptr & header, const node_ptr & new_node, std::size_t *pdepth = 0) - { - insert_commit_data commit_data; - push_front_check(header, commit_data, pdepth); - insert_commit(header, new_node, commit_data); - } - - static void push_front_check - (const node_ptr & header, insert_commit_data &commit_data, std::size_t *pdepth = 0) - { - node_ptr pos(NodeTraits::get_left(header)); - if(pdepth){ - *pdepth = pos == header ? 0 : depth(pos) + 1; - } - commit_data.link_left = true; - commit_data.node = pos; - } - - //! <b>Requires</b>: 'node' can't be a header node. - //! - //! <b>Effects</b>: Calculates the depth of a node: the depth of a - //! node is the length (number of edges) of the path from the root - //! to that node. (The root node is at depth 0.) - //! - //! <b>Complexity</b>: Logarithmic to the number of nodes in the tree. - //! - //! <b>Throws</b>: Nothing. - static std::size_t depth(const const_node_ptr & node) - { - const_node_ptr p(node); - std::size_t depth = 0; - node_ptr p_parent; - while(p != NodeTraits::get_parent(p_parent = NodeTraits::get_parent(p))){ - ++depth; - p = p_parent; - } - return depth; - } - - //! <b>Requires</b>: "cloner" must be a function - //! object taking a node_ptr and returning a new cloned node of it. "disposer" must - //! take a node_ptr and shouldn't throw. - //! - //! <b>Effects</b>: First empties target tree calling - //! <tt>void disposer::operator()(const node_ptr &)</tt> for every node of the tree - //! except the header. - //! - //! Then, duplicates the entire tree pointed by "source_header" cloning each - //! source node with <tt>node_ptr Cloner::operator()(const node_ptr &)</tt> to obtain - //! the nodes of the target tree. If "cloner" throws, the cloned target nodes - //! are disposed using <tt>void disposer(const node_ptr &)</tt>. - //! - //! <b>Complexity</b>: Linear to the number of element of the source tree plus the. - //! number of elements of tree target tree when calling this function. - //! - //! <b>Throws</b>: If cloner functor throws. If this happens target nodes are disposed. - template <class Cloner, class Disposer> - static void clone - (const const_node_ptr & source_header, const node_ptr & target_header, Cloner cloner, Disposer disposer) - { - if(!unique(target_header)){ - clear_and_dispose(target_header, disposer); - } - - node_ptr leftmost, rightmost; - node_ptr new_root = clone_subtree - (source_header, target_header, cloner, disposer, leftmost, rightmost); - - //Now update header node - NodeTraits::set_parent(target_header, new_root); - NodeTraits::set_left (target_header, leftmost); - NodeTraits::set_right (target_header, rightmost); - } - - template <class Cloner, class Disposer> - static node_ptr clone_subtree - (const const_node_ptr &source_parent, const node_ptr &target_parent - , Cloner cloner, Disposer disposer - , node_ptr &leftmost_out, node_ptr &rightmost_out - ) - { - node_ptr target_sub_root = target_parent; - node_ptr source_root = NodeTraits::get_parent(source_parent); - if(!source_root){ - leftmost_out = rightmost_out = source_root; - } - else{ - //We'll calculate leftmost and rightmost nodes while iterating - node_ptr current = source_root; - node_ptr insertion_point = target_sub_root = cloner(current); - - //We'll calculate leftmost and rightmost nodes while iterating - node_ptr leftmost = target_sub_root; - node_ptr rightmost = target_sub_root; - - //First set the subroot - NodeTraits::set_left(target_sub_root, node_ptr()); - NodeTraits::set_right(target_sub_root, node_ptr()); - NodeTraits::set_parent(target_sub_root, target_parent); - - dispose_subtree_disposer<Disposer> rollback(disposer, target_sub_root); - while(true) { - //First clone left nodes - if( NodeTraits::get_left(current) && - !NodeTraits::get_left(insertion_point)) { - current = NodeTraits::get_left(current); - node_ptr temp = insertion_point; - //Clone and mark as leaf - insertion_point = cloner(current); - NodeTraits::set_left (insertion_point, node_ptr()); - NodeTraits::set_right (insertion_point, node_ptr()); - //Insert left - NodeTraits::set_parent(insertion_point, temp); - NodeTraits::set_left (temp, insertion_point); - //Update leftmost - if(rightmost == target_sub_root) - leftmost = insertion_point; - } - //Then clone right nodes - else if( NodeTraits::get_right(current) && - !NodeTraits::get_right(insertion_point)){ - current = NodeTraits::get_right(current); - node_ptr temp = insertion_point; - //Clone and mark as leaf - insertion_point = cloner(current); - NodeTraits::set_left (insertion_point, node_ptr()); - NodeTraits::set_right (insertion_point, node_ptr()); - //Insert right - NodeTraits::set_parent(insertion_point, temp); - NodeTraits::set_right (temp, insertion_point); - //Update rightmost - rightmost = insertion_point; - } - //If not, go up - else if(current == source_root){ - break; - } - else{ - //Branch completed, go up searching more nodes to clone - current = NodeTraits::get_parent(current); - insertion_point = NodeTraits::get_parent(insertion_point); - } - } - rollback.release(); - leftmost_out = leftmost; - rightmost_out = rightmost; - } - return target_sub_root; - } - - template<class Disposer> - static void dispose_subtree(const node_ptr & node, Disposer disposer) - { - node_ptr save; - node_ptr x(node); - while (x){ - save = NodeTraits::get_left(x); - if (save) { - // Right rotation - NodeTraits::set_left(x, NodeTraits::get_right(save)); - NodeTraits::set_right(save, x); - } - else { - save = NodeTraits::get_right(x); - init(x); - disposer(x); - } - x = save; - } - } - - //! <b>Requires</b>: p is a node of a tree. - //! - //! <b>Effects</b>: Returns true if p is a left child. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - static bool is_left_child(const node_ptr & p) - { return NodeTraits::get_left(NodeTraits::get_parent(p)) == p; } - - //! <b>Requires</b>: p is a node of a tree. - //! - //! <b>Effects</b>: Returns true if p is a right child. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - static bool is_right_child(const node_ptr & p) - { return NodeTraits::get_right(NodeTraits::get_parent(p)) == p; } - - //Fix header and own's parent data when replacing x with own, providing own's old data with parent - static void replace_own_impl(const node_ptr & own, const node_ptr & x, const node_ptr & header, const node_ptr & own_parent, bool own_was_left) - { - if(NodeTraits::get_parent(header) == own) - NodeTraits::set_parent(header, x); - else if(own_was_left) - NodeTraits::set_left(own_parent, x); - else - NodeTraits::set_right(own_parent, x); - } - - //Fix header and own's parent data when replacing x with own, supposing own - //links with its parent are still ok - static void replace_own(const node_ptr & own, const node_ptr & x, const node_ptr & header) - { - node_ptr own_parent(NodeTraits::get_parent(own)); - bool own_is_left(NodeTraits::get_left(own_parent) == own); - replace_own_impl(own, x, header, own_parent, own_is_left); - } - - // rotate parent p to left (no header and p's parent fixup) - static node_ptr rotate_left(const node_ptr & p) - { - node_ptr x(NodeTraits::get_right(p)); - node_ptr x_left(NodeTraits::get_left(x)); - NodeTraits::set_right(p, x_left); - if(x_left){ - NodeTraits::set_parent(x_left, p); - } - NodeTraits::set_left(x, p); - NodeTraits::set_parent(p, x); - return x; - } - - // rotate parent p to left (with header and p's parent fixup) - static void rotate_left(const node_ptr & p, const node_ptr & header) - { - bool p_was_left(is_left_child(p)); - node_ptr p_old_parent(NodeTraits::get_parent(p)); - node_ptr x(rotate_left(p)); - NodeTraits::set_parent(x, p_old_parent); - replace_own_impl(p, x, header, p_old_parent, p_was_left); - } - - // rotate parent p to right (no header and p's parent fixup) - static node_ptr rotate_right(const node_ptr & p) - { - node_ptr x(NodeTraits::get_left(p)); - node_ptr x_right(NodeTraits::get_right(x)); - NodeTraits::set_left(p, x_right); - if(x_right){ - NodeTraits::set_parent(x_right, p); - } - NodeTraits::set_right(x, p); - NodeTraits::set_parent(p, x); - return x; - } - - // rotate parent p to right (with header and p's parent fixup) - static void rotate_right(const node_ptr & p, const node_ptr & header) - { - bool p_was_left(is_left_child(p)); - node_ptr p_old_parent(NodeTraits::get_parent(p)); - node_ptr x(rotate_right(p)); - NodeTraits::set_parent(x, p_old_parent); - replace_own_impl(p, x, header, p_old_parent, p_was_left); - } - - static void erase(const node_ptr & header, const node_ptr & z) - { - data_for_rebalance ignored; - erase_impl(header, z, ignored); - } - - struct data_for_rebalance - { - node_ptr x; - node_ptr x_parent; - node_ptr y; - }; - - template<class F> - static void erase(const node_ptr & header, const node_ptr & z, F z_and_successor_fixup, data_for_rebalance &info) - { - erase_impl(header, z, info); - if(info.y != z){ - z_and_successor_fixup(z, info.y); - } - } - - static void unlink(const node_ptr & node) - { - node_ptr x = NodeTraits::get_parent(node); - if(x){ - while(!is_header(x)) - x = NodeTraits::get_parent(x); - erase(x, node); - } - } - - static void tree_to_vine(const node_ptr & header) - { subtree_to_vine(NodeTraits::get_parent(header)); } - - static void vine_to_tree(const node_ptr & header, std::size_t count) - { vine_to_subtree(NodeTraits::get_parent(header), count); } - - static void rebalance(const node_ptr & header) - { - //Taken from: - //"Tree rebalancing in optimal time and space" - //Quentin F. Stout and Bette L. Warren - std::size_t len = 0; - subtree_to_vine(NodeTraits::get_parent(header), &len); - vine_to_subtree(NodeTraits::get_parent(header), len); - } - - static node_ptr rebalance_subtree(const node_ptr & old_root) - { - std::size_t len = 0; - node_ptr new_root = subtree_to_vine(old_root, &len); - return vine_to_subtree(new_root, len); - } - - static node_ptr subtree_to_vine(const node_ptr & old_root, std::size_t *plen = 0) - { - std::size_t len; - len = 0; - if(!old_root) return node_ptr(); - - //To avoid irregularities in the algorithm (old_root can be a - //left or right child or even the root of the tree) just put the - //root as the right child of its parent. Before doing this backup - //information to restore the original relationship after - //the algorithm is applied. - node_ptr super_root = NodeTraits::get_parent(old_root); - BOOST_INTRUSIVE_INVARIANT_ASSERT(super_root); - - //Get info - node_ptr super_root_right_backup = NodeTraits::get_right(super_root); - bool super_root_is_header = is_header(super_root); - bool old_root_is_right = is_right_child(old_root); - - node_ptr x(old_root); - node_ptr new_root(x); - node_ptr save; - bool moved_to_right = false; - for( ; x; x = save){ - save = NodeTraits::get_left(x); - if(save){ - // Right rotation - node_ptr save_right = NodeTraits::get_right(save); - node_ptr x_parent = NodeTraits::get_parent(x); - NodeTraits::set_parent(save, x_parent); - NodeTraits::set_right (x_parent, save); - NodeTraits::set_parent(x, save); - NodeTraits::set_right (save, x); - NodeTraits::set_left(x, save_right); - if(save_right) - NodeTraits::set_parent(save_right, x); - if(!moved_to_right) - new_root = save; - } - else{ - moved_to_right = true; - save = NodeTraits::get_right(x); - ++len; - } - } - - if(super_root_is_header){ - NodeTraits::set_right(super_root, super_root_right_backup); - NodeTraits::set_parent(super_root, new_root); - } - else if(old_root_is_right){ - NodeTraits::set_right(super_root, new_root); - } - else{ - NodeTraits::set_right(super_root, super_root_right_backup); - NodeTraits::set_left(super_root, new_root); - } - if(plen) *plen = len; - return new_root; - } - - static node_ptr vine_to_subtree(const node_ptr & old_root, std::size_t count) - { - std::size_t leaf_nodes = count + 1 - ((std::size_t) 1 << floor_log2 (count + 1)); - std::size_t vine_nodes = count - leaf_nodes; - - node_ptr new_root = compress_subtree(old_root, leaf_nodes); - while(vine_nodes > 1){ - vine_nodes /= 2; - new_root = compress_subtree(new_root, vine_nodes); - } - return new_root; - } - - static node_ptr compress_subtree(const node_ptr & old_root, std::size_t count) - { - if(!old_root) return old_root; - - //To avoid irregularities in the algorithm (old_root can be - //left or right child or even the root of the tree) just put the - //root as the right child of its parent. First obtain - //information to restore the original relationship after - //the algorithm is applied. - node_ptr super_root = NodeTraits::get_parent(old_root); - BOOST_INTRUSIVE_INVARIANT_ASSERT(super_root); - - //Get info - node_ptr super_root_right_backup = NodeTraits::get_right(super_root); - bool super_root_is_header = is_header(super_root); - bool old_root_is_right = is_right_child(old_root); - - //Put old_root as right child - NodeTraits::set_right(super_root, old_root); - - //Start the compression algorithm - node_ptr even_parent = super_root; - node_ptr new_root = old_root; - - while(count--){ - node_ptr even = NodeTraits::get_right(even_parent); - node_ptr odd = NodeTraits::get_right(even); - - if(new_root == old_root) - new_root = odd; - - node_ptr even_right = NodeTraits::get_left(odd); - NodeTraits::set_right(even, even_right); - if (even_right) - NodeTraits::set_parent(even_right, even); - - NodeTraits::set_right(even_parent, odd); - NodeTraits::set_parent(odd, even_parent); - NodeTraits::set_left(odd, even); - NodeTraits::set_parent(even, odd); - even_parent = odd; - } - - if(super_root_is_header){ - NodeTraits::set_parent(super_root, new_root); - NodeTraits::set_right(super_root, super_root_right_backup); - } - else if(old_root_is_right){ - NodeTraits::set_right(super_root, new_root); - } - else{ - NodeTraits::set_left(super_root, new_root); - NodeTraits::set_right(super_root, super_root_right_backup); - } - return new_root; - } - - //! <b>Requires</b>: "n" must be a node inserted in a tree. - //! - //! <b>Effects</b>: Returns a pointer to the header node of the tree. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: Nothing. - static node_ptr get_root(const node_ptr & node) - { - BOOST_INTRUSIVE_INVARIANT_ASSERT((!inited(node))); - node_ptr x = NodeTraits::get_parent(node); - if(x){ - while(!is_header(x)){ - x = NodeTraits::get_parent(x); - } - return x; - } - else{ - return node; - } - } - - private: - template<class NodePtrCompare> - static void insert_equal_check_impl - (bool upper, const node_ptr & h, const node_ptr & new_node, NodePtrCompare comp, insert_commit_data & commit_data, std::size_t *pdepth = 0) - { - std::size_t depth = 0; - node_ptr y(h); - node_ptr x(NodeTraits::get_parent(y)); - bool link_left; - - if(upper){ - while(x){ - ++depth; - y = x; - x = comp(new_node, x) ? - NodeTraits::get_left(x) : NodeTraits::get_right(x); - } - link_left = (y == h) || comp(new_node, y); - } - else{ - while(x){ - ++depth; - y = x; - x = !comp(x, new_node) ? - NodeTraits::get_left(x) : NodeTraits::get_right(x); - } - link_left = (y == h) || !comp(y, new_node); - } - - commit_data.link_left = link_left; - commit_data.node = y; - if(pdepth) *pdepth = depth; - } - - static void erase_impl(const node_ptr & header, const node_ptr & z, data_for_rebalance &info) - { - node_ptr y(z); - node_ptr x; - node_ptr x_parent = node_ptr(); - node_ptr z_left(NodeTraits::get_left(z)); - node_ptr z_right(NodeTraits::get_right(z)); - if(!z_left){ - x = z_right; // x might be null. - } - else if(!z_right){ // z has exactly one non-null child. y == z. - x = z_left; // x is not null. - } - else{ - // find z's successor - y = tree_algorithms::minimum (z_right); - x = NodeTraits::get_right(y); // x might be null. - } - - if(y != z){ - // relink y in place of z. y is z's successor - NodeTraits::set_parent(NodeTraits::get_left(z), y); - NodeTraits::set_left(y, NodeTraits::get_left(z)); - if(y != NodeTraits::get_right(z)){ - x_parent = NodeTraits::get_parent(y); - if(x) - NodeTraits::set_parent(x, x_parent); - NodeTraits::set_left(x_parent, x); // y must be a child of left_ - NodeTraits::set_right(y, NodeTraits::get_right(z)); - NodeTraits::set_parent(NodeTraits::get_right(z), y); - } - else - x_parent = y; - tree_algorithms::replace_own (z, y, header); - NodeTraits::set_parent(y, NodeTraits::get_parent(z)); - } - else { // y == z --> z has only one child, or none - x_parent = NodeTraits::get_parent(z); - if(x) - NodeTraits::set_parent(x, x_parent); - tree_algorithms::replace_own (z, x, header); - if(NodeTraits::get_left(header) == z){ - NodeTraits::set_left(header, !NodeTraits::get_right(z) ? // z->get_left() must be null also - NodeTraits::get_parent(z) : // makes leftmost == header if z == root - tree_algorithms::minimum (x)); - } - if(NodeTraits::get_right(header) == z){ - NodeTraits::set_right(header, !NodeTraits::get_left(z) ? // z->get_right() must be null also - NodeTraits::get_parent(z) : // makes rightmost == header if z == root - tree_algorithms::maximum(x)); - } - } - - info.x = x; - info.x_parent = x_parent; - info.y = y; - } -}; - -} //namespace detail { -} //namespace intrusive -} //namespace boost - -#include <boost/intrusive/detail/config_end.hpp> - -#endif //BOOST_INTRUSIVE_TREE_ALGORITHMS_HPP diff --git a/src/third_party/boost/boost/intrusive/detail/tree_node.hpp b/src/third_party/boost/boost/intrusive/detail/tree_node.hpp deleted file mode 100644 index ccbe70caf1b..00000000000 --- a/src/third_party/boost/boost/intrusive/detail/tree_node.hpp +++ /dev/null @@ -1,190 +0,0 @@ -///////////////////////////////////////////////////////////////////////////// -// -// (C) Copyright Ion Gaztanaga 2007. -// -// Distributed under the Boost Software License, Version 1.0. -// (See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) -// -// See http://www.boost.org/libs/intrusive for documentation. -// -///////////////////////////////////////////////////////////////////////////// - -#ifndef BOOST_INTRUSIVE_TREE_NODE_HPP -#define BOOST_INTRUSIVE_TREE_NODE_HPP - -#include <boost/intrusive/detail/config_begin.hpp> -#include <iterator> -#include <boost/intrusive/pointer_traits.hpp> -#include <boost/intrusive/detail/mpl.hpp> - -namespace boost { -namespace intrusive { - -template<class VoidPointer> -struct tree_node -{ - typedef typename pointer_traits - <VoidPointer>::template rebind_pointer - <tree_node<VoidPointer> >::type node_ptr; - - node_ptr parent_, left_, right_; -}; - -template<class VoidPointer> -struct tree_node_traits -{ - typedef tree_node<VoidPointer> node; - - typedef typename pointer_traits<VoidPointer>::template - rebind_pointer<node>::type node_ptr; - typedef typename pointer_traits<VoidPointer>::template - rebind_pointer<const node>::type const_node_ptr; - - static const node_ptr & get_parent(const const_node_ptr & n) - { return n->parent_; } - - static void set_parent(const node_ptr & n, const node_ptr & p) - { n->parent_ = p; } - - static const node_ptr & get_left(const const_node_ptr & n) - { return n->left_; } - - static void set_left(const node_ptr & n, const node_ptr & l) - { n->left_ = l; } - - static const node_ptr & get_right(const const_node_ptr & n) - { return n->right_; } - - static void set_right(const node_ptr & n, const node_ptr & r) - { n->right_ = r; } -}; - -///////////////////////////////////////////////////////////////////////////// -// // -// Implementation of the tree iterator // -// // -///////////////////////////////////////////////////////////////////////////// - -// tree_iterator provides some basic functions for a -// node oriented bidirectional iterator: -template<class Container, bool IsConst> -class tree_iterator - : public std::iterator - < std::bidirectional_iterator_tag - , typename Container::value_type - , typename Container::difference_type - , typename detail::if_c<IsConst,typename Container::const_pointer,typename Container::pointer>::type - , typename detail::if_c<IsConst,typename Container::const_reference,typename Container::reference>::type - > -{ - protected: - typedef typename Container::real_value_traits real_value_traits; - typedef typename Container::node_algorithms node_algorithms; - typedef typename real_value_traits::node_traits node_traits; - typedef typename node_traits::node node; - typedef typename node_traits::node_ptr node_ptr; - typedef typename pointer_traits<node_ptr>::template - rebind_pointer<void>::type void_pointer; - static const bool store_container_ptr = - detail::store_cont_ptr_on_it<Container>::value; - - public: - typedef typename Container::value_type value_type; - typedef typename detail::if_c<IsConst,typename Container::const_pointer,typename Container::pointer>::type pointer; - typedef typename detail::if_c<IsConst,typename Container::const_reference,typename Container::reference>::type reference; - - - tree_iterator() - : members_ (node_ptr(), (const void *)0) - {} - - explicit tree_iterator(const node_ptr & nodeptr, const Container *cont_ptr) - : members_ (nodeptr, cont_ptr) - {} - - tree_iterator(tree_iterator<Container, false> const& other) - : members_(other.pointed_node(), other.get_container()) - {} - - const node_ptr &pointed_node() const - { return members_.nodeptr_; } - - tree_iterator &operator=(const node_ptr &nodeptr) - { members_.nodeptr_ = nodeptr; return static_cast<tree_iterator&>(*this); } - - public: - tree_iterator& operator++() - { - members_.nodeptr_ = node_algorithms::next_node(members_.nodeptr_); - return static_cast<tree_iterator&> (*this); - } - - tree_iterator operator++(int) - { - tree_iterator result (*this); - members_.nodeptr_ = node_algorithms::next_node(members_.nodeptr_); - return result; - } - - tree_iterator& operator--() - { - members_.nodeptr_ = node_algorithms::prev_node(members_.nodeptr_); - return static_cast<tree_iterator&> (*this); - } - - tree_iterator operator--(int) - { - tree_iterator result (*this); - members_.nodeptr_ = node_algorithms::prev_node(members_.nodeptr_); - return result; - } - - friend bool operator== (const tree_iterator& l, const tree_iterator& r) - { return l.pointed_node() == r.pointed_node(); } - - friend bool operator!= (const tree_iterator& l, const tree_iterator& r) - { return !(l == r); } - - reference operator*() const - { return *operator->(); } - - pointer operator->() const - { return this->get_real_value_traits()->to_value_ptr(members_.nodeptr_); } - - const Container *get_container() const - { return static_cast<const Container*>(members_.get_ptr()); } - - const real_value_traits *get_real_value_traits() const - { return &this->get_container()->get_real_value_traits(); } - - tree_iterator end_iterator_from_it() const - { - return tree_iterator(node_algorithms::get_header(this->pointed_node()), this->get_container()); - } - - tree_iterator<Container, false> unconst() const - { return tree_iterator<Container, false>(this->pointed_node(), this->get_container()); } - - private: - struct members - : public detail::select_constptr - <void_pointer, store_container_ptr>::type - { - typedef typename detail::select_constptr - <void_pointer, store_container_ptr>::type Base; - - members(const node_ptr &n_ptr, const void *cont) - : Base(cont), nodeptr_(n_ptr) - {} - - node_ptr nodeptr_; - } members_; -}; - -} //namespace intrusive -} //namespace boost - -#include <boost/intrusive/detail/config_end.hpp> - -#endif //BOOST_INTRUSIVE_TREE_NODE_HPP diff --git a/src/third_party/boost/boost/intrusive/detail/utilities.hpp b/src/third_party/boost/boost/intrusive/detail/utilities.hpp deleted file mode 100644 index c0416203ffb..00000000000 --- a/src/third_party/boost/boost/intrusive/detail/utilities.hpp +++ /dev/null @@ -1,879 +0,0 @@ -///////////////////////////////////////////////////////////////////////////// -// -// (C) Copyright Ion Gaztanaga 2006-2009 -// -// Distributed under the Boost Software License, Version 1.0. -// (See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) -// -// See http://www.boost.org/libs/intrusive for documentation. -// -///////////////////////////////////////////////////////////////////////////// - -#ifndef BOOST_INTRUSIVE_DETAIL_UTILITIES_HPP -#define BOOST_INTRUSIVE_DETAIL_UTILITIES_HPP - -#include <boost/intrusive/detail/config_begin.hpp> -#include <boost/intrusive/pointer_traits.hpp> -#include <boost/intrusive/detail/parent_from_member.hpp> -#include <boost/intrusive/detail/ebo_functor_holder.hpp> -#include <boost/intrusive/link_mode.hpp> -#include <boost/intrusive/detail/mpl.hpp> -#include <boost/intrusive/detail/assert.hpp> -#include <boost/intrusive/detail/is_stateful_value_traits.hpp> -#include <boost/intrusive/pointer_traits.hpp> -#include <boost/cstdint.hpp> -#include <cstddef> -#include <climits> -#include <iterator> -#include <boost/cstdint.hpp> -#include <boost/static_assert.hpp> - -namespace boost { -namespace intrusive { -namespace detail { - -template <class T> -struct internal_member_value_traits -{ - template <class U> static detail::one test(...); - template <class U> static detail::two test(typename U::member_value_traits* = 0); - static const bool value = sizeof(test<T>(0)) == sizeof(detail::two); -}; - -template <class T> -struct internal_base_hook_bool -{ - template<bool Add> - struct two_or_three {one _[2 + Add];}; - template <class U> static one test(...); - template <class U> static two_or_three<U::boost_intrusive_tags::is_base_hook> test (int); - static const std::size_t value = sizeof(test<T>(0)); -}; - -template <class T> -struct internal_base_hook_bool_is_true -{ - static const bool value = internal_base_hook_bool<T>::value > sizeof(one)*2; -}; - -template <class T> -struct internal_any_hook_bool -{ - template<bool Add> - struct two_or_three {one _[2 + Add];}; - template <class U> static one test(...); - template <class U> static two_or_three<U::is_any_hook> test (int); - static const std::size_t value = sizeof(test<T>(0)); -}; - -template <class T> -struct internal_any_hook_bool_is_true -{ - static const bool value = internal_any_hook_bool<T>::value > sizeof(one)*2; -}; - - -template <class T> -struct external_value_traits_bool -{ - template<bool Add> - struct two_or_three {one _[2 + Add];}; - template <class U> static one test(...); - template <class U> static two_or_three<U::external_value_traits> test (int); - static const std::size_t value = sizeof(test<T>(0)); -}; - -template <class T> -struct external_bucket_traits_bool -{ - template<bool Add> - struct two_or_three {one _[2 + Add];}; - template <class U> static one test(...); - template <class U> static two_or_three<U::external_bucket_traits> test (int); - static const std::size_t value = sizeof(test<T>(0)); -}; - -template <class T> -struct external_value_traits_is_true -{ - static const bool value = external_value_traits_bool<T>::value > sizeof(one)*2; -}; - -template<class Node, class Tag, link_mode_type LinkMode, int> -struct node_holder - : public Node -{}; - -template <class T> -inline T* to_raw_pointer(T* p) -{ return p; } - -template <class Pointer> -inline typename boost::intrusive::pointer_traits<Pointer>::element_type* -to_raw_pointer(const Pointer &p) -{ return boost::intrusive::detail::to_raw_pointer(p.operator->()); } - -//This functor compares a stored value -//and the one passed as an argument -template<class ConstReference> -class equal_to_value -{ - ConstReference t_; - - public: - equal_to_value(ConstReference t) - : t_(t) - {} - - bool operator()(ConstReference t)const - { return t_ == t; } -}; - -class null_disposer -{ - public: - template <class Pointer> - void operator()(Pointer) - {} -}; - -template<class NodeAlgorithms> -class init_disposer -{ - typedef typename NodeAlgorithms::node_ptr node_ptr; - - public: - void operator()(const node_ptr & p) - { NodeAlgorithms::init(p); } -}; - -template<bool ConstantSize, class SizeType> -struct size_holder -{ - static const bool constant_time_size = ConstantSize; - typedef SizeType size_type; - - SizeType get_size() const - { return size_; } - - void set_size(SizeType size) - { size_ = size; } - - void decrement() - { --size_; } - - void increment() - { ++size_; } - - SizeType size_; -}; - -template<class SizeType> -struct size_holder<false, SizeType> -{ - static const bool constant_time_size = false; - typedef SizeType size_type; - - size_type get_size() const - { return 0; } - - void set_size(size_type) - {} - - void decrement() - {} - - void increment() - {} -}; - -template<class KeyValueCompare, class Container> -struct key_nodeptr_comp - : private detail::ebo_functor_holder<KeyValueCompare> -{ - typedef typename Container::real_value_traits real_value_traits; - typedef typename Container::value_type value_type; - typedef typename real_value_traits::node_ptr node_ptr; - typedef typename real_value_traits::const_node_ptr const_node_ptr; - typedef detail::ebo_functor_holder<KeyValueCompare> base_t; - key_nodeptr_comp(KeyValueCompare kcomp, const Container *cont) - : base_t(kcomp), cont_(cont) - {} - - template<class T> - struct is_node_ptr - { - static const bool value = is_same<T, const_node_ptr>::value || is_same<T, node_ptr>::value; - }; - - template<class T> - const value_type & key_forward - (const T &node, typename enable_if_c<is_node_ptr<T>::value>::type * = 0) const - { return *cont_->get_real_value_traits().to_value_ptr(node); } - - template<class T> - const T & key_forward(const T &key, typename enable_if_c<!is_node_ptr<T>::value>::type* = 0) const - { return key; } - - - template<class KeyType, class KeyType2> - bool operator()(const KeyType &key1, const KeyType2 &key2) const - { return base_t::get()(this->key_forward(key1), this->key_forward(key2)); } - - const Container *cont_; -}; - -template<class F, class Container> -struct node_cloner - : private detail::ebo_functor_holder<F> -{ - typedef typename Container::real_value_traits real_value_traits; - typedef typename Container::node_algorithms node_algorithms; - typedef typename real_value_traits::value_type value_type; - typedef typename real_value_traits::pointer pointer; - typedef typename real_value_traits::node_traits::node node; - typedef typename real_value_traits::node_ptr node_ptr; - typedef typename real_value_traits::const_node_ptr const_node_ptr; - typedef detail::ebo_functor_holder<F> base_t; - enum { safemode_or_autounlink = - (int)real_value_traits::link_mode == (int)auto_unlink || - (int)real_value_traits::link_mode == (int)safe_link }; - - node_cloner(F f, const Container *cont) - : base_t(f), cont_(cont) - {} - - node_ptr operator()(const node_ptr & p) - { return this->operator()(*p); } - - node_ptr operator()(const node &to_clone) - { - const value_type &v = - *cont_->get_real_value_traits().to_value_ptr - (pointer_traits<const_node_ptr>::pointer_to(to_clone)); - node_ptr n = cont_->get_real_value_traits().to_node_ptr(*base_t::get()(v)); - //Cloned node must be in default mode if the linking mode requires it - if(safemode_or_autounlink) - BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(n)); - return n; - } - - const Container *cont_; -}; - -template<class F, class Container> -struct node_disposer - : private detail::ebo_functor_holder<F> -{ - typedef typename Container::real_value_traits real_value_traits; - typedef typename real_value_traits::node_ptr node_ptr; - typedef detail::ebo_functor_holder<F> base_t; - typedef typename Container::node_algorithms node_algorithms; - enum { safemode_or_autounlink = - (int)real_value_traits::link_mode == (int)auto_unlink || - (int)real_value_traits::link_mode == (int)safe_link }; - - node_disposer(F f, const Container *cont) - : base_t(f), cont_(cont) - {} - - void operator()(const node_ptr & p) - { - if(safemode_or_autounlink) - node_algorithms::init(p); - base_t::get()(cont_->get_real_value_traits().to_value_ptr(p)); - } - const Container *cont_; -}; - -struct dummy_constptr -{ - dummy_constptr(const void *) - {} - - const void *get_ptr() const - { return 0; } -}; - -template<class VoidPointer> -struct constptr -{ - typedef typename boost::intrusive::pointer_traits<VoidPointer>:: - template rebind_pointer<const void>::type ConstVoidPtr; - - constptr(const void *ptr) - : const_void_ptr_(ptr) - {} - - const void *get_ptr() const - { return boost::intrusive::detail::to_raw_pointer(const_void_ptr_); } - - ConstVoidPtr const_void_ptr_; -}; - -template <class VoidPointer, bool store_ptr> -struct select_constptr -{ - typedef typename detail::if_c - < store_ptr - , constptr<VoidPointer> - , dummy_constptr - >::type type; -}; - -template<class T, bool Add> -struct add_const_if_c -{ - typedef typename detail::if_c - < Add - , typename detail::add_const<T>::type - , T - >::type type; -}; - -template <link_mode_type LinkMode> -struct link_dispatch -{}; - -template<class Hook> -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. - (void)hook; BOOST_INTRUSIVE_SAFE_HOOK_DESTRUCTOR_ASSERT(!hook.is_linked()); -} - -template<class Hook> -void destructor_impl(Hook &hook, detail::link_dispatch<auto_unlink>) -{ hook.unlink(); } - -template<class Hook> -void destructor_impl(Hook &, detail::link_dispatch<normal_link>) -{} - -template<class T, class NodeTraits, link_mode_type LinkMode, class Tag, int HookType> -struct base_hook_traits -{ - public: - typedef detail::node_holder - <typename NodeTraits::node, Tag, LinkMode, HookType> node_holder; - typedef typename NodeTraits::node node; - typedef NodeTraits node_traits; - typedef T value_type; - typedef typename node_traits::node_ptr node_ptr; - typedef typename node_traits::const_node_ptr const_node_ptr; - typedef typename pointer_traits<node_ptr>:: - 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 & node_holder_reference; - typedef const node_holder & const_node_holder_reference; - typedef node& node_reference; - typedef const node & const_node_reference; - - static const link_mode_type link_mode = LinkMode; - - static pointer to_value_ptr(const node_ptr & n) - { - return pointer_traits<pointer>::pointer_to - (static_cast<reference>(static_cast<node_holder_reference>(*n))); - } - - static const_pointer to_value_ptr(const const_node_ptr & n) - { - return pointer_traits<const_pointer>::pointer_to - (static_cast<const_reference>(static_cast<const_node_holder_reference>(*n))); - } - - static node_ptr to_node_ptr(reference value) - { - return pointer_traits<node_ptr>::pointer_to - (static_cast<node_reference>(static_cast<node_holder_reference>(value))); - } - - 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_node_holder_reference>(value))); - } -}; - -template<class T, class Hook, Hook T::* P> -struct member_hook_traits -{ - public: - typedef Hook hook_type; - typedef typename hook_type::boost_intrusive_tags::node_traits node_traits; - typedef typename node_traits::node node; - typedef T value_type; - typedef typename node_traits::node_ptr node_ptr; - typedef typename node_traits::const_node_ptr const_node_ptr; - typedef typename pointer_traits<node_ptr>:: - template rebind_pointer<T>::type pointer; - typedef typename pointer_traits<node_ptr>:: - template rebind_pointer<const T>::type const_pointer; - typedef T & reference; - typedef const T & const_reference; - typedef node& node_reference; - typedef const node & const_node_reference; - typedef hook_type& hook_reference; - typedef const hook_type & const_hook_reference; - - static const link_mode_type link_mode = Hook::boost_intrusive_tags::link_mode; - - 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))); - } - - 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))); - } - - static pointer to_value_ptr(const node_ptr & n) - { - return pointer_traits<pointer>::pointer_to - (*detail::parent_from_member<T, Hook> - (static_cast<Hook*>(boost::intrusive::detail::to_raw_pointer(n)), P)); - } - - static const_pointer to_value_ptr(const const_node_ptr & n) - { - return pointer_traits<const_pointer>::pointer_to - (*detail::parent_from_member<T, Hook> - (static_cast<const Hook*>(boost::intrusive::detail::to_raw_pointer(n)), P)); - } -}; - -template<class Functor> -struct function_hook_traits -{ - public: - typedef typename Functor::hook_type hook_type; - typedef typename Functor::hook_ptr hook_ptr; - typedef typename Functor::const_hook_ptr const_hook_ptr; - typedef typename hook_type::boost_intrusive_tags::node_traits node_traits; - typedef typename node_traits::node node; - typedef typename Functor::value_type value_type; - typedef typename node_traits::node_ptr node_ptr; - typedef typename node_traits::const_node_ptr const_node_ptr; - typedef typename pointer_traits<node_ptr>:: - template rebind_pointer<value_type>::type pointer; - typedef typename pointer_traits<node_ptr>:: - template rebind_pointer<const value_type>::type const_pointer; - typedef value_type & reference; - typedef const value_type & const_reference; - static const link_mode_type link_mode = hook_type::boost_intrusive_tags::link_mode; - - static node_ptr to_node_ptr(reference value) - { return static_cast<node*>(boost::intrusive::detail::to_raw_pointer(Functor::to_hook_ptr(value))); } - - static const_node_ptr to_node_ptr(const_reference value) - { return static_cast<const node*>(boost::intrusive::detail::to_raw_pointer(Functor::to_hook_ptr(value))); } - - static pointer to_value_ptr(const node_ptr & n) - { return Functor::to_value_ptr(to_hook_ptr(n)); } - - static const_pointer to_value_ptr(const const_node_ptr & n) - { return Functor::to_value_ptr(to_hook_ptr(n)); } - - private: - static hook_ptr to_hook_ptr(const node_ptr & n) - { return hook_ptr(&*static_cast<hook_type*>(&*n)); } - - static const_hook_ptr to_hook_ptr(const const_node_ptr & n) - { return const_hook_ptr(&*static_cast<const hook_type*>(&*n)); } -}; - - -//This function uses binary search to discover the -//highest set bit of the integer -inline std::size_t floor_log2 (std::size_t x) -{ - const std::size_t Bits = sizeof(std::size_t)*CHAR_BIT; - const bool Size_t_Bits_Power_2= !(Bits & (Bits-1)); - BOOST_STATIC_ASSERT(Size_t_Bits_Power_2); - - std::size_t n = x; - std::size_t log2 = 0; - - for(std::size_t shift = Bits >> 1; shift; shift >>= 1){ - std::size_t tmp = n >> shift; - if (tmp) - log2 += shift, n = tmp; - } - - return log2; -} - -inline float fast_log2 (float val) -{ - union caster_t - { - boost::uint32_t x; - float val; - } caster; - - caster.val = val; - boost::uint32_t x = caster.x; - const int log_2 = (int)(((x >> 23) & 255) - 128); - x &= ~(255 << 23); - x += 127 << 23; - caster.x = x; - val = caster.val; - val = ((-1.0f/3) * val + 2) * val - 2.0f/3; - - return (val + log_2); -} - -inline std::size_t ceil_log2 (std::size_t x) -{ - return ((x & (x-1))!= 0) + floor_log2(x); -} - -template<class SizeType, std::size_t N> -struct numbits_eq -{ - static const bool value = sizeof(SizeType)*CHAR_BIT == N; -}; - -template<class SizeType, class Enabler = void > -struct sqrt2_pow_max; - -template <class SizeType> -struct sqrt2_pow_max<SizeType, typename enable_if< numbits_eq<SizeType, 32> >::type> -{ - static const boost::uint32_t value = 0xb504f334; - static const std::size_t pow = 31; -}; - -template <class SizeType> -struct sqrt2_pow_max<SizeType, typename enable_if< numbits_eq<SizeType, 64> >::type> -{ - static const boost::uint64_t value = 0xb504f333f9de6484ull; - static const std::size_t pow = 63; -}; - -// Returns floor(pow(sqrt(2), x * 2 + 1)). -// Defined for X from 0 up to the number of bits in size_t minus 1. -inline std::size_t sqrt2_pow_2xplus1 (std::size_t x) -{ - const std::size_t value = (std::size_t)sqrt2_pow_max<std::size_t>::value; - const std::size_t pow = (std::size_t)sqrt2_pow_max<std::size_t>::pow; - return (value >> (pow - x)) + 1; -} - -template<class Container, class Disposer> -class exception_disposer -{ - Container *cont_; - Disposer &disp_; - - exception_disposer(const exception_disposer&); - exception_disposer &operator=(const exception_disposer&); - - public: - exception_disposer(Container &cont, Disposer &disp) - : cont_(&cont), disp_(disp) - {} - - void release() - { cont_ = 0; } - - ~exception_disposer() - { - if(cont_){ - cont_->clear_and_dispose(disp_); - } - } -}; - -template<class Container, class Disposer, class SizeType> -class exception_array_disposer -{ - Container *cont_; - Disposer &disp_; - SizeType &constructed_; - - exception_array_disposer(const exception_array_disposer&); - exception_array_disposer &operator=(const exception_array_disposer&); - - public: - - exception_array_disposer - (Container &cont, Disposer &disp, SizeType &constructed) - : cont_(&cont), disp_(disp), constructed_(constructed) - {} - - void release() - { cont_ = 0; } - - ~exception_array_disposer() - { - SizeType n = constructed_; - if(cont_){ - while(n--){ - cont_[n].clear_and_dispose(disp_); - } - } - } -}; - -template<class ValueTraits, bool ExternalValueTraits> -struct store_cont_ptr_on_it_impl -{ - static const bool value = is_stateful_value_traits<ValueTraits>::value; -}; - -template<class ValueTraits> -struct store_cont_ptr_on_it_impl<ValueTraits, true> -{ - static const bool value = true; -}; - -template <class Container> -struct store_cont_ptr_on_it -{ - typedef typename Container::value_traits value_traits; - static const bool value = store_cont_ptr_on_it_impl - <value_traits, external_value_traits_is_true<value_traits>::value>::value; -}; - -template<class Container, bool IsConst> -struct node_to_value - : public detail::select_constptr - < typename pointer_traits - <typename Container::pointer>::template rebind_pointer<void>::type - , detail::store_cont_ptr_on_it<Container>::value - >::type -{ - static const bool store_container_ptr = - detail::store_cont_ptr_on_it<Container>::value; - - typedef typename Container::real_value_traits real_value_traits; - typedef typename real_value_traits::value_type value_type; - typedef typename detail::select_constptr - < typename pointer_traits - <typename Container::pointer>::template rebind_pointer<void>::type - , store_container_ptr >::type Base; - typedef typename real_value_traits::node_traits::node node; - typedef typename detail::add_const_if_c - <value_type, IsConst>::type vtype; - typedef typename detail::add_const_if_c - <node, IsConst>::type ntype; - typedef typename pointer_traits - <typename Container::pointer>::template rebind_pointer<ntype>::type npointer; - - node_to_value(const Container *cont) - : Base(cont) - {} - - typedef vtype & result_type; - typedef ntype & first_argument_type; - - const Container *get_container() const - { - if(store_container_ptr) - return static_cast<const Container*>(Base::get_ptr()); - else - return 0; - } - - const real_value_traits *get_real_value_traits() const - { - if(store_container_ptr) - return &this->get_container()->get_real_value_traits(); - else - return 0; - } - - result_type operator()(first_argument_type arg) const - { - return *(this->get_real_value_traits()->to_value_ptr - (pointer_traits<npointer>::pointer_to(arg))); - } -}; - -//This is not standard, but should work with all compilers -union max_align -{ - char char_; - short short_; - int int_; - long long_; - #ifdef BOOST_HAS_LONG_LONG - long long long_long_; - #endif - float float_; - double double_; - long double long_double_; - void * void_ptr_; -}; - -template<class T, std::size_t N> -class array_initializer -{ - public: - template<class CommonInitializer> - array_initializer(const CommonInitializer &init) - { - char *init_buf = (char*)rawbuf; - std::size_t i = 0; - try{ - for(; i != N; ++i){ - new(init_buf)T(init); - init_buf += sizeof(T); - } - } - catch(...){ - while(i--){ - init_buf -= sizeof(T); - ((T*)init_buf)->~T(); - } - throw; - } - } - - operator T* () - { return (T*)(rawbuf); } - - operator const T*() const - { return (const T*)(rawbuf); } - - ~array_initializer() - { - char *init_buf = (char*)rawbuf + N*sizeof(T); - for(std::size_t i = 0; i != N; ++i){ - init_buf -= sizeof(T); - ((T*)init_buf)->~T(); - } - } - - private: - detail::max_align rawbuf[(N*sizeof(T)-1)/sizeof(detail::max_align)+1]; -}; - - - - -template<class It> -class reverse_iterator - : public std::iterator< - typename std::iterator_traits<It>::iterator_category, - typename std::iterator_traits<It>::value_type, - typename std::iterator_traits<It>::difference_type, - typename std::iterator_traits<It>::pointer, - typename std::iterator_traits<It>::reference> -{ - public: - typedef typename std::iterator_traits<It>::pointer pointer; - typedef typename std::iterator_traits<It>::reference reference; - typedef typename std::iterator_traits<It>::difference_type difference_type; - typedef It iterator_type; - - reverse_iterator(){} - - explicit reverse_iterator(It r) - : m_current(r) - {} - - template<class OtherIt> - reverse_iterator(const reverse_iterator<OtherIt>& r) - : m_current(r.base()) - {} - - It base() const - { return m_current; } - - reference operator*() const - { It temp(m_current); --temp; return *temp; } - - pointer operator->() const - { It temp(m_current); --temp; return temp.operator->(); } - - reference operator[](difference_type off) const - { return this->m_current[-off]; } - - reverse_iterator& operator++() - { --m_current; return *this; } - - reverse_iterator operator++(int) - { - reverse_iterator temp = *this; - --m_current; - return temp; - } - - reverse_iterator& operator--() - { - ++m_current; - return *this; - } - - reverse_iterator operator--(int) - { - reverse_iterator temp(*this); - ++m_current; - return temp; - } - - friend bool operator==(const reverse_iterator& l, const reverse_iterator& r) - { return l.m_current == r.m_current; } - - friend bool operator!=(const reverse_iterator& l, const reverse_iterator& r) - { return l.m_current != r.m_current; } - - friend bool operator<(const reverse_iterator& l, const reverse_iterator& r) - { return l.m_current < r.m_current; } - - friend bool operator<=(const reverse_iterator& l, const reverse_iterator& r) - { return l.m_current <= r.m_current; } - - friend bool operator>(const reverse_iterator& l, const reverse_iterator& r) - { return l.m_current > r.m_current; } - - friend bool operator>=(const reverse_iterator& l, const reverse_iterator& r) - { return l.m_current >= r.m_current; } - - reverse_iterator& operator+=(difference_type off) - { m_current -= off; return *this; } - - friend reverse_iterator operator+(const reverse_iterator & l, difference_type off) - { - reverse_iterator tmp(l.m_current); - tmp.m_current -= off; - return tmp; - } - - reverse_iterator& operator-=(difference_type off) - { m_current += off; return *this; } - - friend reverse_iterator operator-(const reverse_iterator & l, difference_type off) - { - reverse_iterator tmp(l.m_current); - tmp.m_current += off; - return tmp; - } - - friend difference_type operator-(const reverse_iterator& l, const reverse_iterator& r) - { return r.m_current - l.m_current; } - - private: - It m_current; // the wrapped iterator -}; - -} //namespace detail -} //namespace intrusive -} //namespace boost - -#include <boost/intrusive/detail/config_end.hpp> - -#endif //BOOST_INTRUSIVE_DETAIL_UTILITIES_HPP diff --git a/src/third_party/boost/boost/intrusive/detail/workaround.hpp b/src/third_party/boost/boost/intrusive/detail/workaround.hpp deleted file mode 100644 index 5de529fb66c..00000000000 --- a/src/third_party/boost/boost/intrusive/detail/workaround.hpp +++ /dev/null @@ -1,22 +0,0 @@ -////////////////////////////////////////////////////////////////////////////// -// -// (C) Copyright Ion Gaztanaga 2005-2009. Distributed under the Boost -// Software License, Version 1.0. (See accompanying file -// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -// -// See http://www.boost.org/libs/interprocess for documentation. -// -////////////////////////////////////////////////////////////////////////////// - -#ifndef BOOST_INTRUSIVE_DETAIL_WRKRND_HPP -#define BOOST_INTRUSIVE_DETAIL_WRKRND_HPP - -#include <boost/intrusive/detail/config_begin.hpp> - -#if !defined(BOOST_NO_RVALUE_REFERENCES) && !defined(BOOST_NO_VARIADIC_TEMPLATES) - #define BOOST_INTRUSIVE_PERFECT_FORWARDING -#endif - -#include <boost/intrusive/detail/config_end.hpp> - -#endif //#ifndef BOOST_INTRUSIVE_DETAIL_WRKRND_HPP diff --git a/src/third_party/boost/boost/intrusive/hashtable.hpp b/src/third_party/boost/boost/intrusive/hashtable.hpp deleted file mode 100644 index bade5cb5071..00000000000 --- a/src/third_party/boost/boost/intrusive/hashtable.hpp +++ /dev/null @@ -1,3188 +0,0 @@ -///////////////////////////////////////////////////////////////////////////// -// -// (C) Copyright Ion Gaztanaga 2006-2009 -// -// Distributed under the Boost Software License, Version 1.0. -// (See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) -// -// See http://www.boost.org/libs/intrusive for documentation. -// -///////////////////////////////////////////////////////////////////////////// -#ifndef BOOST_INTRUSIVE_HASHTABLE_HPP -#define BOOST_INTRUSIVE_HASHTABLE_HPP - -#include <boost/intrusive/detail/config_begin.hpp> -//std C++ -#include <functional> //std::equal_to -#include <utility> //std::pair -#include <algorithm> //std::swap, std::lower_bound, std::upper_bound -#include <cstddef> //std::size_t -//boost -#include <boost/intrusive/detail/assert.hpp> -#include <boost/static_assert.hpp> -#include <boost/functional/hash.hpp> -#include <boost/pointer_cast.hpp> -//General intrusive utilities -#include <boost/intrusive/intrusive_fwd.hpp> -#include <boost/intrusive/detail/hashtable_node.hpp> -#include <boost/intrusive/detail/transform_iterator.hpp> -#include <boost/intrusive/link_mode.hpp> -#include <boost/intrusive/detail/ebo_functor_holder.hpp> -#include <boost/intrusive/detail/clear_on_destructor_base.hpp> -#include <boost/intrusive/detail/utilities.hpp> -//Implementation utilities -#include <boost/intrusive/trivial_value_traits.hpp> -#include <boost/intrusive/unordered_set_hook.hpp> -#include <boost/intrusive/slist.hpp> -#include <boost/intrusive/pointer_traits.hpp> -#include <boost/intrusive/detail/mpl.hpp> -#include <boost/type_traits.hpp> -#include <boost/move/move.hpp> - -namespace boost { -namespace intrusive { - -/// @cond - -namespace detail { - -struct hash_bool_flags -{ - static const std::size_t unique_keys_pos = 1u; - static const std::size_t constant_time_size_pos = 2u; - static const std::size_t power_2_buckets_pos = 4u; - static const std::size_t cache_begin_pos = 8u; - static const std::size_t compare_hash_pos = 16u; - static const std::size_t incremental_pos = 32u; -}; - -template - < class ValueTraits - , class Hash - , class Equal - , class SizeType - , class BucketTraits - , std::size_t BoolFlags - > -struct usetopt -{ - typedef ValueTraits value_traits; - typedef Hash hash; - typedef Equal equal; - typedef SizeType size_type; - typedef BucketTraits bucket_traits; - static const std::size_t bool_flags = BoolFlags; -}; - -template - < class UsetOpt - , std::size_t BoolMask - > -struct usetopt_mask -{ - typedef usetopt - <typename UsetOpt::value_traits - ,typename UsetOpt::hash - ,typename UsetOpt::equal - ,typename UsetOpt::size_type - ,typename UsetOpt::bucket_traits - ,UsetOpt::bool_flags & BoolMask - > type; -}; - -template <class NodeTraits> -struct hash_reduced_slist_node_traits -{ - template <class U> static detail::one test(...); - template <class U> static detail::two test(typename U::reduced_slist_node_traits* = 0); - static const bool value = sizeof(test<NodeTraits>(0)) == sizeof(detail::two); -}; - -template <class NodeTraits> -struct apply_reduced_slist_node_traits -{ - typedef typename NodeTraits::reduced_slist_node_traits type; -}; - -template <class NodeTraits> -struct reduced_slist_node_traits -{ - typedef typename detail::eval_if_c - < hash_reduced_slist_node_traits<NodeTraits>::value - , apply_reduced_slist_node_traits<NodeTraits> - , detail::identity<NodeTraits> - >::type type; -}; - -template<class NodeTraits> -struct get_slist_impl -{ - typedef trivial_value_traits<NodeTraits, normal_link> trivial_traits; - - //Reducing symbol length - struct type : make_slist - < typename NodeTraits::node - , boost::intrusive::value_traits<trivial_traits> - , boost::intrusive::constant_time_size<false> - , boost::intrusive::size_type<typename boost::make_unsigned - <typename pointer_traits<typename NodeTraits::node_ptr>::difference_type>::type > - >::type - {}; -}; - -template<class SupposedValueTraits> -struct real_from_supposed_value_traits -{ - typedef typename detail::eval_if_c - < detail::external_value_traits_is_true - <SupposedValueTraits>::value - , detail::eval_value_traits - <SupposedValueTraits> - , detail::identity - <SupposedValueTraits> - >::type type; -}; - -template<class SupposedValueTraits> -struct get_slist_impl_from_supposed_value_traits -{ - typedef typename - real_from_supposed_value_traits - < SupposedValueTraits>::type real_value_traits; - typedef typename detail::get_node_traits - <real_value_traits>::type node_traits; - typedef typename get_slist_impl - <typename reduced_slist_node_traits - <node_traits>::type - >::type type; -}; - -template<class SupposedValueTraits> -struct unordered_bucket_impl -{ - typedef typename - get_slist_impl_from_supposed_value_traits - <SupposedValueTraits>::type slist_impl; - typedef detail::bucket_impl<slist_impl> implementation_defined; - typedef implementation_defined type; -}; - -template<class SupposedValueTraits> -struct unordered_bucket_ptr_impl -{ - typedef typename detail::get_node_traits - <SupposedValueTraits>::type::node_ptr node_ptr; - typedef typename unordered_bucket_impl - <SupposedValueTraits>::type bucket_type; - - typedef typename pointer_traits - <node_ptr>::template rebind_pointer - < bucket_type >::type implementation_defined; - typedef implementation_defined type; -}; - -template <class T> -struct store_hash_bool -{ - template<bool Add> - struct two_or_three {one _[2 + Add];}; - template <class U> static one test(...); - template <class U> static two_or_three<U::store_hash> test (int); - static const std::size_t value = sizeof(test<T>(0)); -}; - -template <class T> -struct store_hash_is_true -{ - static const bool value = store_hash_bool<T>::value > sizeof(one)*2; -}; - -template <class T> -struct optimize_multikey_bool -{ - template<bool Add> - struct two_or_three {one _[2 + Add];}; - template <class U> static one test(...); - template <class U> static two_or_three<U::optimize_multikey> test (int); - static const std::size_t value = sizeof(test<T>(0)); -}; - -template <class T> -struct optimize_multikey_is_true -{ - static const bool value = optimize_multikey_bool<T>::value > sizeof(one)*2; -}; - -template<class Config> -struct bucket_plus_size - : public detail::size_holder //size_traits - < 0 != (Config::bool_flags & hash_bool_flags::constant_time_size_pos) - , typename Config::size_type> -{ - typedef detail::size_holder - < 0 != (Config::bool_flags & hash_bool_flags::constant_time_size_pos) - , typename Config::size_type> size_traits; - typedef typename Config::bucket_traits bucket_traits; - - template<class BucketTraits> - bucket_plus_size(BOOST_FWD_REF(BucketTraits) b_traits) - : bucket_traits_(::boost::forward<BucketTraits>(b_traits)) - {} - - bucket_plus_size & operator =(const bucket_plus_size &x) - { - this->size_traits::operator=(x); - bucket_traits_ = x.bucket_traits_; - return *this; - } - bucket_traits bucket_traits_; -}; - -template<class Config> -struct bucket_hash_t - : public detail::ebo_functor_holder<typename Config::hash> //hash -{ - typedef typename Config::hash hasher; - typedef detail::size_holder - < 0 != (Config::bool_flags & hash_bool_flags::constant_time_size_pos) - , typename Config::size_type> size_traits; - typedef typename Config::bucket_traits bucket_traits; - - template<class BucketTraits> - bucket_hash_t(BOOST_FWD_REF(BucketTraits) b_traits, const hasher & h) - : detail::ebo_functor_holder<hasher>(h), bucket_plus_size_(::boost::forward<BucketTraits>(b_traits)) - {} - - bucket_plus_size<Config> bucket_plus_size_; -}; - -template<class Config, bool> -struct bucket_hash_equal_t - : public detail::ebo_functor_holder<typename Config::equal> -{ - typedef typename Config::equal equal; - typedef typename Config::hash hasher; - typedef typename Config::bucket_traits bucket_traits; - - template<class BucketTraits> - bucket_hash_equal_t(BOOST_FWD_REF(BucketTraits) b_traits, const hasher & h, const equal &e) - : detail::ebo_functor_holder<typename Config::equal>(e)//equal() - , bucket_hash(::boost::forward<BucketTraits>(b_traits), h) - {} - - template<class T> - void set_cache(T) - {} - - bucket_hash_t<Config> bucket_hash; -}; - -template<class Config> //cache_begin == true version -struct bucket_hash_equal_t<Config, true> - : public detail::ebo_functor_holder<typename Config::equal> -{ - typedef typename Config::equal equal; - typedef typename Config::hash hasher; - typedef typename Config::bucket_traits bucket_traits; - typedef typename unordered_bucket_ptr_impl - <typename Config::value_traits>::type bucket_ptr; - - template<class BucketTraits> - bucket_hash_equal_t(BOOST_FWD_REF(BucketTraits) b_traits, const hasher & h, const equal &e) - : detail::ebo_functor_holder<typename Config::equal>(e) //equal() - , bucket_hash(::boost::forward<BucketTraits>(b_traits), h) - {} - - void set_cache(const bucket_ptr & c) - { cached_begin_ = c; } - - bucket_hash_t<Config> bucket_hash; - bucket_ptr cached_begin_; -}; - -template<class Config> -struct hashtable_data_t : public Config::value_traits -{ - static const std::size_t bool_flags = Config::bool_flags; - typedef typename Config::value_traits value_traits; - typedef typename Config::equal equal; - typedef typename Config::hash hasher; - typedef typename Config::bucket_traits bucket_traits; - - template<class BucketTraits> - hashtable_data_t( BOOST_FWD_REF(BucketTraits) b_traits, const hasher & h - , const equal &e, const value_traits &val_traits) - : Config::value_traits(val_traits) //value_traits - , internal_(::boost::forward<BucketTraits>(b_traits), h, e) - {} - typedef typename detail::usetopt_mask - < Config - , detail::hash_bool_flags::constant_time_size_pos - | detail::hash_bool_flags::incremental_pos - >::type masked_config_t; - struct internal - : public detail::size_holder //split_traits - < 0 != (Config::bool_flags & hash_bool_flags::incremental_pos) - , typename Config::size_type> - { - template<class BucketTraits> - internal(BOOST_FWD_REF(BucketTraits) b_traits, const hasher & h, const equal &e) - : bucket_hash_equal_(::boost::forward<BucketTraits>(b_traits), h, e) - {} - - bucket_hash_equal_t - < masked_config_t - , 0 != (bool_flags & hash_bool_flags::cache_begin_pos) - > bucket_hash_equal_; - } internal_; -}; - -struct insert_commit_data_impl -{ - std::size_t hash; -}; - -template<class NodeTraits> -struct group_functions -{ - typedef NodeTraits node_traits; - typedef unordered_group_adapter<node_traits> group_traits; - typedef typename node_traits::node_ptr node_ptr; - typedef typename node_traits::node node; - typedef typename reduced_slist_node_traits - <node_traits>::type reduced_node_traits; - typedef typename reduced_node_traits::node_ptr slist_node_ptr; - typedef typename reduced_node_traits::node slist_node; - typedef circular_slist_algorithms<group_traits> group_algorithms; - - static node_ptr dcast_bucket_ptr(const slist_node_ptr &p) - { return pointer_traits<node_ptr>::pointer_to(static_cast<node&>(*p)); } - - static slist_node_ptr get_bucket_before_begin - (const slist_node_ptr &bucket_beg, const slist_node_ptr &bucket_end, const node_ptr &p) - { - //First find the last node of p's group. - //This requires checking the first node of the next group or - //the bucket node. - node_ptr prev_node = p; - node_ptr nxt(node_traits::get_next(p)); - while(!(bucket_beg <= nxt && nxt <= bucket_end) && - (group_traits::get_next(nxt) == prev_node)){ - prev_node = nxt; - nxt = node_traits::get_next(nxt); - } - - //If we've reached the bucket node just return it. - if(bucket_beg <= nxt && nxt <= bucket_end){ - return nxt; - } - - //Otherwise, iterate using group links until the bucket node - node_ptr first_node_of_group = nxt; - node_ptr last_node_group = group_traits::get_next(first_node_of_group); - slist_node_ptr possible_end = node_traits::get_next(last_node_group); - - while(!(bucket_beg <= possible_end && possible_end <= bucket_end)){ - first_node_of_group = dcast_bucket_ptr(possible_end); - last_node_group = group_traits::get_next(first_node_of_group); - possible_end = node_traits::get_next(last_node_group); - } - return possible_end; - } - - static node_ptr get_prev_to_first_in_group(const slist_node_ptr &bucket_node, const node_ptr &first_in_group) - { - //Just iterate using group links and obtain the node - //before "first_in_group)" - node_ptr prev_node = dcast_bucket_ptr(bucket_node); - node_ptr nxt(node_traits::get_next(prev_node)); - while(nxt != first_in_group){ - prev_node = group_traits::get_next(nxt); - nxt = node_traits::get_next(prev_node); - } - return prev_node; - } - - static node_ptr get_first_in_group_of_last_in_group(const node_ptr &last_in_group) - { - //Just iterate using group links and obtain the node - //before "last_in_group" - node_ptr possible_first = group_traits::get_next(last_in_group); - node_ptr possible_first_prev = group_traits::get_next(possible_first); - // The deleted node is at the end of the group, so the - // node in the group pointing to it is at the beginning - // of the group. Find that to change its pointer. - while(possible_first_prev != last_in_group){ - possible_first = possible_first_prev; - possible_first_prev = group_traits::get_next(possible_first); - } - return possible_first; - } - - static void erase_from_group(const slist_node_ptr &end_ptr, const node_ptr &to_erase_ptr, detail::true_) - { - node_ptr nxt_ptr(node_traits::get_next(to_erase_ptr)); - node_ptr prev_in_group_ptr(group_traits::get_next(to_erase_ptr)); - bool last_in_group = (end_ptr == nxt_ptr) || - (group_traits::get_next(nxt_ptr) != to_erase_ptr); - bool first_in_group = node_traits::get_next(prev_in_group_ptr) != to_erase_ptr; - - if(first_in_group && last_in_group){ - group_algorithms::init(to_erase_ptr); - } - else if(first_in_group){ - group_algorithms::unlink_after(nxt_ptr); - } - else if(last_in_group){ - node_ptr first_in_group = - get_first_in_group_of_last_in_group(to_erase_ptr); - group_algorithms::unlink_after(first_in_group); - } - else{ - group_algorithms::unlink_after(nxt_ptr); - } - } - - static void erase_from_group(const slist_node_ptr&, const node_ptr&, detail::false_) - {} - - static node_ptr get_last_in_group(const node_ptr &first_in_group, detail::true_) - { return group_traits::get_next(first_in_group); } - - static node_ptr get_last_in_group(const node_ptr &n, detail::false_) - { return n; } - - static void init_group(const node_ptr &n, true_) - { group_algorithms::init(n); } - - static void init_group(const node_ptr &, false_) - {} - - static void insert_in_group(const node_ptr &first_in_group, const node_ptr &n, true_) - { - if(first_in_group){ - if(group_algorithms::unique(first_in_group)) - group_algorithms::link_after(first_in_group, n); - else{ - group_algorithms::link_after(group_algorithms::node_traits::get_next(first_in_group), n); - } - } - else{ - group_algorithms::init_header(n); - } - } - - static slist_node_ptr get_previous_and_next_in_group - ( const slist_node_ptr &i, node_ptr &nxt_in_group - //If first_end_ptr == last_end_ptr, then first_end_ptr is the bucket of i - //Otherwise first_end_ptr is the first bucket and last_end_ptr the last one. - , const slist_node_ptr &first_end_ptr, const slist_node_ptr &last_end_ptr) - { - slist_node_ptr prev; - node_ptr elem(dcast_bucket_ptr(i)); - - //It's the last in group if the next_node is a bucket - slist_node_ptr nxt(node_traits::get_next(elem)); - bool last_in_group = (first_end_ptr <= nxt && nxt <= last_end_ptr)/* || - (group_traits::get_next(nxt) != elem)*/; - //It's the first in group if group_previous's next_node is not - //itself, as group list does not link bucket - node_ptr prev_in_group(group_traits::get_next(elem)); - bool first_in_group = node_traits::get_next(prev_in_group) != elem; - - if(first_in_group){ - node_ptr start_pos; - if(last_in_group){ - start_pos = elem; - nxt_in_group = node_ptr(); - } - else{ - start_pos = prev_in_group; - nxt_in_group = node_traits::get_next(elem); - } - slist_node_ptr bucket_node; - if(first_end_ptr != last_end_ptr){ - bucket_node = group_functions::get_bucket_before_begin - (first_end_ptr, last_end_ptr, start_pos); - } - else{ - bucket_node = first_end_ptr; - } - prev = group_functions::get_prev_to_first_in_group(bucket_node, elem); - } - else{ - if(last_in_group){ - nxt_in_group = group_functions::get_first_in_group_of_last_in_group(elem); - } - else{ - nxt_in_group = node_traits::get_next(elem); - } - prev = group_traits::get_next(elem); - } - return prev; - } - - static void insert_in_group(const node_ptr&, const node_ptr&, false_) - {} -}; - -template<class BucketType, class SplitTraits> -class incremental_rehash_rollback -{ - private: - typedef BucketType bucket_type; - typedef SplitTraits split_traits; - - incremental_rehash_rollback(); - incremental_rehash_rollback & operator=(const incremental_rehash_rollback &); - incremental_rehash_rollback (const incremental_rehash_rollback &); - - public: - incremental_rehash_rollback - (bucket_type &source_bucket, bucket_type &destiny_bucket, split_traits &split_traits) - : source_bucket_(source_bucket), destiny_bucket_(destiny_bucket) - , split_traits_(split_traits), released_(false) - {} - - void release() - { released_ = true; } - - ~incremental_rehash_rollback() - { - if(!released_){ - //If an exception is thrown, just put all moved nodes back in the old bucket - //and move back the split mark. - destiny_bucket_.splice_after(destiny_bucket_.before_begin(), source_bucket_); - split_traits_.decrement(); - } - } - - private: - bucket_type &source_bucket_; - bucket_type &destiny_bucket_; - split_traits &split_traits_; - bool released_; -}; - -template<class NodeTraits> -struct node_functions -{ - static void store_hash(typename NodeTraits::node_ptr p, std::size_t h, true_) - { return NodeTraits::set_hash(p, h); } - - static void store_hash(typename NodeTraits::node_ptr, std::size_t, false_) - {} -}; - -} //namespace detail { - -//!This metafunction will obtain the type of a bucket -//!from the value_traits or hook option to be used with -//!a hash container. -template<class ValueTraitsOrHookOption> -struct unordered_bucket - : public detail::unordered_bucket_impl - <typename ValueTraitsOrHookOption:: - template pack<none>::value_traits - > -{}; - -//!This metafunction will obtain the type of a bucket pointer -//!from the value_traits or hook option to be used with -//!a hash container. -template<class ValueTraitsOrHookOption> -struct unordered_bucket_ptr - : public detail::unordered_bucket_ptr_impl - <typename ValueTraitsOrHookOption:: - template pack<none>::value_traits - > -{}; - -//!This metafunction will obtain the type of the default bucket traits -//!(when the user does not specify the bucket_traits<> option) from the -//!value_traits or hook option to be used with -//!a hash container. -template<class ValueTraitsOrHookOption> -struct unordered_default_bucket_traits -{ - typedef typename ValueTraitsOrHookOption:: - template pack<none>::value_traits supposed_value_traits; - typedef typename detail:: - get_slist_impl_from_supposed_value_traits - <supposed_value_traits>::type slist_impl; - typedef detail::bucket_traits_impl - <slist_impl> implementation_defined; - typedef implementation_defined type; -}; - -struct default_bucket_traits; - -template <class T> -struct uset_defaults - : pack_options - < none - , base_hook<detail::default_uset_hook> - , constant_time_size<true> - , size_type<std::size_t> - , equal<std::equal_to<T> > - , hash<boost::hash<T> > - , bucket_traits<default_bucket_traits> - , power_2_buckets<false> - , cache_begin<false> - , compare_hash<false> - , incremental<false> - >::type -{}; - -/// @endcond - -//! The class template hashtable is an intrusive hash table container, that -//! is used to construct intrusive unordered_set and unordered_multiset containers. The -//! no-throw guarantee holds only, if the Equal object and Hasher don't throw. -//! -//! hashtable is a semi-intrusive container: each object to be stored in the -//! container must contain a proper hook, but the container also needs -//! additional auxiliary memory to work: hashtable needs a pointer to an array -//! of type `bucket_type` to be passed in the constructor. This bucket array must -//! have at least the same lifetime as the container. This makes the use of -//! hashtable more complicated than purely intrusive containers. -//! `bucket_type` is default-constructible, copyable and assignable -//! -//! The template parameter \c T is the type to be managed by the container. -//! The user can specify additional options and if no options are provided -//! default options are used. -//! -//! The container supports the following options: -//! \c base_hook<>/member_hook<>/value_traits<>, -//! \c constant_time_size<>, \c size_type<>, \c hash<> and \c equal<> -//! \c bucket_traits<>, power_2_buckets<>, cache_begin<> and incremental<>. -//! -//! hashtable only provides forward iterators but it provides 4 iterator types: -//! iterator and const_iterator to navigate through the whole container and -//! local_iterator and const_local_iterator to navigate through the values -//! stored in a single bucket. Local iterators are faster and smaller. -//! -//! It's not recommended to use non constant-time size hashtables because several -//! key functions, like "empty()", become non-constant time functions. Non -//! constant_time size hashtables are mainly provided to support auto-unlink hooks. -//! -//! hashtables, does not make automatic rehashings nor -//! offers functions related to a load factor. Rehashing can be explicitly requested -//! and the user must provide a new bucket array that will be used from that moment. -//! -//! Since no automatic rehashing is done, iterators are never invalidated when -//! inserting or erasing elements. Iterators are only invalidated when rehashing. -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -class hashtable_impl - : private detail::clear_on_destructor_base<hashtable_impl<Config> > -{ - template<class C> friend class detail::clear_on_destructor_base; - public: - typedef typename Config::value_traits value_traits; - - /// @cond - static const bool external_value_traits = - detail::external_value_traits_is_true<value_traits>::value; - typedef typename detail::eval_if_c - < external_value_traits - , detail::eval_value_traits<value_traits> - , detail::identity<value_traits> - >::type real_value_traits; - typedef typename Config::bucket_traits bucket_traits; - static const bool external_bucket_traits = - detail::external_bucket_traits_is_true<bucket_traits>::value; - typedef typename detail::eval_if_c - < external_bucket_traits - , detail::eval_bucket_traits<bucket_traits> - , detail::identity<bucket_traits> - >::type real_bucket_traits; - typedef typename detail::get_slist_impl - <typename detail::reduced_slist_node_traits - <typename real_value_traits::node_traits>::type - >::type slist_impl; - /// @endcond - - typedef typename real_value_traits::pointer pointer; - typedef typename real_value_traits::const_pointer const_pointer; - typedef typename real_value_traits::value_type value_type; - typedef typename pointer_traits<pointer>::reference reference; - typedef typename pointer_traits<const_pointer>::reference const_reference; - typedef typename pointer_traits<pointer>::difference_type difference_type; - typedef typename Config::size_type size_type; - typedef value_type key_type; - typedef typename Config::equal key_equal; - typedef typename Config::hash hasher; - typedef detail::bucket_impl<slist_impl> bucket_type; - typedef typename pointer_traits - <pointer>::template rebind_pointer - < bucket_type >::type bucket_ptr; - typedef typename slist_impl::iterator siterator; - typedef typename slist_impl::const_iterator const_siterator; - typedef detail::hashtable_iterator<hashtable_impl, false> iterator; - typedef detail::hashtable_iterator<hashtable_impl, true> const_iterator; - typedef typename real_value_traits::node_traits node_traits; - typedef typename node_traits::node node; - typedef typename pointer_traits - <pointer>::template rebind_pointer - < node >::type node_ptr; - typedef typename pointer_traits - <pointer>::template rebind_pointer - < const node >::type const_node_ptr; - typedef typename slist_impl::node_algorithms node_algorithms; - - static const bool stateful_value_traits = detail::is_stateful_value_traits<real_value_traits>::value; - static const bool store_hash = detail::store_hash_is_true<node_traits>::value; - - static const bool unique_keys = 0 != (Config::bool_flags & detail::hash_bool_flags::unique_keys_pos); - static const bool constant_time_size = 0 != (Config::bool_flags & detail::hash_bool_flags::constant_time_size_pos); - static const bool cache_begin = 0 != (Config::bool_flags & detail::hash_bool_flags::cache_begin_pos); - static const bool compare_hash = 0 != (Config::bool_flags & detail::hash_bool_flags::compare_hash_pos); - static const bool incremental = 0 != (Config::bool_flags & detail::hash_bool_flags::incremental_pos); - static const bool power_2_buckets = incremental || (0 != (Config::bool_flags & detail::hash_bool_flags::power_2_buckets_pos)); - - static const bool optimize_multikey - = detail::optimize_multikey_is_true<node_traits>::value && !unique_keys; - - /// @cond - private: - - //Configuration error: compare_hash<> can't be specified without store_hash<> - //See documentation for more explanations - BOOST_STATIC_ASSERT((!compare_hash || store_hash)); - - typedef typename slist_impl::node_ptr slist_node_ptr; - typedef typename pointer_traits - <slist_node_ptr>::template rebind_pointer - < void >::type void_pointer; - //We'll define group traits, but these won't be instantiated if - //optimize_multikey is not true - typedef unordered_group_adapter<node_traits> group_traits; - typedef circular_slist_algorithms<group_traits> group_algorithms; - typedef detail::bool_<store_hash> store_hash_t; - typedef detail::bool_<optimize_multikey> optimize_multikey_t; - typedef detail::bool_<cache_begin> cache_begin_t; - typedef detail::bool_<power_2_buckets> power_2_buckets_t; - typedef detail::size_holder<constant_time_size, size_type> size_traits; - typedef detail::size_holder<incremental, size_type> split_traits; - typedef detail::group_functions<node_traits> group_functions_t; - typedef detail::node_functions<node_traits> node_functions_t; - - static const std::size_t hashtable_data_bool_flags_mask = - ( detail::hash_bool_flags::cache_begin_pos - | detail::hash_bool_flags::constant_time_size_pos - | detail::hash_bool_flags::incremental_pos - ); - typedef typename detail::usetopt_mask - <Config, hashtable_data_bool_flags_mask>::type masked_config_t; - detail::hashtable_data_t<masked_config_t> data_; - - template<bool IsConst> - struct downcast_node_to_value - : public detail::node_to_value<hashtable_impl, IsConst> - { - typedef detail::node_to_value<hashtable_impl, IsConst> base_t; - typedef typename base_t::result_type result_type; - typedef typename detail::add_const_if_c - <typename slist_impl::node, IsConst>::type &first_argument_type; - typedef typename detail::add_const_if_c - <node, IsConst>::type &intermediate_argument_type; - - downcast_node_to_value(const hashtable_impl *cont) - : base_t(cont) - {} - - result_type operator()(first_argument_type arg) const - { return this->base_t::operator()(static_cast<intermediate_argument_type>(arg)); } - }; - - template<class F> - struct node_cast_adaptor - : private detail::ebo_functor_holder<F> - { - typedef detail::ebo_functor_holder<F> base_t; - - template<class ConvertibleToF> - node_cast_adaptor(const ConvertibleToF &c2f, const hashtable_impl *cont) - : base_t(base_t(c2f, cont)) - {} - - typename base_t::node_ptr operator()(const typename slist_impl::node &to_clone) - { return base_t::operator()(static_cast<const node &>(to_clone)); } - - void operator()(typename slist_impl::node_ptr to_clone) - { - base_t::operator()(pointer_traits<node_ptr>::pointer_to(static_cast<node &>(*to_clone))); - } - }; - - private: - //noncopyable, movable - BOOST_MOVABLE_BUT_NOT_COPYABLE(hashtable_impl) - - enum { safemode_or_autounlink = - (int)real_value_traits::link_mode == (int)auto_unlink || - (int)real_value_traits::link_mode == (int)safe_link }; - - //Constant-time size is incompatible with auto-unlink hooks! - BOOST_STATIC_ASSERT(!(constant_time_size && ((int)real_value_traits::link_mode == (int)auto_unlink))); - //Cache begin is incompatible with auto-unlink hooks! - BOOST_STATIC_ASSERT(!(cache_begin && ((int)real_value_traits::link_mode == (int)auto_unlink))); - - template<class Disposer> - node_cast_adaptor<detail::node_disposer<Disposer, hashtable_impl> > - make_node_disposer(const Disposer &disposer) const - { return node_cast_adaptor<detail::node_disposer<Disposer, hashtable_impl> >(disposer, this); } - - /// @endcond - - public: - typedef detail::insert_commit_data_impl insert_commit_data; - - typedef detail::transform_iterator - < typename slist_impl::iterator - , downcast_node_to_value<false> > local_iterator; - - typedef detail::transform_iterator - < typename slist_impl::iterator - , downcast_node_to_value<true> > const_local_iterator; - - /// @cond - - const real_value_traits &get_real_value_traits(detail::false_) const - { return this->data_; } - - const real_value_traits &get_real_value_traits(detail::true_) const - { return data_.get_value_traits(*this); } - - real_value_traits &get_real_value_traits(detail::false_) - { return this->data_; } - - real_value_traits &get_real_value_traits(detail::true_) - { return data_.get_value_traits(*this); } - - /// @endcond - - public: - - const real_value_traits &get_real_value_traits() const - { return this->get_real_value_traits(detail::bool_<external_value_traits>()); } - - real_value_traits &get_real_value_traits() - { return this->get_real_value_traits(detail::bool_<external_value_traits>()); } - - //! <b>Requires</b>: buckets must not be being used by any other resource. - //! - //! <b>Effects</b>: Constructs an empty unordered_set, storing a reference - //! to the bucket array and copies of the key_hasher and equal_func functors. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: If value_traits::node_traits::node - //! constructor throws (this does not happen with predefined Boost.Intrusive hooks) - //! or the copy constructor or invocation of hash_func or equal_func throws. - //! - //! <b>Notes</b>: buckets array must be disposed only after - //! *this is disposed. - hashtable_impl ( const bucket_traits &b_traits - , const hasher & hash_func = hasher() - , const key_equal &equal_func = key_equal() - , const value_traits &v_traits = value_traits()) - : data_(b_traits, hash_func, equal_func, v_traits) - { - priv_initialize_buckets(); - this->priv_size_traits().set_size(size_type(0)); - size_type bucket_size = this->priv_buckets_len(); - BOOST_INTRUSIVE_INVARIANT_ASSERT(bucket_size != 0); - //Check power of two bucket array if the option is activated - BOOST_INTRUSIVE_INVARIANT_ASSERT - (!power_2_buckets || (0 == (bucket_size & (bucket_size-1)))); - priv_split_traits().set_size(bucket_size>>1); - } - - //! <b>Effects</b>: to-do - //! - hashtable_impl(BOOST_RV_REF(hashtable_impl) x) - : data_( ::boost::move(x.priv_bucket_traits()) - , ::boost::move(x.priv_hasher()) - , ::boost::move(x.priv_equal()) - , ::boost::move(x.priv_value_traits()) - ) - { - priv_swap_cache(cache_begin_t(), x); - x.priv_initialize_cache(); - if(constant_time_size){ - this->priv_size_traits().set_size(size_type(0)); - this->priv_size_traits().set_size(x.priv_size_traits().get_size()); - x.priv_size_traits().set_size(size_type(0)); - } - if(incremental){ - this->priv_split_traits().set_size(x.priv_split_traits().get_size()); - x.priv_split_traits().set_size(size_type(0)); - } - } - - //! <b>Effects</b>: to-do - //! - hashtable_impl& operator=(BOOST_RV_REF(hashtable_impl) x) - { this->swap(x); return *this; } - - //! <b>Effects</b>: Detaches all elements from this. The objects in the unordered_set - //! are not deleted (i.e. no destructors are called). - //! - //! <b>Complexity</b>: Linear to the number of elements in the unordered_set, if - //! it's a safe-mode or auto-unlink value. Otherwise constant. - //! - //! <b>Throws</b>: Nothing. - ~hashtable_impl() - {} - - //! <b>Effects</b>: Returns an iterator pointing to the beginning of the unordered_set. - //! - //! <b>Complexity</b>: Amortized constant time. - //! Worst case (empty unordered_set): O(this->bucket_count()) - //! - //! <b>Throws</b>: Nothing. - iterator begin() - { return iterator(this->priv_begin(), this); } - - //! <b>Effects</b>: Returns a const_iterator pointing to the beginning - //! of the unordered_set. - //! - //! <b>Complexity</b>: Amortized constant time. - //! Worst case (empty unordered_set): O(this->bucket_count()) - //! - //! <b>Throws</b>: Nothing. - const_iterator begin() const - { return this->cbegin(); } - - //! <b>Effects</b>: Returns a const_iterator pointing to the beginning - //! of the unordered_set. - //! - //! <b>Complexity</b>: Amortized constant time. - //! Worst case (empty unordered_set): O(this->bucket_count()) - //! - //! <b>Throws</b>: Nothing. - const_iterator cbegin() const - { return const_iterator(this->priv_begin(), this); } - - //! <b>Effects</b>: Returns an iterator pointing to the end of the unordered_set. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - iterator end() - { return iterator(priv_invalid_local_it(), 0); } - - //! <b>Effects</b>: Returns a const_iterator pointing to the end of the unordered_set. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_iterator end() const - { return this->cend(); } - - //! <b>Effects</b>: Returns a const_iterator pointing to the end of the unordered_set. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_iterator cend() const - { return const_iterator(priv_invalid_local_it(), 0); } - - //! <b>Effects</b>: Returns the hasher object used by the unordered_set. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: If hasher copy-constructor throws. - hasher hash_function() const - { return this->priv_hasher(); } - - //! <b>Effects</b>: Returns the key_equal object used by the unordered_set. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: If key_equal copy-constructor throws. - key_equal key_eq() const - { return this->priv_equal(); } - - //! <b>Effects</b>: Returns true if the container is empty. - //! - //! <b>Complexity</b>: if constant-time size and cache_begin options are disabled, - //! average constant time (worst case, with empty() == true: O(this->bucket_count()). - //! Otherwise constant. - //! - //! <b>Throws</b>: Nothing. - bool empty() const - { - if(constant_time_size){ - return !this->size(); - } - else if(cache_begin){ - return this->begin() == this->end(); - } - else{ - size_type buckets_len = this->priv_buckets_len(); - const bucket_type *b = boost::intrusive::detail::to_raw_pointer(this->priv_buckets()); - for (size_type n = 0; n < buckets_len; ++n, ++b){ - if(!b->empty()){ - return false; - } - } - return true; - } - } - - //! <b>Effects</b>: Returns the number of elements stored in the unordered_set. - //! - //! <b>Complexity</b>: Linear to elements contained in *this if - //! constant_time_size is false. Constant-time otherwise. - //! - //! <b>Throws</b>: Nothing. - size_type size() const - { - if(constant_time_size) - return this->priv_size_traits().get_size(); - else{ - size_type len = 0; - size_type buckets_len = this->priv_buckets_len(); - const bucket_type *b = boost::intrusive::detail::to_raw_pointer(this->priv_buckets()); - for (size_type n = 0; n < buckets_len; ++n, ++b){ - len += b->size(); - } - return len; - } - } - - //! <b>Requires</b>: the hasher and the equality function unqualified swap - //! call should not throw. - //! - //! <b>Effects</b>: Swaps the contents of two unordered_sets. - //! Swaps also the contained bucket array and equality and hasher functors. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: If the swap() call for the comparison or hash functors - //! found using ADL throw. Basic guarantee. - void swap(hashtable_impl& other) - { - using std::swap; - //These can throw - swap(this->priv_equal(), other.priv_equal()); - swap(this->priv_hasher(), other.priv_hasher()); - //These can't throw - swap(this->priv_bucket_traits(), other.priv_bucket_traits()); - swap(this->priv_value_traits(), other.priv_value_traits()); - priv_swap_cache(cache_begin_t(), other); - if(constant_time_size){ - size_type backup = this->priv_size_traits().get_size(); - this->priv_size_traits().set_size(other.priv_size_traits().get_size()); - other.priv_size_traits().set_size(backup); - } - if(incremental){ - size_type backup = this->priv_split_traits().get_size(); - this->priv_split_traits().set_size(other.priv_split_traits().get_size()); - other.priv_split_traits().set_size(backup); - } - } - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw - //! Cloner should yield to nodes that compare equal and produce the same - //! hash than the original node. - //! - //! <b>Effects</b>: Erases all the elements from *this - //! calling Disposer::operator()(pointer), clones all the - //! elements from src calling Cloner::operator()(const_reference ) - //! and inserts them on *this. The hash function and the equality - //! predicate are copied from the source. - //! - //! If store_hash option is true, this method does not use the hash function. - //! - //! If any operation throws, all cloned elements are unlinked and disposed - //! calling Disposer::operator()(pointer). - //! - //! <b>Complexity</b>: Linear to erased plus inserted elements. - //! - //! <b>Throws</b>: If cloner or hasher throw or hash or equality predicate copying - //! throws. Basic guarantee. - template <class Cloner, class Disposer> - void clone_from(const hashtable_impl &src, Cloner cloner, Disposer disposer) - { - this->clear_and_dispose(disposer); - if(!constant_time_size || !src.empty()){ - const size_type src_bucket_count = src.bucket_count(); - const size_type dst_bucket_count = this->bucket_count(); - //Check power of two bucket array if the option is activated - BOOST_INTRUSIVE_INVARIANT_ASSERT - (!power_2_buckets || (0 == (src_bucket_count & (src_bucket_count-1)))); - BOOST_INTRUSIVE_INVARIANT_ASSERT - (!power_2_buckets || (0 == (dst_bucket_count & (dst_bucket_count-1)))); - - //If src bucket count is bigger or equal, structural copy is possible - if(!incremental && (src_bucket_count >= dst_bucket_count)){ - //First clone the first ones - const bucket_ptr src_buckets = src.priv_buckets(); - const bucket_ptr dst_buckets = this->priv_buckets(); - size_type constructed; - typedef node_cast_adaptor<detail::node_disposer<Disposer, hashtable_impl> > NodeDisposer; - typedef node_cast_adaptor<detail::node_cloner<Cloner, hashtable_impl> > NodeCloner; - NodeDisposer node_disp(disposer, this); - - detail::exception_array_disposer<bucket_type, NodeDisposer, size_type> - rollback(dst_buckets[0], node_disp, constructed); - for( constructed = 0 - ; constructed < dst_bucket_count - ; ++constructed){ - dst_buckets[constructed].clone_from - ( src_buckets[constructed] - , NodeCloner(cloner, this), node_disp); - } - if(src_bucket_count != dst_bucket_count){ - //Now insert the remaining ones using the modulo trick - for(//"constructed" comes from the previous loop - ; constructed < src_bucket_count - ; ++constructed){ - bucket_type &dst_b = - dst_buckets[priv_hash_to_bucket(constructed, dst_bucket_count, dst_bucket_count)]; - bucket_type &src_b = src_buckets[constructed]; - for( siterator b(src_b.begin()), e(src_b.end()) - ; b != e - ; ++b){ - dst_b.push_front(*(NodeCloner(cloner, this)(*b.pointed_node()))); - } - } - } - this->priv_hasher() = src.priv_hasher(); - this->priv_equal() = src.priv_equal(); - rollback.release(); - this->priv_size_traits().set_size(src.priv_size_traits().get_size()); - this->priv_split_traits().set_size(dst_bucket_count); - priv_insertion_update_cache(0u); - priv_erasure_update_cache(); - } - else if(store_hash){ - //Unlike previous cloning algorithm, this can throw - //if cloner, hasher or comparison functor throw - const_iterator b(src.begin()), e(src.end()); - detail::exception_disposer<hashtable_impl, Disposer> - rollback(*this, disposer); - for(; b != e; ++b){ - std::size_t hash_value = this->priv_stored_or_compute_hash(*b, store_hash_t());; - this->priv_insert_equal_with_hash(*cloner(*b), hash_value); - } - rollback.release(); - } - else{ - //Unlike previous cloning algorithm, this can throw - //if cloner, hasher or comparison functor throw - const_iterator b(src.begin()), e(src.end()); - detail::exception_disposer<hashtable_impl, Disposer> - rollback(*this, disposer); - for(; b != e; ++b){ - this->insert_equal(*cloner(*b)); - } - rollback.release(); - } - } - } - - //! <b>Requires</b>: value must be an lvalue - //! - //! <b>Effects</b>: Inserts the value into the unordered_set. - //! - //! <b>Returns</b>: An iterator to the inserted value. - //! - //! <b>Complexity</b>: Average case O(1), worst case O(this->size()). - //! - //! <b>Throws</b>: If the internal hasher or the equality functor throws. Strong guarantee. - //! - //! <b>Note</b>: Does not affect the validity of iterators and references. - //! No copy-constructors are called. - iterator insert_equal(reference value) - { - size_type bucket_num; - std::size_t hash_value; - siterator prev; - siterator it = this->priv_find - (value, this->priv_hasher(), this->priv_equal(), bucket_num, hash_value, prev); - return priv_insert_equal_find(value, bucket_num, hash_value, it); - } - - //! <b>Requires</b>: Dereferencing iterator must yield an lvalue - //! of type value_type. - //! - //! <b>Effects</b>: Equivalent to this->insert_equal(t) for each element in [b, e). - //! - //! <b>Complexity</b>: Average case O(N), where N is std::distance(b, e). - //! Worst case O(N*this->size()). - //! - //! <b>Throws</b>: If the internal hasher or the equality functor throws. Basic guarantee. - //! - //! <b>Note</b>: Does not affect the validity of iterators and references. - //! No copy-constructors are called. - template<class Iterator> - void insert_equal(Iterator b, Iterator e) - { - for (; b != e; ++b) - this->insert_equal(*b); - } - - //! <b>Requires</b>: value must be an lvalue - //! - //! <b>Effects</b>: Tries to inserts value into the unordered_set. - //! - //! <b>Returns</b>: If the value - //! is not already present inserts it and returns a pair containing the - //! iterator to the new value and true. If there is an equivalent value - //! returns a pair containing an iterator to the already present value - //! and false. - //! - //! <b>Complexity</b>: Average case O(1), worst case O(this->size()). - //! - //! <b>Throws</b>: If the internal hasher or the equality functor throws. Strong guarantee. - //! - //! <b>Note</b>: Does not affect the validity of iterators and references. - //! No copy-constructors are called. - std::pair<iterator, bool> insert_unique(reference value) - { - insert_commit_data commit_data; - std::pair<iterator, bool> ret = this->insert_unique_check - (value, this->priv_hasher(), this->priv_equal(), commit_data); - if(!ret.second) - return ret; - return std::pair<iterator, bool> - (this->insert_unique_commit(value, commit_data), true); - } - - //! <b>Requires</b>: Dereferencing iterator must yield an lvalue - //! of type value_type. - //! - //! <b>Effects</b>: Equivalent to this->insert_unique(t) for each element in [b, e). - //! - //! <b>Complexity</b>: Average case O(N), where N is std::distance(b, e). - //! Worst case O(N*this->size()). - //! - //! <b>Throws</b>: If the internal hasher or the equality functor throws. Basic guarantee. - //! - //! <b>Note</b>: Does not affect the validity of iterators and references. - //! No copy-constructors are called. - template<class Iterator> - void insert_unique(Iterator b, Iterator e) - { - for (; b != e; ++b) - this->insert_unique(*b); - } - - //! <b>Requires</b>: "hash_func" must be a hash function that induces - //! the same hash values as the stored hasher. The difference is that - //! "hash_func" hashes the given key instead of the value_type. - //! - //! "equal_func" must be a equality function that induces - //! the same equality as key_equal. The difference is that - //! "equal_func" compares an arbitrary key with the contained values. - //! - //! <b>Effects</b>: Checks if a value can be inserted in the unordered_set, using - //! a user provided key instead of the value itself. - //! - //! <b>Returns</b>: If there is an equivalent value - //! returns a pair containing an iterator to the already present value - //! and false. If the value can be inserted returns true in the returned - //! pair boolean and fills "commit_data" that is meant to be used with - //! the "insert_commit" function. - //! - //! <b>Complexity</b>: Average case O(1), worst case O(this->size()). - //! - //! <b>Throws</b>: If hash_func or equal_func throw. Strong guarantee. - //! - //! <b>Notes</b>: This function is used to improve performance when constructing - //! a value_type is expensive: if there is an equivalent value - //! the constructed object must be discarded. Many times, the part of the - //! node that is used to impose the hash or the equality is much cheaper to - //! construct than the value_type and this function offers the possibility to - //! use that the part to check if the insertion will be successful. - //! - //! If the check is successful, the user can construct the value_type and use - //! "insert_commit" to insert the object in constant-time. - //! - //! "commit_data" remains valid for a subsequent "insert_commit" only if no more - //! objects are inserted or erased from the unordered_set. - //! - //! After a successful rehashing insert_commit_data remains valid. - template<class KeyType, class KeyHasher, class KeyValueEqual> - std::pair<iterator, bool> insert_unique_check - ( const KeyType &key - , KeyHasher hash_func - , KeyValueEqual equal_func - , insert_commit_data &commit_data) - { - size_type bucket_num; - siterator prev; - siterator prev_pos = - this->priv_find(key, hash_func, equal_func, bucket_num, commit_data.hash, prev); - bool success = prev_pos == priv_invalid_local_it(); - if(success){ - prev_pos = prev; - } - return std::pair<iterator, bool>(iterator(prev_pos, this),success); - } - - //! <b>Requires</b>: value must be an lvalue of type value_type. commit_data - //! must have been obtained from a previous call to "insert_check". - //! No objects should have been inserted or erased from the unordered_set between - //! the "insert_check" that filled "commit_data" and the call to "insert_commit". - //! - //! <b>Effects</b>: Inserts the value in the unordered_set using the information obtained - //! from the "commit_data" that a previous "insert_check" filled. - //! - //! <b>Returns</b>: An iterator to the newly inserted object. - //! - //! <b>Complexity</b>: Constant time. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Notes</b>: This function has only sense if a "insert_check" has been - //! previously executed to fill "commit_data". No value should be inserted or - //! erased between the "insert_check" and "insert_commit" calls. - //! - //! After a successful rehashing insert_commit_data remains valid. - iterator insert_unique_commit(reference value, const insert_commit_data &commit_data) - { - size_type bucket_num = priv_hash_to_bucket(commit_data.hash); - bucket_type &b = this->priv_buckets()[bucket_num]; - this->priv_size_traits().increment(); - node_ptr n = pointer_traits<node_ptr>::pointer_to(priv_value_to_node(value)); - node_functions_t::store_hash(n, commit_data.hash, store_hash_t()); - if(safemode_or_autounlink) - BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(n)); - priv_insertion_update_cache(bucket_num); - group_functions_t::insert_in_group(node_ptr(), n, optimize_multikey_t()); - return iterator(b.insert_after(b.before_begin(), *n), this); - } - - //! <b>Effects</b>: Erases the element pointed to by i. - //! - //! <b>Complexity</b>: Average case O(1), worst case O(this->size()). - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased element. No destructors are called. - void erase(const_iterator i) - { this->erase_and_dispose(i, detail::null_disposer()); } - - //! <b>Effects</b>: Erases the range pointed to by b end e. - //! - //! <b>Complexity</b>: Average case O(std::distance(b, e)), - //! worst case O(this->size()). - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - void erase(const_iterator b, const_iterator e) - { this->erase_and_dispose(b, e, detail::null_disposer()); } - - //! <b>Effects</b>: Erases all the elements with the given value. - //! - //! <b>Returns</b>: The number of erased elements. - //! - //! <b>Complexity</b>: Average case O(this->count(value)). - //! Worst case O(this->size()). - //! - //! <b>Throws</b>: If the internal hasher or the equality functor throws. - //! Basic guarantee. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - size_type erase(const_reference value) - { return this->erase(value, this->priv_hasher(), this->priv_equal()); } - - //! <b>Requires</b>: "hash_func" must be a hash function that induces - //! the same hash values as the stored hasher. The difference is that - //! "hash_func" hashes the given key instead of the value_type. - //! - //! "equal_func" must be a equality function that induces - //! the same equality as key_equal. The difference is that - //! "equal_func" compares an arbitrary key with the contained values. - //! - //! <b>Effects</b>: Erases all the elements that have the same hash and - //! compare equal with the given key. - //! - //! <b>Returns</b>: The number of erased elements. - //! - //! <b>Complexity</b>: Average case O(this->count(value)). - //! Worst case O(this->size()). - //! - //! <b>Throws</b>: If hash_func or equal_func throw. Basic guarantee. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - template<class KeyType, class KeyHasher, class KeyValueEqual> - size_type erase(const KeyType& key, KeyHasher hash_func, KeyValueEqual equal_func) - { return this->erase_and_dispose(key, hash_func, equal_func, detail::null_disposer()); } - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! - //! <b>Effects</b>: Erases the element pointed to by i. - //! Disposer::operator()(pointer) is called for the removed element. - //! - //! <b>Complexity</b>: Average case O(1), worst case O(this->size()). - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators - //! to the erased elements. - template<class Disposer> - void erase_and_dispose(const_iterator i, Disposer disposer - /// @cond - , typename detail::enable_if_c<!detail::is_convertible<Disposer, const_iterator>::value >::type * = 0 - /// @endcond - ) - { - priv_erase(i, disposer, optimize_multikey_t()); - this->priv_size_traits().decrement(); - priv_erasure_update_cache(); - } - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! - //! <b>Effects</b>: Erases the range pointed to by b end e. - //! Disposer::operator()(pointer) is called for the removed elements. - //! - //! <b>Complexity</b>: Average case O(std::distance(b, e)), - //! worst case O(this->size()). - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators - //! to the erased elements. - template<class Disposer> - void erase_and_dispose(const_iterator b, const_iterator e, Disposer disposer) - { - if(b != e){ - //Get the bucket number and local iterator for both iterators - siterator first_local_it(b.slist_it()); - size_type first_bucket_num = this->priv_get_bucket_num(first_local_it); - - siterator before_first_local_it - = priv_get_previous(priv_buckets()[first_bucket_num], first_local_it); - size_type last_bucket_num; - siterator last_local_it; - - //For the end iterator, we will assign the end iterator - //of the last bucket - if(e == this->end()){ - last_bucket_num = this->bucket_count() - 1; - last_local_it = priv_buckets()[last_bucket_num].end(); - } - else{ - last_local_it = e.slist_it(); - last_bucket_num = this->priv_get_bucket_num(last_local_it); - } - priv_erase_range(before_first_local_it, first_bucket_num, last_local_it, last_bucket_num, disposer); - priv_erasure_update_cache(first_bucket_num, last_bucket_num); - } - } - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! - //! <b>Effects</b>: Erases all the elements with the given value. - //! Disposer::operator()(pointer) is called for the removed elements. - //! - //! <b>Returns</b>: The number of erased elements. - //! - //! <b>Complexity</b>: Average case O(this->count(value)). - //! Worst case O(this->size()). - //! - //! <b>Throws</b>: If the internal hasher or the equality functor throws. - //! Basic guarantee. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - template<class Disposer> - size_type erase_and_dispose(const_reference value, Disposer disposer) - { return this->erase_and_dispose(value, priv_hasher(), priv_equal(), disposer); } - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! - //! <b>Effects</b>: Erases all the elements with the given key. - //! according to the comparison functor "equal_func". - //! Disposer::operator()(pointer) is called for the removed elements. - //! - //! <b>Returns</b>: The number of erased elements. - //! - //! <b>Complexity</b>: Average case O(this->count(value)). - //! Worst case O(this->size()). - //! - //! <b>Throws</b>: If hash_func or equal_func throw. Basic guarantee. - //! - //! <b>Note</b>: Invalidates the iterators - //! to the erased elements. - template<class KeyType, class KeyHasher, class KeyValueEqual, class Disposer> - size_type erase_and_dispose(const KeyType& key, KeyHasher hash_func - ,KeyValueEqual equal_func, Disposer disposer) - { - size_type bucket_num; - std::size_t h; - siterator prev; - siterator it = - this->priv_find(key, hash_func, equal_func, bucket_num, h, prev); - bool success = it != priv_invalid_local_it(); - size_type count(0); - if(!success){ - return 0; - } - else if(optimize_multikey){ - siterator last = bucket_type::s_iterator_to - (*node_traits::get_next(group_functions_t::get_last_in_group - (dcast_bucket_ptr(it.pointed_node()), optimize_multikey_t()))); - this->priv_erase_range_impl(bucket_num, prev, last, disposer, count); - } - else{ - //If found erase all equal values - bucket_type &b = this->priv_buckets()[bucket_num]; - for(siterator end = b.end(); it != end; ++count, ++it){ - slist_node_ptr n(it.pointed_node()); - const value_type &v = priv_value_from_slist_node(n); - if(compare_hash){ - std::size_t vh = this->priv_stored_or_compute_hash(v, store_hash_t()); - if(h != vh || !equal_func(key, v)){ - break; - } - } - else if(!equal_func(key, v)){ - break; - } - this->priv_size_traits().decrement(); - } - b.erase_after_and_dispose(prev, it, make_node_disposer(disposer)); - } - priv_erasure_update_cache(); - return count; - } - - //! <b>Effects</b>: Erases all of the elements. - //! - //! <b>Complexity</b>: Linear to the number of elements on the container. - //! if it's a safe-mode or auto-unlink value_type. Constant time otherwise. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - void clear() - { - priv_clear_buckets(); - this->priv_size_traits().set_size(size_type(0)); - } - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! - //! <b>Effects</b>: Erases all of the elements. - //! - //! <b>Complexity</b>: Linear to the number of elements on the container. - //! Disposer::operator()(pointer) is called for the removed elements. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - template<class Disposer> - void clear_and_dispose(Disposer disposer) - { - if(!constant_time_size || !this->empty()){ - size_type num_buckets = this->bucket_count(); - bucket_ptr b = this->priv_buckets(); - for(; num_buckets--; ++b){ - b->clear_and_dispose(make_node_disposer(disposer)); - } - this->priv_size_traits().set_size(size_type(0)); - } - priv_initialize_cache(); - } - - //! <b>Effects</b>: Returns the number of contained elements with the given value - //! - //! <b>Complexity</b>: Average case O(1), worst case O(this->size()). - //! - //! <b>Throws</b>: If the internal hasher or the equality functor throws. - size_type count(const_reference value) const - { return this->count(value, this->priv_hasher(), this->priv_equal()); } - - //! <b>Requires</b>: "hash_func" must be a hash function that induces - //! the same hash values as the stored hasher. The difference is that - //! "hash_func" hashes the given key instead of the value_type. - //! - //! "equal_func" must be a equality function that induces - //! the same equality as key_equal. The difference is that - //! "equal_func" compares an arbitrary key with the contained values. - //! - //! <b>Effects</b>: Returns the number of contained elements with the given key - //! - //! <b>Complexity</b>: Average case O(1), worst case O(this->size()). - //! - //! <b>Throws</b>: If hash_func or equal throw. - template<class KeyType, class KeyHasher, class KeyValueEqual> - size_type count(const KeyType &key, const KeyHasher &hash_func, const KeyValueEqual &equal_func) const - { - size_type bucket_n1, bucket_n2, count; - this->priv_equal_range(key, hash_func, equal_func, bucket_n1, bucket_n2, count); - return count; - } - - //! <b>Effects</b>: Finds an iterator to the first element is equal to - //! "value" or end() if that element does not exist. - //! - //! <b>Complexity</b>: Average case O(1), worst case O(this->size()). - //! - //! <b>Throws</b>: If the internal hasher or the equality functor throws. - iterator find(const_reference value) - { return this->find(value, this->priv_hasher(), this->priv_equal()); } - - //! <b>Requires</b>: "hash_func" must be a hash function that induces - //! the same hash values as the stored hasher. The difference is that - //! "hash_func" hashes the given key instead of the value_type. - //! - //! "equal_func" must be a equality function that induces - //! the same equality as key_equal. The difference is that - //! "equal_func" compares an arbitrary key with the contained values. - //! - //! <b>Effects</b>: Finds an iterator to the first element whose key is - //! "key" according to the given hash and equality functor or end() if - //! that element does not exist. - //! - //! <b>Complexity</b>: Average case O(1), worst case O(this->size()). - //! - //! <b>Throws</b>: If hash_func or equal_func throw. - //! - //! <b>Note</b>: This function is used when constructing a value_type - //! is expensive and the value_type can be compared with a cheaper - //! key type. Usually this key is part of the value_type. - template<class KeyType, class KeyHasher, class KeyValueEqual> - iterator find(const KeyType &key, KeyHasher hash_func, KeyValueEqual equal_func) - { - size_type bucket_n; - std::size_t hash; - siterator prev; - siterator local_it = this->priv_find(key, hash_func, equal_func, bucket_n, hash, prev); - return iterator(local_it, this); - } - - //! <b>Effects</b>: Finds a const_iterator to the first element whose key is - //! "key" or end() if that element does not exist. - //! - //! <b>Complexity</b>: Average case O(1), worst case O(this->size()). - //! - //! <b>Throws</b>: If the internal hasher or the equality functor throws. - const_iterator find(const_reference value) const - { return this->find(value, this->priv_hasher(), this->priv_equal()); } - - //! <b>Requires</b>: "hash_func" must be a hash function that induces - //! the same hash values as the stored hasher. The difference is that - //! "hash_func" hashes the given key instead of the value_type. - //! - //! "equal_func" must be a equality function that induces - //! the same equality as key_equal. The difference is that - //! "equal_func" compares an arbitrary key with the contained values. - //! - //! <b>Effects</b>: Finds an iterator to the first element whose key is - //! "key" according to the given hasher and equality functor or end() if - //! that element does not exist. - //! - //! <b>Complexity</b>: Average case O(1), worst case O(this->size()). - //! - //! <b>Throws</b>: If hash_func or equal_func throw. - //! - //! <b>Note</b>: This function is used when constructing a value_type - //! is expensive and the value_type can be compared with a cheaper - //! key type. Usually this key is part of the value_type. - template<class KeyType, class KeyHasher, class KeyValueEqual> - const_iterator find - (const KeyType &key, KeyHasher hash_func, KeyValueEqual equal_func) const - { - size_type bucket_n; - std::size_t hash_value; - siterator prev; - siterator sit = this->priv_find(key, hash_func, equal_func, bucket_n, hash_value, prev); - return const_iterator(sit, this); - } - - //! <b>Effects</b>: Returns a range containing all elements with values equivalent - //! to value. Returns std::make_pair(this->end(), this->end()) if no such - //! elements exist. - //! - //! <b>Complexity</b>: Average case O(this->count(value)). Worst case O(this->size()). - //! - //! <b>Throws</b>: If the internal hasher or the equality functor throws. - std::pair<iterator,iterator> equal_range(const_reference value) - { return this->equal_range(value, this->priv_hasher(), this->priv_equal()); } - - //! <b>Requires</b>: "hash_func" must be a hash function that induces - //! the same hash values as the stored hasher. The difference is that - //! "hash_func" hashes the given key instead of the value_type. - //! - //! "equal_func" must be a equality function that induces - //! the same equality as key_equal. The difference is that - //! "equal_func" compares an arbitrary key with the contained values. - //! - //! <b>Effects</b>: Returns a range containing all elements with equivalent - //! keys. Returns std::make_pair(this->end(), this->end()) if no such - //! elements exist. - //! - //! <b>Complexity</b>: Average case O(this->count(key, hash_func, equal_func)). - //! Worst case O(this->size()). - //! - //! <b>Throws</b>: If hash_func or the equal_func throw. - //! - //! <b>Note</b>: This function is used when constructing a value_type - //! is expensive and the value_type can be compared with a cheaper - //! key type. Usually this key is part of the value_type. - template<class KeyType, class KeyHasher, class KeyValueEqual> - std::pair<iterator,iterator> equal_range - (const KeyType &key, KeyHasher hash_func, KeyValueEqual equal_func) - { - size_type bucket_n1, bucket_n2, count; - std::pair<siterator, siterator> ret = this->priv_equal_range - (key, hash_func, equal_func, bucket_n1, bucket_n2, count); - return std::pair<iterator, iterator> - (iterator(ret.first, this), iterator(ret.second, this)); - } - - //! <b>Effects</b>: Returns a range containing all elements with values equivalent - //! to value. Returns std::make_pair(this->end(), this->end()) if no such - //! elements exist. - //! - //! <b>Complexity</b>: Average case O(this->count(value)). Worst case O(this->size()). - //! - //! <b>Throws</b>: If the internal hasher or the equality functor throws. - std::pair<const_iterator, const_iterator> - equal_range(const_reference value) const - { return this->equal_range(value, this->priv_hasher(), this->priv_equal()); } - - //! <b>Requires</b>: "hash_func" must be a hash function that induces - //! the same hash values as the stored hasher. The difference is that - //! "hash_func" hashes the given key instead of the value_type. - //! - //! "equal_func" must be a equality function that induces - //! the same equality as key_equal. The difference is that - //! "equal_func" compares an arbitrary key with the contained values. - //! - //! <b>Effects</b>: Returns a range containing all elements with equivalent - //! keys. Returns std::make_pair(this->end(), this->end()) if no such - //! elements exist. - //! - //! <b>Complexity</b>: Average case O(this->count(key, hash_func, equal_func)). - //! Worst case O(this->size()). - //! - //! <b>Throws</b>: If the hasher or equal_func throw. - //! - //! <b>Note</b>: This function is used when constructing a value_type - //! is expensive and the value_type can be compared with a cheaper - //! key type. Usually this key is part of the value_type. - template<class KeyType, class KeyHasher, class KeyValueEqual> - std::pair<const_iterator,const_iterator> equal_range - (const KeyType &key, KeyHasher hash_func, KeyValueEqual equal_func) const - { - size_type bucket_n1, bucket_n2, count; - std::pair<siterator, siterator> ret = - this->priv_equal_range(key, hash_func, equal_func, bucket_n1, bucket_n2, count); - return std::pair<const_iterator, const_iterator> - (const_iterator(ret.first, this), const_iterator(ret.second, this)); - } - - //! <b>Requires</b>: value must be an lvalue and shall be in a unordered_set of - //! appropriate type. Otherwise the behavior is undefined. - //! - //! <b>Effects</b>: Returns: a valid iterator belonging to the unordered_set - //! that points to the value - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: If the internal hash function throws. - iterator iterator_to(reference value) - { - return iterator(bucket_type::s_iterator_to(priv_value_to_node(value)), this); - } - - //! <b>Requires</b>: value must be an lvalue and shall be in a unordered_set of - //! appropriate type. Otherwise the behavior is undefined. - //! - //! <b>Effects</b>: Returns: a valid const_iterator belonging to the - //! unordered_set that points to the value - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: If the internal hash function throws. - const_iterator iterator_to(const_reference value) const - { - siterator sit = bucket_type::s_iterator_to(const_cast<node &>(this->priv_value_to_node(value))); - return const_iterator(sit, this); - } - - //! <b>Requires</b>: value must be an lvalue and shall be in a unordered_set of - //! appropriate type. Otherwise the behavior is undefined. - //! - //! <b>Effects</b>: Returns: a valid local_iterator belonging to the unordered_set - //! that points to the value - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: This static function is available only if the <i>value traits</i> - //! is stateless. - static local_iterator s_local_iterator_to(reference value) - { - BOOST_STATIC_ASSERT((!stateful_value_traits)); - siterator sit = bucket_type::s_iterator_to(((hashtable_impl*)0)->priv_value_to_node(value)); - return local_iterator(sit, (hashtable_impl*)0); - } - - //! <b>Requires</b>: value must be an lvalue and shall be in a unordered_set of - //! appropriate type. Otherwise the behavior is undefined. - //! - //! <b>Effects</b>: Returns: a valid const_local_iterator belonging to - //! the unordered_set that points to the value - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: This static function is available only if the <i>value traits</i> - //! is stateless. - static const_local_iterator s_local_iterator_to(const_reference value) - { - BOOST_STATIC_ASSERT((!stateful_value_traits)); - siterator sit = bucket_type::s_iterator_to(((hashtable_impl*)0)->priv_value_to_node(const_cast<value_type&>(value))); - return const_local_iterator(sit, (hashtable_impl*)0); - } - - //! <b>Requires</b>: value must be an lvalue and shall be in a unordered_set of - //! appropriate type. Otherwise the behavior is undefined. - //! - //! <b>Effects</b>: Returns: a valid local_iterator belonging to the unordered_set - //! that points to the value - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - local_iterator local_iterator_to(reference value) - { - siterator sit = bucket_type::s_iterator_to(this->priv_value_to_node(value)); - return local_iterator(sit, this); - } - - //! <b>Requires</b>: value must be an lvalue and shall be in a unordered_set of - //! appropriate type. Otherwise the behavior is undefined. - //! - //! <b>Effects</b>: Returns: a valid const_local_iterator belonging to - //! the unordered_set that points to the value - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_local_iterator local_iterator_to(const_reference value) const - { - siterator sit = bucket_type::s_iterator_to - (const_cast<node &>(this->priv_value_to_node(value))); - return const_local_iterator(sit, this); - } - - //! <b>Effects</b>: Returns the number of buckets passed in the constructor - //! or the last rehash function. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - size_type bucket_count() const - { return this->priv_buckets_len(); } - - //! <b>Requires</b>: n is in the range [0, this->bucket_count()). - //! - //! <b>Effects</b>: Returns the number of elements in the nth bucket. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - size_type bucket_size(size_type n) const - { return this->priv_buckets()[n].size(); } - - //! <b>Effects</b>: Returns the index of the bucket in which elements - //! with keys equivalent to k would be found, if any such element existed. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: If the hash functor throws. - //! - //! <b>Note</b>: the return value is in the range [0, this->bucket_count()). - size_type bucket(const key_type& k) const - { return this->bucket(k, this->priv_hasher()); } - - //! <b>Requires</b>: "hash_func" must be a hash function that induces - //! the same hash values as the stored hasher. The difference is that - //! "hash_func" hashes the given key instead of the value_type. - //! - //! <b>Effects</b>: Returns the index of the bucket in which elements - //! with keys equivalent to k would be found, if any such element existed. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: If hash_func throws. - //! - //! <b>Note</b>: the return value is in the range [0, this->bucket_count()). - template<class KeyType, class KeyHasher> - size_type bucket(const KeyType& k, const KeyHasher &hash_func) const - { return priv_hash_to_bucket(hash_func(k)); } - - //! <b>Effects</b>: Returns the bucket array pointer passed in the constructor - //! or the last rehash function. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - bucket_ptr bucket_pointer() const - { return this->priv_buckets(); } - - //! <b>Requires</b>: n is in the range [0, this->bucket_count()). - //! - //! <b>Effects</b>: Returns a local_iterator pointing to the beginning - //! of the sequence stored in the bucket n. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: [this->begin(n), this->end(n)) is a valid range - //! containing all of the elements in the nth bucket. - local_iterator begin(size_type n) - { return local_iterator(this->priv_buckets()[n].begin(), this); } - - //! <b>Requires</b>: n is in the range [0, this->bucket_count()). - //! - //! <b>Effects</b>: Returns a const_local_iterator pointing to the beginning - //! of the sequence stored in the bucket n. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: [this->begin(n), this->end(n)) is a valid range - //! containing all of the elements in the nth bucket. - const_local_iterator begin(size_type n) const - { return this->cbegin(n); } - - //! <b>Requires</b>: n is in the range [0, this->bucket_count()). - //! - //! <b>Effects</b>: Returns a const_local_iterator pointing to the beginning - //! of the sequence stored in the bucket n. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: [this->begin(n), this->end(n)) is a valid range - //! containing all of the elements in the nth bucket. - const_local_iterator cbegin(size_type n) const - { - siterator sit = const_cast<bucket_type&>(this->priv_buckets()[n]).begin(); - return const_local_iterator(sit, this); - } - - //! <b>Requires</b>: n is in the range [0, this->bucket_count()). - //! - //! <b>Effects</b>: Returns a local_iterator pointing to the end - //! of the sequence stored in the bucket n. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: [this->begin(n), this->end(n)) is a valid range - //! containing all of the elements in the nth bucket. - local_iterator end(size_type n) - { return local_iterator(this->priv_buckets()[n].end(), this); } - - //! <b>Requires</b>: n is in the range [0, this->bucket_count()). - //! - //! <b>Effects</b>: Returns a const_local_iterator pointing to the end - //! of the sequence stored in the bucket n. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: [this->begin(n), this->end(n)) is a valid range - //! containing all of the elements in the nth bucket. - const_local_iterator end(size_type n) const - { return this->cend(n); } - - //! <b>Requires</b>: n is in the range [0, this->bucket_count()). - //! - //! <b>Effects</b>: Returns a const_local_iterator pointing to the end - //! of the sequence stored in the bucket n. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: [this->begin(n), this->end(n)) is a valid range - //! containing all of the elements in the nth bucket. - const_local_iterator cend(size_type n) const - { return const_local_iterator(const_cast<bucket_type&>(this->priv_buckets()[n]).end(), this); } - - //! <b>Requires</b>: new_buckets must be a pointer to a new bucket array - //! or the same as the old bucket array. new_size is the length of the - //! the array pointed by new_buckets. If new_buckets == this->bucket_pointer() - //! n can be bigger or smaller than this->bucket_count(). - //! 'new_bucket_traits' copy constructor should not throw. - //! - //! <b>Effects</b>: Updates the internal reference with the new bucket erases - //! the values from the old bucket and inserts then in the new one. - //! Bucket traits hold by *this is assigned from new_bucket_traits. - //! If the container is configured as incremental<>, the split bucket is set - //! to the new bucket_len(). - //! - //! If store_hash option is true, this method does not use the hash function. - //! - //! <b>Complexity</b>: Average case linear in this->size(), worst case quadratic. - //! - //! <b>Throws</b>: If the hasher functor throws. Basic guarantee. - void rehash(const bucket_traits &new_bucket_traits) - { - bucket_ptr new_buckets = new_bucket_traits.bucket_begin(); - size_type new_buckets_len = new_bucket_traits.bucket_count(); - bucket_ptr old_buckets = this->priv_buckets(); - size_type old_buckets_len = this->priv_buckets_len(); - - //Check power of two bucket array if the option is activated - BOOST_INTRUSIVE_INVARIANT_ASSERT - (!power_2_buckets || (0 == (new_buckets_len & (new_buckets_len-1u)))); - - size_type n = priv_get_cache_bucket_num(); - const bool same_buffer = old_buckets == new_buckets; - //If the new bucket length is a common factor - //of the old one we can avoid hash calculations. - const bool fast_shrink = (!incremental) && (old_buckets_len > new_buckets_len) && - (power_2_buckets ||(old_buckets_len % new_buckets_len) == 0); - //If we are shrinking the same bucket array and it's - //is a fast shrink, just rehash the last nodes - size_type new_first_bucket_num = new_buckets_len; - if(same_buffer && fast_shrink && (n < new_buckets_len)){ - n = new_buckets_len; - new_first_bucket_num = priv_get_cache_bucket_num(); - } - - //Anti-exception stuff: they destroy the elements if something goes wrong. - //If the source and destination buckets are the same, the second rollback function - //is harmless, because all elements have been already unlinked and destroyed - typedef detail::init_disposer<node_algorithms> NodeDisposer; - NodeDisposer node_disp; - bucket_type & newbuck = new_buckets[0]; - bucket_type & oldbuck = old_buckets[0]; - detail::exception_array_disposer<bucket_type, NodeDisposer, size_type> - rollback1(newbuck, node_disp, new_buckets_len); - detail::exception_array_disposer<bucket_type, NodeDisposer, size_type> - rollback2(oldbuck, node_disp, old_buckets_len); - - //Put size in a safe value for rollback exception - size_type size_backup = this->priv_size_traits().get_size(); - this->priv_size_traits().set_size(0); - //Put cache to safe position - priv_initialize_cache(); - priv_insertion_update_cache(size_type(0u)); - - //Iterate through nodes - for(; n < old_buckets_len; ++n){ - bucket_type &old_bucket = old_buckets[n]; - - if(!fast_shrink){ - siterator before_i(old_bucket.before_begin()); - siterator end(old_bucket.end()); - siterator i(old_bucket.begin()); - for(;i != end; ++i){ - const value_type &v = priv_value_from_slist_node(i.pointed_node()); - const std::size_t hash_value = this->priv_stored_or_compute_hash(v, store_hash_t()); - const size_type new_n = priv_hash_to_bucket(hash_value, new_buckets_len, new_buckets_len); - if(cache_begin && new_n < new_first_bucket_num) - new_first_bucket_num = new_n; - siterator last = bucket_type::s_iterator_to - (*group_functions_t::get_last_in_group - (dcast_bucket_ptr(i.pointed_node()), optimize_multikey_t())); - if(same_buffer && new_n == n){ - before_i = last; - } - else{ - bucket_type &new_b = new_buckets[new_n]; - new_b.splice_after(new_b.before_begin(), old_bucket, before_i, last); - } - i = before_i; - } - } - else{ - const size_type new_n = priv_hash_to_bucket(n, new_buckets_len, new_buckets_len); - if(cache_begin && new_n < new_first_bucket_num) - new_first_bucket_num = new_n; - bucket_type &new_b = new_buckets[new_n]; - if(!old_bucket.empty()){ - new_b.splice_after( new_b.before_begin() - , old_bucket - , old_bucket.before_begin() - , priv_get_last(old_bucket)); - } - } - } - - this->priv_size_traits().set_size(size_backup); - this->priv_split_traits().set_size(new_buckets_len); - this->priv_real_bucket_traits() = new_bucket_traits; - priv_initialize_cache(); - priv_insertion_update_cache(new_first_bucket_num); - rollback1.release(); - rollback2.release(); - } - - //! <b>Requires</b>: - //! - //! <b>Effects</b>: - //! - //! <b>Complexity</b>: - //! - //! <b>Throws</b>: - //! - //! <b>Note</b>: this method is only available if incremental<true> option is activated. - bool incremental_rehash(bool grow = true) - { - //This function is only available for containers with incremental hashing - BOOST_STATIC_ASSERT(( incremental && power_2_buckets )); - size_type split_idx = priv_split_traits().get_size(); - size_type bucket_len = priv_buckets_len(); - - if(grow){ - //Test if the split variable can be changed - if(split_idx >= bucket_len) - return false; - - size_type bucket_len = priv_buckets_len(); - size_type bucket_to_rehash = split_idx - bucket_len/2; - bucket_type &old_bucket = this->priv_buckets()[bucket_to_rehash]; - siterator before_i(old_bucket.before_begin()); - siterator end(old_bucket.end()); - siterator i(old_bucket.begin()); - priv_split_traits().increment(); - - //Anti-exception stuff: if an exception is thrown while - //moving elements from old_bucket to the target bucket, all moved - //elements are moved back to the original one. - detail::incremental_rehash_rollback<bucket_type, split_traits> rollback - ( this->priv_buckets()[split_idx], old_bucket, priv_split_traits()); - for(;i != end; ++i){ - const value_type &v = priv_value_from_slist_node(i.pointed_node()); - const std::size_t hash_value = this->priv_stored_or_compute_hash(v, store_hash_t()); - const size_type new_n = priv_hash_to_bucket(hash_value); - siterator last = bucket_type::s_iterator_to - (*group_functions_t::get_last_in_group - (dcast_bucket_ptr(i.pointed_node()), optimize_multikey_t())); - if(new_n == bucket_to_rehash){ - before_i = last; - } - else{ - bucket_type &new_b = this->priv_buckets()[new_n]; - new_b.splice_after(new_b.before_begin(), old_bucket, before_i, last); - } - i = before_i; - } - rollback.release(); - priv_erasure_update_cache(); - return true; - } - else{ - //Test if the split variable can be changed - if(split_idx <= bucket_len/2) - return false; - const size_type target_bucket_num = split_idx - 1 - bucket_len/2; - bucket_type &target_bucket = this->priv_buckets()[target_bucket_num]; - bucket_type &source_bucket = this->priv_buckets()[split_idx-1]; - target_bucket.splice_after(target_bucket.cbefore_begin(), source_bucket); - priv_split_traits().decrement(); - priv_insertion_update_cache(target_bucket_num); - return true; - } - } - - //! <b>Effects</b>: If new_bucket_traits.bucket_count() is not - //! this->bucket_count()/2 or this->bucket_count()*2, or - //! this->split_bucket() != new_bucket_traits.bucket_count() returns false - //! and does nothing. - //! - //! Otherwise, copy assigns new_bucket_traits to the internal bucket_traits - //! and transfers all the objects from old buckets to the new ones. - //! - //! <b>Complexity</b>: Linear to size(). - //! - //! <b>Throws</b>: Nothing - //! - //! <b>Note</b>: this method is only available if incremental<true> option is activated. - bool incremental_rehash(const bucket_traits &new_bucket_traits) - { - //This function is only available for containers with incremental hashing - BOOST_STATIC_ASSERT(( incremental && power_2_buckets )); - size_type new_bucket_traits_size = new_bucket_traits.bucket_count(); - size_type cur_bucket_traits = this->priv_buckets_len(); - if(new_bucket_traits_size/2 != cur_bucket_traits && new_bucket_traits_size != cur_bucket_traits/2){ - return false; - } - - const size_type split_idx = this->split_count(); - - if(new_bucket_traits_size/2 == cur_bucket_traits){ - //Test if the split variable can be changed - if(!(split_idx >= cur_bucket_traits)) - return false; - } - else{ - //Test if the split variable can be changed - if(!(split_idx <= cur_bucket_traits/2)) - return false; - } - - const size_type ini_n = priv_get_cache_bucket_num(); - const bucket_ptr old_buckets = this->priv_buckets(); - this->priv_real_bucket_traits() = new_bucket_traits; - if(new_bucket_traits.bucket_begin() != old_buckets){ - for(size_type n = ini_n; n < split_idx; ++n){ - bucket_type &new_bucket = new_bucket_traits.bucket_begin()[n]; - bucket_type &old_bucket = old_buckets[n]; - new_bucket.splice_after(new_bucket.cbefore_begin(), old_bucket); - } - //Put cache to safe position - priv_initialize_cache(); - priv_insertion_update_cache(ini_n); - } - return true; - } - - //! <b>Requires</b>: - //! - //! <b>Effects</b>: - //! - //! <b>Complexity</b>: - //! - //! <b>Throws</b>: - size_type split_count() const - { - //This function is only available if incremental hashing is activated - BOOST_STATIC_ASSERT(( incremental && power_2_buckets )); - return this->priv_split_traits().get_size(); - } - - //! <b>Effects</b>: Returns the nearest new bucket count optimized for - //! the container that is bigger or equal than n. This suggestion can be - //! used to create bucket arrays with a size that will usually improve - //! container's performance. If such value does not exist, the - //! higher possible value is returned. - //! - //! <b>Complexity</b>: Amortized constant time. - //! - //! <b>Throws</b>: Nothing. - static size_type suggested_upper_bucket_count(size_type n) - { - const std::size_t *primes = &detail::prime_list_holder<0>::prime_list[0]; - const std::size_t *primes_end = primes + detail::prime_list_holder<0>::prime_list_size; - std::size_t const* bound = std::lower_bound(primes, primes_end, n); - if(bound == primes_end) - --bound; - return size_type(*bound); - } - - //! <b>Effects</b>: Returns the nearest new bucket count optimized for - //! the container that is smaller or equal than n. This suggestion can be - //! used to create bucket arrays with a size that will usually improve - //! container's performance. If such value does not exist, the - //! lowest possible value is returned. - //! - //! <b>Complexity</b>: Amortized constant time. - //! - //! <b>Throws</b>: Nothing. - static size_type suggested_lower_bucket_count(size_type n) - { - const std::size_t *primes = &detail::prime_list_holder<0>::prime_list[0]; - const std::size_t *primes_end = primes + detail::prime_list_holder<0>::prime_list_size; - size_type const* bound = std::upper_bound(primes, primes_end, n); - if(bound != primes) - --bound; - return size_type(*bound); - } - - /// @cond - private: - - std::size_t priv_hash_to_bucket(std::size_t hash_value) const - { return priv_hash_to_bucket(hash_value, this->priv_real_bucket_traits().bucket_count(), priv_split_traits().get_size()); } - - std::size_t priv_hash_to_bucket(std::size_t hash_value, std::size_t bucket_len, std::size_t split) const - { - std::size_t bucket_number = priv_hash_to_bucket_impl(hash_value, bucket_len, power_2_buckets_t()); - if(incremental) - if(bucket_number >= split) - bucket_number -= bucket_len/2; - return bucket_number; - } - - std::size_t priv_hash_to_bucket_impl(std::size_t hash_value, std::size_t bucket_len, detail::false_) const - { return hash_value % bucket_len; } - - std::size_t priv_hash_to_bucket_impl(std::size_t hash_value, std::size_t bucket_len, detail::true_) const - { return hash_value & (bucket_len - 1); } - - const key_equal &priv_equal() const - { return static_cast<const key_equal&>(this->data_.internal_.bucket_hash_equal_.get()); } - - key_equal &priv_equal() - { return static_cast<key_equal&>(this->data_.internal_.bucket_hash_equal_.get()); } - - const value_traits &priv_value_traits() const - { return data_; } - - value_traits &priv_value_traits() - { return data_; } - - value_type &priv_value_from_slist_node(slist_node_ptr n) - { return *this->get_real_value_traits().to_value_ptr(dcast_bucket_ptr(n)); } - - const value_type &priv_value_from_slist_node(slist_node_ptr n) const - { return *this->get_real_value_traits().to_value_ptr(dcast_bucket_ptr(n)); } - - const real_bucket_traits &priv_real_bucket_traits(detail::false_) const - { return this->data_.internal_.bucket_hash_equal_.bucket_hash.bucket_plus_size_.bucket_traits_; } - - const real_bucket_traits &priv_real_bucket_traits(detail::true_) const - { return this->data_.internal_.bucket_hash_equal_.bucket_hash.bucket_plus_size_.bucket_traits_.get_bucket_traits(*this); } - - real_bucket_traits &priv_real_bucket_traits(detail::false_) - { return this->data_.internal_.bucket_hash_equal_.bucket_hash.bucket_plus_size_.bucket_traits_; } - - real_bucket_traits &priv_real_bucket_traits(detail::true_) - { return this->data_.internal_.bucket_hash_equal_.bucket_hash.bucket_plus_size_.bucket_traits_.get_bucket_traits(*this); } - - const real_bucket_traits &priv_real_bucket_traits() const - { return this->priv_real_bucket_traits(detail::bool_<external_bucket_traits>()); } - - real_bucket_traits &priv_real_bucket_traits() - { return this->priv_real_bucket_traits(detail::bool_<external_bucket_traits>()); } - - const bucket_traits &priv_bucket_traits() const - { return this->data_.internal_.bucket_hash_equal_.bucket_hash.bucket_plus_size_.bucket_traits_; } - - bucket_traits &priv_bucket_traits() - { return this->data_.internal_.bucket_hash_equal_.bucket_hash.bucket_plus_size_.bucket_traits_; } - - const hasher &priv_hasher() const - { return static_cast<const hasher&>(this->data_.internal_.bucket_hash_equal_.bucket_hash.get()); } - - hasher &priv_hasher() - { return static_cast<hasher&>(this->data_.internal_.bucket_hash_equal_.bucket_hash.get()); } - - bucket_ptr priv_buckets() const - { return this->priv_real_bucket_traits().bucket_begin(); } - - size_type priv_buckets_len() const - { return this->priv_real_bucket_traits().bucket_count(); } - - static node_ptr uncast(const const_node_ptr & ptr) - { return node_ptr(const_cast<node*>(boost::intrusive::detail::to_raw_pointer(ptr))); } - - node &priv_value_to_node(value_type &v) - { return *this->get_real_value_traits().to_node_ptr(v); } - - const node &priv_value_to_node(const value_type &v) const - { return *this->get_real_value_traits().to_node_ptr(v); } - - size_traits &priv_size_traits() - { return this->data_.internal_.bucket_hash_equal_.bucket_hash.bucket_plus_size_; } - - const size_traits &priv_size_traits() const - { return this->data_.internal_.bucket_hash_equal_.bucket_hash.bucket_plus_size_; } - - split_traits &priv_split_traits() - { return this->data_.internal_; } - - const split_traits &priv_split_traits() const - { return this->data_.internal_; } - - template<class Disposer> - void priv_erase_range_impl - (size_type bucket_num, siterator before_first_it, siterator end, Disposer disposer, size_type &num_erased) - { - const bucket_ptr buckets = priv_buckets(); - bucket_type &b = buckets[bucket_num]; - - if(before_first_it == b.before_begin() && end == b.end()){ - priv_erase_range_impl(bucket_num, 1, disposer, num_erased); - } - else{ - num_erased = 0; - siterator to_erase(before_first_it); - ++to_erase; - slist_node_ptr end_ptr = end.pointed_node(); - while(to_erase != end){ - group_functions_t::erase_from_group(end_ptr, dcast_bucket_ptr(to_erase.pointed_node()), optimize_multikey_t()); - to_erase = b.erase_after_and_dispose(before_first_it, make_node_disposer(disposer)); - ++num_erased; - } - this->priv_size_traits().set_size(this->priv_size_traits().get_size()-num_erased); - } - } - - template<class Disposer> - void priv_erase_range_impl - (size_type first_bucket_num, size_type num_buckets, Disposer disposer, size_type &num_erased) - { - //Now fully clear the intermediate buckets - const bucket_ptr buckets = priv_buckets(); - num_erased = 0; - for(size_type i = first_bucket_num; i < (num_buckets + first_bucket_num); ++i){ - bucket_type &b = buckets[i]; - siterator b_begin(b.before_begin()); - siterator nxt(b_begin); - ++nxt; - siterator end(b.end()); - while(nxt != end){ - group_functions_t::init_group(dcast_bucket_ptr(nxt.pointed_node()), optimize_multikey_t()); - nxt = b.erase_after_and_dispose - (b_begin, make_node_disposer(disposer)); - this->priv_size_traits().decrement(); - ++num_erased; - } - } - } - - template<class Disposer> - void priv_erase_range( siterator before_first_it, size_type first_bucket - , siterator last_it, size_type last_bucket - , Disposer disposer) - { - size_type num_erased; - if (first_bucket == last_bucket){ - priv_erase_range_impl(first_bucket, before_first_it, last_it, disposer, num_erased); - } - else { - bucket_type *b = (&this->priv_buckets()[0]); - priv_erase_range_impl(first_bucket, before_first_it, b[first_bucket].end(), disposer, num_erased); - if(size_type n = (last_bucket - first_bucket - 1)) - priv_erase_range_impl(first_bucket + 1, n, disposer, num_erased); - priv_erase_range_impl(last_bucket, b[last_bucket].before_begin(), last_it, disposer, num_erased); - } - } - - static node_ptr dcast_bucket_ptr(typename slist_impl::node_ptr p) - { return pointer_traits<node_ptr>::pointer_to(static_cast<node&>(*p)); } - - std::size_t priv_stored_or_compute_hash(const value_type &v, detail::true_) const - { return node_traits::get_hash(this->get_real_value_traits().to_node_ptr(v)); } - - std::size_t priv_stored_or_compute_hash(const value_type &v, detail::false_) const - { return priv_hasher()(v); } - - std::size_t priv_stored_hash(slist_node_ptr n, detail::true_) const - { return node_traits::get_hash(dcast_bucket_ptr(n)); } - - std::size_t priv_stored_hash(slist_node_ptr, detail::false_) const - { - //This code should never be reached! - BOOST_INTRUSIVE_INVARIANT_ASSERT(0); - return 0; - } - - static void priv_clear_group_nodes(bucket_type &b, detail::true_) - { - siterator it(b.begin()), itend(b.end()); - while(it != itend){ - node_ptr to_erase(dcast_bucket_ptr(it.pointed_node())); - ++it; - group_algorithms::init(to_erase); - } - } - - static void priv_clear_group_nodes(bucket_type &, detail::false_) - {} - - std::size_t priv_get_bucket_num(siterator it) - { return priv_get_bucket_num_hash_dispatch(it, store_hash_t()); } - - std::size_t priv_get_bucket_num_hash_dispatch(siterator it, detail::true_) - { - return this->priv_hash_to_bucket - (this->priv_stored_hash(it.pointed_node(), store_hash_t())); - } - - std::size_t priv_get_bucket_num_hash_dispatch(siterator it, detail::false_) - { return priv_get_bucket_num_no_hash_store(it, optimize_multikey_t()); } - - std::size_t priv_get_bucket_num_no_hash_store(siterator it, detail::true_) - { - bucket_ptr f(priv_buckets()), l(f + priv_buckets_len() - 1); - slist_node_ptr bb = group_functions_t::get_bucket_before_begin - ( f->end().pointed_node() - , l->end().pointed_node() - , dcast_bucket_ptr(it.pointed_node())); - //Now get the bucket_impl from the iterator - const bucket_type &b = static_cast<const bucket_type&> - (bucket_type::slist_type::container_from_end_iterator(bucket_type::s_iterator_to(*bb))); - //Now just calculate the index b has in the bucket array - return static_cast<size_type>(&b - &*f); - } - - std::size_t priv_get_bucket_num_no_hash_store(siterator it, detail::false_) - { - bucket_ptr f(priv_buckets()), l(f + priv_buckets_len() - 1); - slist_node_ptr first_ptr(f->cend().pointed_node()) - , last_ptr(l->cend().pointed_node()); - - //The end node is embedded in the singly linked list: - //iterate until we reach it. - while(!(first_ptr <= it.pointed_node() && it.pointed_node() <= last_ptr)){ - ++it; - } - //Now get the bucket_impl from the iterator - const bucket_type &b = static_cast<const bucket_type&> - (bucket_type::container_from_end_iterator(it)); - - //Now just calculate the index b has in the bucket array - return static_cast<std::size_t>(&b - &*f); - } - - siterator priv_get_previous - (bucket_type &b, siterator i) - { return priv_get_previous(b, i, optimize_multikey_t()); } - - siterator priv_get_previous - (bucket_type &b, siterator i, detail::true_) - { - node_ptr elem(dcast_bucket_ptr(i.pointed_node())); - node_ptr prev_in_group(group_traits::get_next(elem)); - bool first_in_group = node_traits::get_next(prev_in_group) != elem; - typename bucket_type::node &n = first_in_group - ? *group_functions_t::get_prev_to_first_in_group(b.end().pointed_node(), elem) - : *group_traits::get_next(elem) - ; - return bucket_type::s_iterator_to(n); - } - - siterator priv_get_previous - (bucket_type &b, siterator i, detail::false_) - { return b.previous(i); } - - static siterator priv_get_last(bucket_type &b) - { return priv_get_last(b, optimize_multikey_t()); } - - static siterator priv_get_last(bucket_type &b, detail::true_) - { - //First find the last node of p's group. - //This requires checking the first node of the next group or - //the bucket node. - slist_node_ptr end_ptr(b.end().pointed_node()); - node_ptr possible_end(node_traits::get_next( dcast_bucket_ptr(end_ptr))); - node_ptr last_node_group(possible_end); - - while(end_ptr != possible_end){ - last_node_group = group_traits::get_next(dcast_bucket_ptr(possible_end)); - possible_end = node_traits::get_next(last_node_group); - } - return bucket_type::s_iterator_to(*last_node_group); - } - - static siterator priv_get_last(bucket_type &b, detail::false_) - { return b.previous(b.end()); } -/* - siterator priv_get_previous_and_next_in_group - (siterator i, node_ptr &nxt_in_group) - { - siterator prev; - node_ptr elem(dcast_bucket_ptr(i.pointed_node())); - bucket_ptr f(priv_buckets()), l(f + priv_buckets_len() - 1); - - slist_node_ptr first_end_ptr(f->cend().pointed_node()); - slist_node_ptr last_end_ptr (l->cend().pointed_node()); - - node_ptr nxt(node_traits::get_next(elem)); - node_ptr prev_in_group(group_traits::get_next(elem)); - bool last_in_group = (first_end_ptr <= nxt && nxt <= last_end_ptr) || - (group_traits::get_next(nxt) != elem); - bool first_in_group = node_traits::get_next(prev_in_group) != elem; - - if(first_in_group){ - node_ptr start_pos; - if(last_in_group){ - start_pos = elem; - nxt_in_group = node_ptr(); - } - else{ - start_pos = prev_in_group; - nxt_in_group = node_traits::get_next(elem); - } - slist_node_ptr bucket_node; - if(store_hash){ - bucket_node = this->priv_buckets() - [this->priv_hash_to_bucket - (this->priv_stored_hash(elem, store_hash_t())) - ].before_begin().pointed_node(); - } - else{ - bucket_node = group_functions_t::get_bucket_before_begin - (first_end_ptr, last_end_ptr, start_pos); - } - prev = bucket_type::s_iterator_to - (*group_functions_t::get_prev_to_first_in_group(bucket_node, elem)); - } - else{ - if(last_in_group){ - nxt_in_group = group_functions_t::get_first_in_group_of_last_in_group(elem); - } - else{ - nxt_in_group = node_traits::get_next(elem); - } - prev = bucket_type::s_iterator_to(*group_traits::get_next(elem)); - } - return prev; - } -*/ - -/* - template<class Disposer> - void priv_erase(const_iterator i, Disposer disposer, detail::true_) - { - siterator elem(i.slist_it()); - node_ptr nxt_in_group; - siterator prev = priv_get_previous_and_next_in_group(elem, nxt_in_group); - bucket_type::s_erase_after_and_dispose(prev, make_node_disposer(disposer)); - if(nxt_in_group) - group_algorithms::unlink_after(nxt_in_group); - if(safemode_or_autounlink) - group_algorithms::init(dcast_bucket_ptr(elem.pointed_node())); - } -*/ - -/* - if(store_hash){ - bucket_node = this->priv_buckets() - [this->priv_hash_to_bucket - (this->priv_stored_hash(elem, store_hash_t())) - ].before_begin().pointed_node(); - } - else{ - bucket_node = group_functions_t::get_bucket_before_begin - (first_end_ptr, last_end_ptr, start_pos); - } -*/ - template<class Disposer> - void priv_erase(const_iterator i, Disposer disposer, detail::true_) - { - slist_node_ptr elem(i.slist_it().pointed_node()); - slist_node_ptr f_bucket_end, l_bucket_end; - if(store_hash){ - f_bucket_end = l_bucket_end = - (this->priv_buckets() - [this->priv_hash_to_bucket - (this->priv_stored_hash(elem, store_hash_t())) - ]).before_begin().pointed_node(); - } - else{ - f_bucket_end = this->priv_buckets()->cend().pointed_node(); - l_bucket_end = f_bucket_end + priv_buckets_len() - 1; - } - node_ptr nxt_in_group; - siterator prev = bucket_type::s_iterator_to - (*group_functions_t::get_previous_and_next_in_group - ( elem, nxt_in_group, f_bucket_end, l_bucket_end) - ); - bucket_type::s_erase_after_and_dispose(prev, make_node_disposer(disposer)); - if(nxt_in_group) - group_algorithms::unlink_after(nxt_in_group); - if(safemode_or_autounlink) - group_algorithms::init(dcast_bucket_ptr(elem)); - } - - template <class Disposer> - void priv_erase(const_iterator i, Disposer disposer, detail::false_) - { - siterator to_erase(i.slist_it()); - bucket_type &b = this->priv_buckets()[this->priv_get_bucket_num(to_erase)]; - siterator prev(priv_get_previous(b, to_erase)); - b.erase_after_and_dispose(prev, make_node_disposer(disposer)); - } - - bucket_ptr priv_invalid_bucket() const - { - const real_bucket_traits &rbt = this->priv_real_bucket_traits(); - return rbt.bucket_begin() + rbt.bucket_count(); - } - - siterator priv_invalid_local_it() const - { return priv_invalid_bucket()->end(); } - - siterator priv_begin() const - { return priv_begin(cache_begin_t()); } - - siterator priv_begin(detail::false_) const - { - size_type n = 0; - size_type buckets_len = this->priv_buckets_len(); - for (n = 0; n < buckets_len; ++n){ - bucket_type &b = this->priv_buckets()[n]; - if(!b.empty()){ - return b.begin(); - } - } - return priv_invalid_local_it(); - } - - siterator priv_begin(detail::true_) const - { - if(this->data_.internal_.bucket_hash_equal_.cached_begin_ == priv_invalid_bucket()){ - return priv_invalid_local_it(); - } - else{ - return this->data_.internal_.bucket_hash_equal_.cached_begin_->begin(); - } - } - - void priv_initialize_cache() - { priv_initialize_cache(cache_begin_t()); } - - void priv_initialize_cache(detail::true_) - { this->data_.internal_.bucket_hash_equal_.cached_begin_ = priv_invalid_bucket(); } - - void priv_initialize_cache(detail::false_) - {} - - void priv_insertion_update_cache(size_type insertion_bucket) - { priv_insertion_update_cache(insertion_bucket, cache_begin_t()); } - - void priv_insertion_update_cache(size_type insertion_bucket, detail::true_) - { - bucket_ptr p = priv_buckets() + insertion_bucket; - if(p < this->data_.internal_.bucket_hash_equal_.cached_begin_){ - this->data_.internal_.bucket_hash_equal_.cached_begin_ = p; - } - } - - void priv_insertion_update_cache(size_type, detail::false_) - {} - - void priv_erasure_update_cache(size_type first_bucket, size_type last_bucket) - { priv_erasure_update_cache(first_bucket, last_bucket, cache_begin_t()); } - - void priv_erasure_update_cache(size_type first_bucket_num, size_type last_bucket_num, detail::true_) - { - //If the last bucket is the end, the cache must be updated - //to the last position if all - if(priv_get_cache_bucket_num() == first_bucket_num && - priv_buckets()[first_bucket_num].empty() ){ - priv_set_cache(priv_buckets() + last_bucket_num); - priv_erasure_update_cache(); - } - } - - void priv_erasure_update_cache(size_type, size_type, detail::false_) - {} - - void priv_erasure_update_cache() - { priv_erasure_update_cache(cache_begin_t()); } - - void priv_erasure_update_cache(detail::true_) - { - if(constant_time_size && !size()){ - priv_initialize_cache(); - } - else{ - size_type current_n = this->data_.internal_.bucket_hash_equal_.cached_begin_ - priv_buckets(); - for( const size_type num_buckets = this->priv_buckets_len() - ; current_n < num_buckets - ; ++current_n, ++this->data_.internal_.bucket_hash_equal_.cached_begin_){ - if(!this->data_.internal_.bucket_hash_equal_.cached_begin_->empty()){ - return; - } - } - priv_initialize_cache(); - } - } - - void priv_erasure_update_cache(detail::false_) - {} - - void priv_swap_cache(detail::true_, hashtable_impl &other) - { - std::swap( this->data_.internal_.bucket_hash_equal_.cached_begin_ - , other.data_.internal_.bucket_hash_equal_.cached_begin_); - } - - void priv_swap_cache(detail::false_, hashtable_impl &) - {} - - bucket_ptr priv_get_cache() - { return priv_get_cache(cache_begin_t()); } - - bucket_ptr priv_get_cache(detail::true_) - { return this->data_.internal_.bucket_hash_equal_.cached_begin_; } - - bucket_ptr priv_get_cache(detail::false_) - { return this->priv_buckets(); } - - void priv_set_cache(const bucket_ptr &p) - { this->data_.internal_.bucket_hash_equal_.set_cache(p); } - - size_type priv_get_cache_bucket_num() - { return priv_get_cache_bucket_num(cache_begin_t()); } - - size_type priv_get_cache_bucket_num(detail::true_) - { return this->data_.internal_.bucket_hash_equal_.cached_begin_ - this->priv_buckets(); } - - size_type priv_get_cache_bucket_num(detail::false_) - { return 0u; } - - void priv_clear_buckets() - { - this->priv_clear_buckets - ( priv_get_cache() - , this->priv_buckets_len() - (priv_get_cache() - priv_buckets())); - } - - void priv_initialize_buckets() - { this->priv_clear_buckets(priv_buckets(), this->priv_buckets_len()); } - - void priv_clear_buckets(bucket_ptr buckets_ptr, size_type buckets_len) - { - for(; buckets_len--; ++buckets_ptr){ - if(safemode_or_autounlink){ - priv_clear_group_nodes(*buckets_ptr, optimize_multikey_t()); - buckets_ptr->clear_and_dispose(detail::init_disposer<node_algorithms>()); - } - else{ - buckets_ptr->clear(); - } - } - priv_initialize_cache(); - } - - template<class KeyType, class KeyHasher, class KeyValueEqual> - siterator priv_find - ( const KeyType &key, KeyHasher hash_func - , KeyValueEqual equal_func, size_type &bucket_number, std::size_t &h, siterator &previt) const - { - h = hash_func(key); - return priv_find_with_hash(key, equal_func, bucket_number, h, previt); - } - - template<class KeyType, class KeyValueEqual> - siterator priv_find_with_hash - ( const KeyType &key, KeyValueEqual equal_func, size_type &bucket_number, const std::size_t h, siterator &previt) const - { - bucket_number = priv_hash_to_bucket(h); - bucket_type &b = this->priv_buckets()[bucket_number]; - previt = b.before_begin(); - if(constant_time_size && this->empty()){ - return priv_invalid_local_it(); - } - - siterator it = previt; - ++it; - - while(it != b.end()){ - const value_type &v = priv_value_from_slist_node(it.pointed_node()); - if(compare_hash){ - std::size_t vh = this->priv_stored_or_compute_hash(v, store_hash_t()); - if(h == vh && equal_func(key, v)){ - return it; - } - } - else if(equal_func(key, v)){ - return it; - } - if(optimize_multikey){ - previt = bucket_type::s_iterator_to - (*group_functions_t::get_last_in_group - (dcast_bucket_ptr(it.pointed_node()), optimize_multikey_t())); - it = previt; - } - else{ - previt = it; - } - ++it; - } - previt = b.before_begin(); - return priv_invalid_local_it(); - } - - iterator priv_insert_equal_with_hash(reference value, std::size_t hash_value) - { - size_type bucket_num; - siterator prev; - siterator it = this->priv_find_with_hash - (value, this->priv_equal(), bucket_num, hash_value, prev); - return priv_insert_equal_find(value, bucket_num, hash_value, it); - } - - iterator priv_insert_equal_find(reference value, size_type bucket_num, std::size_t hash_value, siterator it) - { - bucket_type &b = this->priv_buckets()[bucket_num]; - bool found_equal = it != priv_invalid_local_it(); - if(!found_equal){ - it = b.before_begin(); - } - //Now store hash if needed - node_ptr n = pointer_traits<node_ptr>::pointer_to(priv_value_to_node(value)); - node_functions_t::store_hash(n, hash_value, store_hash_t()); - //Checks for some modes - if(safemode_or_autounlink) - BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(n)); - //Shorcut for optimize_multikey cases - if(optimize_multikey){ - node_ptr first_in_group = found_equal ? - dcast_bucket_ptr(it.pointed_node()) : node_ptr(); - group_functions_t::insert_in_group(first_in_group, n, optimize_multikey_t()); - } - //Update cache and increment size if needed - priv_insertion_update_cache(bucket_num); - this->priv_size_traits().increment(); - //Insert the element in the bucket after it - return iterator(b.insert_after(it, *n), this); - } - - template<class KeyType, class KeyHasher, class KeyValueEqual> - std::pair<siterator, siterator> priv_equal_range - ( const KeyType &key - , KeyHasher hash_func - , KeyValueEqual equal_func - , size_type &bucket_number_first - , size_type &bucket_number_second - , size_type &count) const - { - std::size_t h; - count = 0; - siterator prev; - //Let's see if the element is present - std::pair<siterator, siterator> to_return - ( priv_find(key, hash_func, equal_func, bucket_number_first, h, prev) - , priv_invalid_local_it()); - if(to_return.first == to_return.second){ - bucket_number_second = bucket_number_first; - return to_return; - } - //If it's present, find the first that it's not equal in - //the same bucket - bucket_type &b = this->priv_buckets()[bucket_number_first]; - siterator it = to_return.first; - if(optimize_multikey){ - to_return.second = bucket_type::s_iterator_to - (*node_traits::get_next(group_functions_t::get_last_in_group - (dcast_bucket_ptr(it.pointed_node()), optimize_multikey_t()))); - count = std::distance(it, to_return.second); - if(to_return.second != b.end()){ - bucket_number_second = bucket_number_first; - return to_return; - } - } - else{ - ++count; - ++it; - while(it != b.end()){ - const value_type &v = priv_value_from_slist_node(it.pointed_node()); - if(compare_hash){ - std::size_t hv = this->priv_stored_or_compute_hash(v, store_hash_t()); - if(hv != h || !equal_func(key, v)){ - to_return.second = it; - bucket_number_second = bucket_number_first; - return to_return; - } - } - else if(!equal_func(key, v)){ - to_return.second = it; - bucket_number_second = bucket_number_first; - return to_return; - } - ++it; - ++count; - } - } - - //If we reached the end, find the first, non-empty bucket - for(bucket_number_second = bucket_number_first+1 - ; bucket_number_second != this->priv_buckets_len() - ; ++bucket_number_second){ - bucket_type &b = this->priv_buckets()[bucket_number_second]; - if(!b.empty()){ - to_return.second = b.begin(); - return to_return; - } - } - - //Otherwise, return the end node - to_return.second = priv_invalid_local_it(); - return to_return; - } - /// @endcond -}; - -/// @cond -#if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template < class T - , bool UniqueKeys - , class O1 = none, class O2 = none - , class O3 = none, class O4 = none - , class O5 = none, class O6 = none - , class O7 = none, class O8 = none - , class O9 = none, class O10= none - > -#else -template <class T, bool UniqueKeys, class ...Options> -#endif -struct make_hashtable_opt -{ - typedef typename pack_options - < uset_defaults<T>, - #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) - O1, O2, O3, O4, O5, O6, O7, O8, O9, O10 - #else - Options... - #endif - >::type packed_options; - - //Real value traits must be calculated from options - typedef typename detail::get_value_traits - <T, typename packed_options::value_traits>::type value_traits; - static const bool external_value_traits = - detail::external_value_traits_is_true<value_traits>::value; - typedef typename detail::eval_if_c - < external_value_traits - , detail::eval_value_traits<value_traits> - , detail::identity<value_traits> - >::type real_value_traits; - typedef typename packed_options::bucket_traits specified_bucket_traits; - - //Real bucket traits must be calculated from options and calculated value_traits - typedef typename detail::get_slist_impl - <typename detail::reduced_slist_node_traits - <typename real_value_traits::node_traits>::type - >::type slist_impl; - - typedef typename - detail::if_c< detail::is_same - < specified_bucket_traits - , default_bucket_traits - >::value - , detail::bucket_traits_impl<slist_impl> - , specified_bucket_traits - >::type real_bucket_traits; - - typedef detail::usetopt - < value_traits - , typename packed_options::hash - , typename packed_options::equal - , typename packed_options::size_type - , real_bucket_traits - , (std::size_t(UniqueKeys)*detail::hash_bool_flags::unique_keys_pos) - | (std::size_t(packed_options::constant_time_size)*detail::hash_bool_flags::constant_time_size_pos) - | (std::size_t(packed_options::power_2_buckets)*detail::hash_bool_flags::power_2_buckets_pos) - | (std::size_t(packed_options::cache_begin)*detail::hash_bool_flags::cache_begin_pos) - | (std::size_t(packed_options::compare_hash)*detail::hash_bool_flags::compare_hash_pos) - | (std::size_t(packed_options::incremental)*detail::hash_bool_flags::incremental_pos) - > type; -}; -/// @endcond - -//! Helper metafunction to define a \c hashtable that yields to the same type when the -//! same options (either explicitly or implicitly) are used. -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) || defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template<class T, class ...Options> -#else -template<class T, class O1 = none, class O2 = none - , class O3 = none, class O4 = none - , class O5 = none, class O6 = none - , class O7 = none, class O8 = none - , class O9 = none, class O10= none - > -#endif -struct make_hashtable -{ - /// @cond - typedef hashtable_impl - < typename make_hashtable_opt - <T, false, - #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) - O1, O2, O3, O4, O5, O6, O7, O8, O9, O10 - #else - Options... - #endif - >::type - > implementation_defined; - - /// @endcond - typedef implementation_defined type; -}; - -#if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) - -#if defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template<class T, class ...Options> -#else -template<class T, class O1, class O2, class O3, class O4, class O5, class O6, class O7, class O8, class O9, class O10> -#endif -class hashtable - : public make_hashtable<T, - #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) - O1, O2, O3, O4, O5, O6, O7, O8, O9, O10 - #else - Options... - #endif - >::type -{ - typedef typename make_hashtable<T, - #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) - O1, O2, O3, O4, O5, O6, O7, O8, O9, O10 - #else - Options... - #endif - >::type Base; - BOOST_MOVABLE_BUT_NOT_COPYABLE(hashtable) - - public: - typedef typename Base::value_traits value_traits; - typedef typename Base::real_value_traits real_value_traits; - typedef typename Base::iterator iterator; - typedef typename Base::const_iterator const_iterator; - typedef typename Base::bucket_ptr bucket_ptr; - typedef typename Base::size_type size_type; - typedef typename Base::hasher hasher; - typedef typename Base::bucket_traits bucket_traits; - typedef typename Base::key_equal key_equal; - - //Assert if passed value traits are compatible with the type - BOOST_STATIC_ASSERT((detail::is_same<typename real_value_traits::value_type, T>::value)); - - hashtable ( const bucket_traits &b_traits - , const hasher & hash_func = hasher() - , const key_equal &equal_func = key_equal() - , const value_traits &v_traits = value_traits()) - : Base(b_traits, hash_func, equal_func, v_traits) - {} - - hashtable(BOOST_RV_REF(hashtable) x) - : Base(::boost::move(static_cast<Base&>(x))) - {} - - hashtable& operator=(BOOST_RV_REF(hashtable) x) - { this->Base::operator=(::boost::move(static_cast<Base&>(x))); return *this; } -}; - -#endif - -} //namespace intrusive -} //namespace boost - -#include <boost/intrusive/detail/config_end.hpp> - -#endif //BOOST_INTRUSIVE_HASHTABLE_HPP diff --git a/src/third_party/boost/boost/intrusive/intrusive_fwd.hpp b/src/third_party/boost/boost/intrusive/intrusive_fwd.hpp deleted file mode 100644 index dc185667e0a..00000000000 --- a/src/third_party/boost/boost/intrusive/intrusive_fwd.hpp +++ /dev/null @@ -1,542 +0,0 @@ -///////////////////////////////////////////////////////////////////////////// -// -// (C) Copyright Ion Gaztanaga 2007-2009 -// -// Distributed under the Boost Software License, Version 1.0. -// (See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) -// -// See http://www.boost.org/libs/intrusive for documentation. -// -///////////////////////////////////////////////////////////////////////////// - -#ifndef BOOST_INTRUSIVE_FWD_HPP -#define BOOST_INTRUSIVE_FWD_HPP - -#include <cstddef> -#include <boost/intrusive/link_mode.hpp> -#include <boost/intrusive/detail/workaround.hpp> - -/// @cond - -namespace boost { - -namespace intrusive { - -struct none; - -} //namespace intrusive{ -} //namespace boost{ - -namespace boost { -namespace intrusive { - -//////////////////////////// -// Node algorithms -//////////////////////////// - -//Algorithms predeclarations -template<class NodeTraits> -class circular_list_algorithms; - -template<class NodeTraits> -class circular_slist_algorithms; - -template<class NodeTraits> -class rbtree_algorithms; - -//////////////////////////// -// Containers -//////////////////////////// - -//slist -#if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) && !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template - < class T - , class O1 = none - , class O2 = none - , class O3 = none - , class O4 = none - , class O5 = none - > -#else -template<class T, class ...Options> -#endif -class slist; - -#if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) && !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template - < class O1 = none - , class O2 = none - , class O3 = none - > -#else -template<class ...Options> -#endif -class slist_base_hook; - -#if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) && !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template - < class O1 = none - , class O2 = none - , class O3 = none - > -#else -template<class ...Options> -#endif -class slist_member_hook; - -//list -#if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) && !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template - < class T - , class O1 = none - , class O2 = none - , class O3 = none - > -#else -template<class T, class ...Options> -#endif -class list; - -#if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) && !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template - < class O1 = none - , class O2 = none - , class O3 = none - > -#else -template<class ...Options> -#endif -class list_base_hook; - -#if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) && !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template - < class O1 = none - , class O2 = none - , class O3 = none - > -#else -template<class ...Options> -#endif -class list_member_hook; - -#if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) && !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template - < class O1 = none - , class O2 = none - , class O3 = none - > -#else -template<class ...Options> -#endif -class list_hook; - -//rbtree/set/multiset -#if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) && !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template - < class T - , class O1 = none - , class O2 = none - , class O3 = none - , class O4 = none - > -#else -template<class T, class ...Options> -#endif -class rbtree; - -#if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) && !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template - < class T - , class O1 = none - , class O2 = none - , class O3 = none - , class O4 = none - > -#else -template<class T, class ...Options> -#endif -class set; - -#if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) && !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template - < class T - , class O1 = none - , class O2 = none - , class O3 = none - , class O4 = none - > -#else -template<class T, class ...Options> -#endif -class multiset; - -#if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) && !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template - < class O1 = none - , class O2 = none - , class O3 = none - , class O4 = none - > -#else -template<class ...Options> -#endif -class set_base_hook; - -#if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) && !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template - < class O1 = none - , class O2 = none - , class O3 = none - , class O4 = none - > -#else -template<class ...Options> -#endif -class set_member_hook; - -//splaytree/splay_set/splay_multiset -#if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) && !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template - < class T - , class O1 = none - , class O2 = none - , class O3 = none - , class O4 = none - > -#else -template<class T, class ...Options> -#endif -class splaytree; - -#if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) && !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template - < class T - , class O1 = none - , class O2 = none - , class O3 = none - , class O4 = none - > -#else -template<class T, class ...Options> -#endif -class splay_set; - -#if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) && !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template - < class T - , class O1 = none - , class O2 = none - , class O3 = none - , class O4 = none - > -#else -template<class T, class ...Options> -#endif -class splay_multiset; - -#if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) && !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template - < class O1 = none - , class O2 = none - , class O3 = none - > -#else -template<class ...Options> -#endif -class splay_set_base_hook; - -#if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) && !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template - < class O1 = none - , class O2 = none - , class O3 = none - > -#else -template<class ...Options> -#endif -class splay_set_member_hook; - -//avltree/avl_set/avl_multiset -#if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) && !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template - < class T - , class O1 = none - , class O2 = none - , class O3 = none - , class O4 = none - > -#else -template<class T, class ...Options> -#endif -class avltree; - -#if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) && !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template - < class T - , class O1 = none - , class O2 = none - , class O3 = none - , class O4 = none - > -#else -template<class T, class ...Options> -#endif -class avl_set; - -#if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) && !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template - < class T - , class O1 = none - , class O2 = none - , class O3 = none - , class O4 = none - > -#else -template<class T, class ...Options> -#endif -class avl_multiset; - -#if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) && !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template - < class O1 = none - , class O2 = none - , class O3 = none - , class O4 = none - > -#else -template<class ...Options> -#endif -class avl_set_base_hook; - -#if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) && !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template - < class O1 = none - , class O2 = none - , class O3 = none - , class O4 = none - > -#else -template<class ...Options> -#endif -class avl_set_member_hook; - - -//treap/treap_set/treap_multiset -#if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) && !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template - < class T - , class O1 = none - , class O2 = none - , class O3 = none - , class O4 = none - > -#else -template<class T, class ...Options> -#endif -class treap; - -#if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) && !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template - < class T - , class O1 = none - , class O2 = none - , class O3 = none - , class O4 = none - > -#else -template<class T, class ...Options> -#endif -class treap_set; - -#if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) && !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template - < class T - , class O1 = none - , class O2 = none - , class O3 = none - , class O4 = none - > -#else -template<class T, class ...Options> -#endif -class treap_multiset; - -//Default priority comparison functor -template <class T> -struct priority_compare; - -//sgtree/sg_set/sg_multiset -#if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) && !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template - < class T - , class O1 = none - , class O2 = none - , class O3 = none - , class O4 = none - > -#else -template<class T, class ...Options> -#endif -class sgtree; - -#if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) && !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template - < class T - , class O1 = none - , class O2 = none - , class O3 = none - , class O4 = none - > -#else -template<class T, class ...Options> -#endif -class sg_set; - -#if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) && !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template - < class T - , class O1 = none - , class O2 = none - , class O3 = none - , class O4 = none - > -#else -template<class T, class ...Options> -#endif -class sg_multiset; - -#if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) && !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template - < class O1 = none - , class O2 = none - , class O3 = none - > -#else -template<class ...Options> -#endif -class bs_set_base_hook; - -#if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) && !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template - < class O1 = none - , class O2 = none - , class O3 = none - > -#else -template<class ...Options> -#endif -class bs_set_member_hook; - -//hashtable/unordered_set/unordered_multiset - -#if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) && !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template - < class T - , class O1 = none - , class O2 = none - , class O3 = none - , class O4 = none - , class O5 = none - , class O6 = none - , class O7 = none - , class O8 = none - , class O9 = none - , class O10 = none - > -#else -template<class T, class ...Options> -#endif -class hashtable; - -#if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) && !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template - < class T - , class O1 = none - , class O2 = none - , class O3 = none - , class O4 = none - , class O5 = none - , class O6 = none - , class O7 = none - , class O8 = none - , class O9 = none - , class O10 = none - > -#else -template<class T, class ...Options> -#endif -class unordered_set; - -#if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) && !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template - < class T - , class O1 = none - , class O2 = none - , class O3 = none - , class O4 = none - , class O5 = none - , class O6 = none - , class O7 = none - , class O8 = none - , class O9 = none - , class O10 = none - > -#else -template<class T, class ...Options> -#endif -class unordered_multiset; - -#if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) && !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template - < class O1 = none - , class O2 = none - , class O3 = none - , class O4 = none - > -#else -template<class ...Options> -#endif -class unordered_set_base_hook; - -#if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) && !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template - < class O1 = none - , class O2 = none - , class O3 = none - , class O4 = none - > -#else -template<class ...Options> -#endif -class unordered_set_member_hook; - -#if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) && !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template - < class O1 = none - , class O2 = none - , class O3 = none - > -#else -template<class ...Options> -#endif -class any_base_hook; - -#if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) && !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template - < class O1 = none - , class O2 = none - , class O3 = none - > -#else -template<class ...Options> -#endif -class any_member_hook; - -} //namespace intrusive { -} //namespace boost { - -/// @endcond - -#endif //#ifndef BOOST_INTRUSIVE_FWD_HPP diff --git a/src/third_party/boost/boost/intrusive/linear_slist_algorithms.hpp b/src/third_party/boost/boost/intrusive/linear_slist_algorithms.hpp deleted file mode 100644 index f33565528e1..00000000000 --- a/src/third_party/boost/boost/intrusive/linear_slist_algorithms.hpp +++ /dev/null @@ -1,327 +0,0 @@ -///////////////////////////////////////////////////////////////////////////// -// -// (C) Copyright Olaf Krzikalla 2004-2006. -// (C) Copyright Ion Gaztanaga 2006-2009 -// -// Distributed under the Boost Software License, Version 1.0. -// (See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) -// -// See http://www.boost.org/libs/intrusive for documentation. -// -///////////////////////////////////////////////////////////////////////////// - -#ifndef BOOST_INTRUSIVE_LINEAR_SLIST_ALGORITHMS_HPP -#define BOOST_INTRUSIVE_LINEAR_SLIST_ALGORITHMS_HPP - -#include <boost/intrusive/detail/config_begin.hpp> -#include <boost/intrusive/intrusive_fwd.hpp> -#include <boost/intrusive/detail/common_slist_algorithms.hpp> -#include <cstddef> -#include <utility> - -namespace boost { -namespace intrusive { - -//! linear_slist_algorithms provides basic algorithms to manipulate nodes -//! forming a linear singly linked list. -//! -//! linear_slist_algorithms is configured with a NodeTraits class, which encapsulates the -//! information about the node to be manipulated. NodeTraits must support the -//! following interface: -//! -//! <b>Typedefs</b>: -//! -//! <tt>node</tt>: The type of the node that forms the linear list -//! -//! <tt>node_ptr</tt>: A pointer to a node -//! -//! <tt>const_node_ptr</tt>: A pointer to a const node -//! -//! <b>Static functions</b>: -//! -//! <tt>static node_ptr get_next(const_node_ptr n);</tt> -//! -//! <tt>static void set_next(node_ptr n, node_ptr next);</tt> -template<class NodeTraits> -class linear_slist_algorithms - /// @cond - : public detail::common_slist_algorithms<NodeTraits> - /// @endcond -{ - /// @cond - typedef detail::common_slist_algorithms<NodeTraits> base_t; - /// @endcond - public: - typedef typename NodeTraits::node node; - typedef typename NodeTraits::node_ptr node_ptr; - typedef typename NodeTraits::const_node_ptr const_node_ptr; - typedef NodeTraits node_traits; - - #if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) - - //! <b>Effects</b>: Constructs an non-used list element, putting the next - //! pointer to null: - //! <tt>NodeTraits::get_next(this_node) == node_ptr()</tt> - //! - //! <b>Complexity</b>: Constant - //! - //! <b>Throws</b>: Nothing. - static void init(const node_ptr & this_node); - - //! <b>Requires</b>: this_node must be in a circular list or be an empty circular list. - //! - //! <b>Effects</b>: Returns true is "this_node" is the only node of a circular list: - //! or it's a not inserted node: - //! <tt>return node_ptr() == NodeTraits::get_next(this_node) || NodeTraits::get_next(this_node) == this_node</tt> - //! - //! <b>Complexity</b>: Constant - //! - //! <b>Throws</b>: Nothing. - static bool unique(const_node_ptr this_node); - - //! <b>Effects</b>: Returns true is "this_node" has the same state as if - //! it was inited using "init(node_ptr)" - //! - //! <b>Complexity</b>: Constant - //! - //! <b>Throws</b>: Nothing. - static bool inited(const_node_ptr this_node); - - //! <b>Requires</b>: prev_node must be in a circular list or be an empty circular list. - //! - //! <b>Effects</b>: Unlinks the next node of prev_node from the circular list. - //! - //! <b>Complexity</b>: Constant - //! - //! <b>Throws</b>: Nothing. - static void unlink_after(const node_ptr & prev_node); - - //! <b>Requires</b>: prev_node and last_node must be in a circular list - //! or be an empty circular list. - //! - //! <b>Effects</b>: Unlinks the range (prev_node, last_node) from the linear list. - //! - //! <b>Complexity</b>: Constant - //! - //! <b>Throws</b>: Nothing. - static void unlink_after(const node_ptr & prev_node, const node_ptr & last_node); - - //! <b>Requires</b>: prev_node must be a node of a linear list. - //! - //! <b>Effects</b>: Links this_node after prev_node in the linear list. - //! - //! <b>Complexity</b>: Constant - //! - //! <b>Throws</b>: Nothing. - static void link_after(const node_ptr & prev_node, const node_ptr & this_node); - - //! <b>Requires</b>: b and e must be nodes of the same linear list or an empty range. - //! and p must be a node of a different linear list. - //! - //! <b>Effects</b>: Removes the nodes from (b, e] range from their linear list and inserts - //! them after p in p's linear list. - //! - //! <b>Complexity</b>: Constant - //! - //! <b>Throws</b>: Nothing. - static void transfer_after(const node_ptr & p, const node_ptr & b, const node_ptr & e); - - #endif //#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) - - //! <b>Effects</b>: Constructs an empty list, making this_node the only - //! node of the circular list: - //! <tt>NodeTraits::get_next(this_node) == this_node</tt>. - //! - //! <b>Complexity</b>: Constant - //! - //! <b>Throws</b>: Nothing. - static void init_header(const node_ptr & this_node) - { NodeTraits::set_next(this_node, node_ptr ()); } - - //! <b>Requires</b>: this_node and prev_init_node must be in the same linear list. - //! - //! <b>Effects</b>: Returns the previous node of this_node in the linear list starting. - //! the search from prev_init_node. The first node checked for equality - //! is NodeTraits::get_next(prev_init_node). - //! - //! <b>Complexity</b>: Linear to the number of elements between prev_init_node and this_node. - //! - //! <b>Throws</b>: Nothing. - static node_ptr get_previous_node(const node_ptr & prev_init_node, const node_ptr & this_node) - { return base_t::get_previous_node(prev_init_node, this_node); } - - //! <b>Requires</b>: this_node must be in a linear list or be an empty linear list. - //! - //! <b>Effects</b>: Returns the number of nodes in a linear list. If the linear list - //! is empty, returns 1. - //! - //! <b>Complexity</b>: Linear - //! - //! <b>Throws</b>: Nothing. - static std::size_t count(const const_node_ptr & this_node) - { - std::size_t result = 0; - const_node_ptr p = this_node; - do{ - p = NodeTraits::get_next(p); - ++result; - } while (p); - return result; - } - - //! <b>Requires</b>: this_node and other_node must be nodes inserted - //! in linear lists or be empty linear lists. - //! - //! <b>Effects</b>: Moves all the nodes previously chained after this_node after other_node - //! and vice-versa. - //! - //! <b>Complexity</b>: Constant - //! - //! <b>Throws</b>: Nothing. - static void swap_trailing_nodes(const node_ptr & this_node, const node_ptr & other_node) - { - node_ptr this_nxt = NodeTraits::get_next(this_node); - node_ptr other_nxt = NodeTraits::get_next(other_node); - NodeTraits::set_next(this_node, other_nxt); - NodeTraits::set_next(other_node, this_nxt); - } - - //! <b>Effects</b>: Reverses the order of elements in the list. - //! - //! <b>Returns</b>: The new first node of the list. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: This function is linear to the contained elements. - static node_ptr reverse(const node_ptr & p) - { - if(!p) return node_ptr(); - node_ptr i = NodeTraits::get_next(p); - node_ptr first(p); - while(i){ - node_ptr nxti(NodeTraits::get_next(i)); - base_t::unlink_after(p); - NodeTraits::set_next(i, first); - first = i; - i = nxti; - } - return first; - } - - //! <b>Effects</b>: Moves the first n nodes starting at p to the end of the list. - //! - //! <b>Returns</b>: A pair containing the new first and last node of the list or - //! if there has been any movement, a null pair if n leads to no movement. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Linear to the number of elements plus the number moved positions. - static std::pair<node_ptr, node_ptr> move_first_n_backwards(const node_ptr & p, std::size_t n) - { - std::pair<node_ptr, node_ptr> ret; - //Null shift, or count() == 0 or 1, nothing to do - if(!n || !p || !NodeTraits::get_next(p)){ - return ret; - } - - node_ptr first = p; - bool end_found = false; - node_ptr new_last = node_ptr(); - node_ptr old_last = node_ptr(); - - //Now find the new last node according to the shift count. - //If we find 0 before finding the new last node - //unlink p, shortcut the search now that we know the size of the list - //and continue. - for(std::size_t i = 1; i <= n; ++i){ - new_last = first; - first = NodeTraits::get_next(first); - if(first == node_ptr()){ - //Shortcut the shift with the modulo of the size of the list - n %= i; - if(!n) return ret; - old_last = new_last; - i = 0; - //Unlink p and continue the new first node search - first = p; - //unlink_after(new_last); - end_found = true; - } - } - - //If the p has not been found in the previous loop, find it - //starting in the new first node and unlink it - if(!end_found){ - old_last = base_t::get_previous_node(first, node_ptr()); - } - - //Now link p after the new last node - NodeTraits::set_next(old_last, p); - NodeTraits::set_next(new_last, node_ptr()); - ret.first = first; - ret.second = new_last; - return ret; - } - - //! <b>Effects</b>: Moves the first n nodes starting at p to the beginning of the list. - //! - //! <b>Returns</b>: A pair containing the new first and last node of the list or - //! if there has been any movement, a null pair if n leads to no movement. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Linear to the number of elements plus the number moved positions. - static std::pair<node_ptr, node_ptr> move_first_n_forward(const node_ptr & p, std::size_t n) - { - std::pair<node_ptr, node_ptr> ret; - //Null shift, or count() == 0 or 1, nothing to do - if(!n || !p || !NodeTraits::get_next(p)) - return ret; - - node_ptr first = p; - - //Iterate until p is found to know where the current last node is. - //If the shift count is less than the size of the list, we can also obtain - //the position of the new last node after the shift. - node_ptr old_last(first), next_to_it, new_last(p); - std::size_t distance = 1; - while(!!(next_to_it = node_traits::get_next(old_last))){ - if(distance++ > n) - new_last = node_traits::get_next(new_last); - old_last = next_to_it; - } - //If the shift was bigger or equal than the size, obtain the equivalent - //forward shifts and find the new last node. - if(distance <= n){ - //Now find the equivalent forward shifts. - //Shortcut the shift with the modulo of the size of the list - std::size_t new_before_last_pos = (distance - (n % distance))% distance; - //If the shift is a multiple of the size there is nothing to do - if(!new_before_last_pos) - return ret; - - for( new_last = p - ; --new_before_last_pos - ; new_last = node_traits::get_next(new_last)){ - //empty - } - } - - //Get the first new node - node_ptr new_first(node_traits::get_next(new_last)); - //Now put the old beginning after the old end - NodeTraits::set_next(old_last, p); - NodeTraits::set_next(new_last, node_ptr()); - ret.first = new_first; - ret.second = new_last; - return ret; - } -}; - -} //namespace intrusive -} //namespace boost - -#include <boost/intrusive/detail/config_end.hpp> - -#endif //BOOST_INTRUSIVE_LINEAR_SLIST_ALGORITHMS_HPP diff --git a/src/third_party/boost/boost/intrusive/link_mode.hpp b/src/third_party/boost/boost/intrusive/link_mode.hpp deleted file mode 100644 index 17012c93cb0..00000000000 --- a/src/third_party/boost/boost/intrusive/link_mode.hpp +++ /dev/null @@ -1,46 +0,0 @@ -///////////////////////////////////////////////////////////////////////////// -// -// (C) Copyright Ion Gaztanaga 2006-2009 -// -// Distributed under the Boost Software License, Version 1.0. -// (See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) -// -// See http://www.boost.org/libs/intrusive for documentation. -// -///////////////////////////////////////////////////////////////////////////// - -#ifndef BOOST_INTRUSIVE_VALUE_LINK_TYPE_HPP -#define BOOST_INTRUSIVE_VALUE_LINK_TYPE_HPP - -namespace boost { -namespace intrusive { - -//!This enumeration defines the type of value_traits that can be defined -//!for Boost.Intrusive containers -enum link_mode_type{ - //!If this linking policy is specified in a value_traits class - //!as the link_mode, containers - //!configured with such value_traits won't set the hooks - //!of the erased values to a default state. Containers also won't - //!check that the hooks of the new values are default initialized. - normal_link, - - //!If this linking policy is specified in a value_traits class - //!as the link_mode, containers - //!configured with such value_traits will set the hooks - //!of the erased values to a default state. Containers also will - //!check that the hooks of the new values are default initialized. - safe_link, - - //!Same as "safe_link" but the user type is an auto-unlink - //!type, so the containers with constant-time size features won't be - //!compatible with value_traits configured with this policy. - //!Containers also know that the a value can be silently erased from - //!the container without using any function provided by the containers. - auto_unlink -}; -} //namespace intrusive -} //namespace boost - -#endif //BOOST_INTRUSIVE_VALUE_LINK_TYPE_HPP diff --git a/src/third_party/boost/boost/intrusive/list.hpp b/src/third_party/boost/boost/intrusive/list.hpp deleted file mode 100644 index dbbf7c93f57..00000000000 --- a/src/third_party/boost/boost/intrusive/list.hpp +++ /dev/null @@ -1,1525 +0,0 @@ -///////////////////////////////////////////////////////////////////////////// -// -// (C) Copyright Olaf Krzikalla 2004-2006. -// (C) Copyright Ion Gaztanaga 2006-2009 -// -// Distributed under the Boost Software License, Version 1.0. -// (See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) -// -// See http://www.boost.org/libs/intrusive for documentation. -// -///////////////////////////////////////////////////////////////////////////// - -#ifndef BOOST_INTRUSIVE_LIST_HPP -#define BOOST_INTRUSIVE_LIST_HPP - -#include <boost/intrusive/detail/config_begin.hpp> -#include <boost/intrusive/detail/assert.hpp> -#include <boost/intrusive/intrusive_fwd.hpp> -#include <boost/intrusive/list_hook.hpp> -#include <boost/intrusive/circular_list_algorithms.hpp> -#include <boost/intrusive/pointer_traits.hpp> -#include <boost/intrusive/detail/clear_on_destructor_base.hpp> -#include <boost/intrusive/detail/mpl.hpp> -#include <boost/intrusive/link_mode.hpp> -#include <boost/static_assert.hpp> -#include <boost/intrusive/options.hpp> -#include <boost/intrusive/pointer_traits.hpp> -#include <boost/intrusive/detail/utilities.hpp> -#include <iterator> -#include <algorithm> -#include <functional> -#include <cstddef> -#include <boost/move/move.hpp> - -namespace boost { -namespace intrusive { - -/// @cond - -template <class ValueTraits, class SizeType, bool ConstantTimeSize> -struct listopt -{ - typedef ValueTraits value_traits; - typedef SizeType size_type; - static const bool constant_time_size = ConstantTimeSize; -}; - - -template <class T> -struct list_defaults - : pack_options - < none - , base_hook<detail::default_list_hook> - , constant_time_size<true> - , size_type<std::size_t> - >::type -{}; - -/// @endcond - -//! The class template list is an intrusive container that mimics most of the -//! interface of std::list as described in the C++ standard. -//! -//! The template parameter \c T is the type to be managed by the container. -//! The user can specify additional options and if no options are provided -//! default options are used. -//! -//! The container supports the following options: -//! \c base_hook<>/member_hook<>/value_traits<>, -//! \c constant_time_size<> and \c size_type<>. -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -class list_impl - : private detail::clear_on_destructor_base< list_impl<Config> > -{ - template<class C> friend class detail::clear_on_destructor_base; - //Public typedefs - public: - typedef typename Config::value_traits value_traits; - /// @cond - static const bool external_value_traits = - detail::external_value_traits_is_true<value_traits>::value; - typedef typename detail::eval_if_c - < external_value_traits - , detail::eval_value_traits<value_traits> - , detail::identity<value_traits> - >::type real_value_traits; - /// @endcond - typedef typename real_value_traits::pointer pointer; - typedef typename real_value_traits::const_pointer const_pointer; - typedef typename pointer_traits<pointer>::element_type value_type; - typedef typename pointer_traits<pointer>::reference reference; - typedef typename pointer_traits<const_pointer>::reference const_reference; - typedef typename pointer_traits<pointer>::difference_type difference_type; - typedef typename Config::size_type size_type; - typedef list_iterator<list_impl, false> iterator; - typedef list_iterator<list_impl, true> const_iterator; - typedef boost::intrusive::detail::reverse_iterator<iterator> reverse_iterator; - typedef boost::intrusive::detail::reverse_iterator<const_iterator>const_reverse_iterator; - typedef typename real_value_traits::node_traits node_traits; - typedef typename node_traits::node node; - typedef typename node_traits::node_ptr node_ptr; - typedef typename node_traits::const_node_ptr const_node_ptr; - typedef circular_list_algorithms<node_traits> node_algorithms; - - static const bool constant_time_size = Config::constant_time_size; - static const bool stateful_value_traits = detail::is_stateful_value_traits<real_value_traits>::value; - - /// @cond - - private: - typedef detail::size_holder<constant_time_size, size_type> size_traits; - - //noncopyable - BOOST_MOVABLE_BUT_NOT_COPYABLE(list_impl) - - enum { safemode_or_autounlink = - (int)real_value_traits::link_mode == (int)auto_unlink || - (int)real_value_traits::link_mode == (int)safe_link }; - - //Constant-time size is incompatible with auto-unlink hooks! - BOOST_STATIC_ASSERT(!(constant_time_size && - ((int)real_value_traits::link_mode == (int)auto_unlink) - )); - - //Const cast emulation for smart pointers - static node_ptr uncast(const const_node_ptr & ptr) - { return pointer_traits<node_ptr>::const_cast_from(ptr); } - - node_ptr get_root_node() - { return pointer_traits<node_ptr>::pointer_to(data_.root_plus_size_.root_); } - - const_node_ptr get_root_node() const - { return pointer_traits<const_node_ptr>::pointer_to(data_.root_plus_size_.root_); } - - struct root_plus_size : public size_traits - { - node root_; - }; - - struct data_t : public value_traits - { - typedef typename list_impl::value_traits value_traits; - data_t(const value_traits &val_traits) - : value_traits(val_traits) - {} - - root_plus_size root_plus_size_; - } data_; - - size_traits &priv_size_traits() - { return data_.root_plus_size_; } - - const size_traits &priv_size_traits() const - { return data_.root_plus_size_; } - - const real_value_traits &get_real_value_traits(detail::bool_<false>) const - { return data_; } - - const real_value_traits &get_real_value_traits(detail::bool_<true>) const - { return data_.get_value_traits(*this); } - - real_value_traits &get_real_value_traits(detail::bool_<false>) - { return data_; } - - real_value_traits &get_real_value_traits(detail::bool_<true>) - { return data_.get_value_traits(*this); } - - const value_traits &priv_value_traits() const - { return data_; } - - value_traits &priv_value_traits() - { return data_; } - - protected: - node &prot_root_node() - { return data_.root_plus_size_.root_; } - - node const &prot_root_node() const - { return data_.root_plus_size_.root_; } - - void prot_set_size(size_type s) - { data_.root_plus_size_.set_size(s); } - - /// @endcond - - public: - - const real_value_traits &get_real_value_traits() const - { return this->get_real_value_traits(detail::bool_<external_value_traits>()); } - - real_value_traits &get_real_value_traits() - { return this->get_real_value_traits(detail::bool_<external_value_traits>()); } - - //! <b>Effects</b>: constructs an empty list. - //! - //! <b>Complexity</b>: Constant - //! - //! <b>Throws</b>: If real_value_traits::node_traits::node - //! constructor throws (this does not happen with predefined Boost.Intrusive hooks). - list_impl(const value_traits &v_traits = value_traits()) - : data_(v_traits) - { - this->priv_size_traits().set_size(size_type(0)); - node_algorithms::init_header(this->get_root_node()); - } - - //! <b>Requires</b>: Dereferencing iterator must yield an lvalue of type value_type. - //! - //! <b>Effects</b>: Constructs a list equal to the range [first,last). - //! - //! <b>Complexity</b>: Linear in std::distance(b, e). No copy constructors are called. - //! - //! <b>Throws</b>: If real_value_traits::node_traits::node - //! constructor throws (this does not happen with predefined Boost.Intrusive hooks). - template<class Iterator> - list_impl(Iterator b, Iterator e, const value_traits &v_traits = value_traits()) - : data_(v_traits) - { - this->priv_size_traits().set_size(size_type(0)); - node_algorithms::init_header(this->get_root_node()); - this->insert(this->cend(), b, e); - } - - //! <b>Effects</b>: to-do - //! - list_impl(BOOST_RV_REF(list_impl) x) - : data_(::boost::move(x.priv_value_traits())) - { - this->priv_size_traits().set_size(size_type(0)); - node_algorithms::init_header(this->get_root_node()); - this->swap(x); - } - - //! <b>Effects</b>: to-do - //! - list_impl& operator=(BOOST_RV_REF(list_impl) x) - { this->swap(x); return *this; } - - //! <b>Effects</b>: If it's not a safe-mode or an auto-unlink value_type - //! the destructor does nothing - //! (ie. no code is generated). Otherwise it detaches all elements from this. - //! In this case the objects in the list are not deleted (i.e. no destructors - //! are called), but the hooks according to the ValueTraits template parameter - //! are set to their default value. - //! - //! <b>Complexity</b>: Linear to the number of elements in the list, if - //! it's a safe-mode or auto-unlink value . Otherwise constant. - ~list_impl() - {} - - //! <b>Requires</b>: value must be an lvalue. - //! - //! <b>Effects</b>: Inserts the value in the back of the list. - //! No copy constructors are called. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Note</b>: Does not affect the validity of iterators and references. - void push_back(reference value) - { - node_ptr to_insert = get_real_value_traits().to_node_ptr(value); - if(safemode_or_autounlink) - BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::inited(to_insert)); - node_algorithms::link_before(this->get_root_node(), to_insert); - this->priv_size_traits().increment(); - } - - //! <b>Requires</b>: value must be an lvalue. - //! - //! <b>Effects</b>: Inserts the value in the front of the list. - //! No copy constructors are called. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Note</b>: Does not affect the validity of iterators and references. - void push_front(reference value) - { - node_ptr to_insert = get_real_value_traits().to_node_ptr(value); - if(safemode_or_autounlink) - BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::inited(to_insert)); - node_algorithms::link_before(node_traits::get_next(this->get_root_node()), to_insert); - this->priv_size_traits().increment(); - } - - //! <b>Effects</b>: Erases the last element of the list. - //! No destructors are called. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) to the erased element. - void pop_back() - { return this->pop_back_and_dispose(detail::null_disposer()); } - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! - //! <b>Effects</b>: Erases the last element of the list. - //! No destructors are called. - //! Disposer::operator()(pointer) is called for the removed element. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Note</b>: Invalidates the iterators to the erased element. - template<class Disposer> - void pop_back_and_dispose(Disposer disposer) - { - node_ptr to_erase = node_traits::get_previous(this->get_root_node()); - node_algorithms::unlink(to_erase); - this->priv_size_traits().decrement(); - if(safemode_or_autounlink) - node_algorithms::init(to_erase); - disposer(get_real_value_traits().to_value_ptr(to_erase)); - } - - //! <b>Effects</b>: Erases the first element of the list. - //! No destructors are called. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) to the erased element. - void pop_front() - { return this->pop_front_and_dispose(detail::null_disposer()); } - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! - //! <b>Effects</b>: Erases the first element of the list. - //! No destructors are called. - //! Disposer::operator()(pointer) is called for the removed element. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Note</b>: Invalidates the iterators to the erased element. - template<class Disposer> - void pop_front_and_dispose(Disposer disposer) - { - node_ptr to_erase = node_traits::get_next(this->get_root_node()); - node_algorithms::unlink(to_erase); - this->priv_size_traits().decrement(); - if(safemode_or_autounlink) - node_algorithms::init(to_erase); - disposer(get_real_value_traits().to_value_ptr(to_erase)); - } - - //! <b>Effects</b>: Returns a reference to the first element of the list. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - reference front() - { return *get_real_value_traits().to_value_ptr(node_traits::get_next(this->get_root_node())); } - - //! <b>Effects</b>: Returns a const_reference to the first element of the list. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - const_reference front() const - { return *get_real_value_traits().to_value_ptr(uncast(node_traits::get_next(this->get_root_node()))); } - - //! <b>Effects</b>: Returns a reference to the last element of the list. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - reference back() - { return *get_real_value_traits().to_value_ptr(node_traits::get_previous(this->get_root_node())); } - - //! <b>Effects</b>: Returns a const_reference to the last element of the list. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - const_reference back() const - { return *get_real_value_traits().to_value_ptr(uncast(node_traits::get_previous(this->get_root_node()))); } - - //! <b>Effects</b>: Returns an iterator to the first element contained in the list. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - iterator begin() - { return iterator(node_traits::get_next(this->get_root_node()), this); } - - //! <b>Effects</b>: Returns a const_iterator to the first element contained in the list. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - const_iterator begin() const - { return this->cbegin(); } - - //! <b>Effects</b>: Returns a const_iterator to the first element contained in the list. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - const_iterator cbegin() const - { return const_iterator(node_traits::get_next(this->get_root_node()), this); } - - //! <b>Effects</b>: Returns an iterator to the end of the list. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - iterator end() - { return iterator(this->get_root_node(), this); } - - //! <b>Effects</b>: Returns a const_iterator to the end of the list. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - const_iterator end() const - { return this->cend(); } - - //! <b>Effects</b>: Returns a constant iterator to the end of the list. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - const_iterator cend() const - { return const_iterator(uncast(this->get_root_node()), this); } - - //! <b>Effects</b>: Returns a reverse_iterator pointing to the beginning - //! of the reversed list. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - reverse_iterator rbegin() - { return reverse_iterator(this->end()); } - - //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning - //! of the reversed list. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - const_reverse_iterator rbegin() const - { return this->crbegin(); } - - //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning - //! of the reversed list. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - const_reverse_iterator crbegin() const - { return const_reverse_iterator(end()); } - - //! <b>Effects</b>: Returns a reverse_iterator pointing to the end - //! of the reversed list. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - reverse_iterator rend() - { return reverse_iterator(begin()); } - - //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the end - //! of the reversed list. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - const_reverse_iterator rend() const - { return this->crend(); } - - //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the end - //! of the reversed list. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - const_reverse_iterator crend() const - { return const_reverse_iterator(this->begin()); } - - //! <b>Precondition</b>: end_iterator must be a valid end iterator - //! of list. - //! - //! <b>Effects</b>: Returns a const reference to the list associated to the end iterator - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - static list_impl &container_from_end_iterator(iterator end_iterator) - { return list_impl::priv_container_from_end_iterator(end_iterator); } - - //! <b>Precondition</b>: end_iterator must be a valid end const_iterator - //! of list. - //! - //! <b>Effects</b>: Returns a const reference to the list associated to the end iterator - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - static const list_impl &container_from_end_iterator(const_iterator end_iterator) - { return list_impl::priv_container_from_end_iterator(end_iterator); } - - //! <b>Effects</b>: Returns the number of the elements contained in the list. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Linear to the number of elements contained in the list. - //! if constant-time size option is disabled. Constant time otherwise. - //! - //! <b>Note</b>: Does not affect the validity of iterators and references. - size_type size() const - { - if(constant_time_size) - return this->priv_size_traits().get_size(); - else - return node_algorithms::count(this->get_root_node()) - 1; - } - - //! <b>Effects</b>: Returns true if the list contains no elements. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Note</b>: Does not affect the validity of iterators and references. - bool empty() const - { return node_algorithms::unique(this->get_root_node()); } - - //! <b>Effects</b>: Swaps the elements of x and *this. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Note</b>: Does not affect the validity of iterators and references. - void swap(list_impl& other) - { - node_algorithms::swap_nodes(this->get_root_node(), other.get_root_node()); - if(constant_time_size){ - size_type backup = this->priv_size_traits().get_size(); - this->priv_size_traits().set_size(other.priv_size_traits().get_size()); - other.priv_size_traits().set_size(backup); - } - } - - //! <b>Effects</b>: Moves backwards all the elements, so that the first - //! element becomes the second, the second becomes the third... - //! the last element becomes the first one. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Linear to the number of shifts. - //! - //! <b>Note</b>: Does not affect the validity of iterators and references. - void shift_backwards(size_type n = 1) - { node_algorithms::move_forward(this->get_root_node(), n); } - - //! <b>Effects</b>: Moves forward all the elements, so that the second - //! element becomes the first, the third becomes the second... - //! the first element becomes the last one. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Linear to the number of shifts. - //! - //! <b>Note</b>: Does not affect the validity of iterators and references. - void shift_forward(size_type n = 1) - { node_algorithms::move_backwards(this->get_root_node(), n); } - - //! <b>Effects</b>: Erases the element pointed by i of the list. - //! No destructors are called. - //! - //! <b>Returns</b>: the first element remaining beyond the removed element, - //! or end() if no such element exists. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) to the - //! erased element. - iterator erase(const_iterator i) - { return this->erase_and_dispose(i, detail::null_disposer()); } - - //! <b>Requires</b>: b and e must be valid iterators to elements in *this. - //! - //! <b>Effects</b>: Erases the element range pointed by b and e - //! No destructors are called. - //! - //! <b>Returns</b>: the first element remaining beyond the removed elements, - //! or end() if no such element exists. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Linear to the number of erased elements if it's a safe-mode - //! or auto-unlink value, or constant-time size is enabled. Constant-time otherwise. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) to the - //! erased elements. - iterator erase(const_iterator b, const_iterator e) - { - if(safemode_or_autounlink || constant_time_size){ - return this->erase_and_dispose(b, e, detail::null_disposer()); - } - else{ - node_algorithms::unlink(b.pointed_node(), e.pointed_node()); - return e.unconst(); - } - } - - //! <b>Requires</b>: b and e must be valid iterators to elements in *this. - //! n must be std::distance(b, e). - //! - //! <b>Effects</b>: Erases the element range pointed by b and e - //! No destructors are called. - //! - //! <b>Returns</b>: the first element remaining beyond the removed elements, - //! or end() if no such element exists. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Linear to the number of erased elements if it's a safe-mode - //! or auto-unlink value is enabled. Constant-time otherwise. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) to the - //! erased elements. - iterator erase(const_iterator b, const_iterator e, difference_type n) - { - BOOST_INTRUSIVE_INVARIANT_ASSERT(std::distance(b, e) == difference_type(n)); - if(safemode_or_autounlink || constant_time_size){ - return this->erase_and_dispose(b, e, detail::null_disposer()); - } - else{ - if(constant_time_size){ - this->priv_size_traits().set_size(this->priv_size_traits().get_size() - n); - } - node_algorithms::unlink(b.pointed_node(), e.pointed_node()); - return e.unconst(); - } - } - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! - //! <b>Effects</b>: Erases the element pointed by i of the list. - //! No destructors are called. - //! Disposer::operator()(pointer) is called for the removed element. - //! - //! <b>Returns</b>: the first element remaining beyond the removed element, - //! or end() if no such element exists. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Note</b>: Invalidates the iterators to the erased element. - template <class Disposer> - iterator erase_and_dispose(const_iterator i, Disposer disposer) - { - node_ptr to_erase(i.pointed_node()); - ++i; - node_algorithms::unlink(to_erase); - this->priv_size_traits().decrement(); - if(safemode_or_autounlink) - node_algorithms::init(to_erase); - disposer(this->get_real_value_traits().to_value_ptr(to_erase)); - return i.unconst(); - } - - #if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) - template<class Disposer> - iterator erase_and_dispose(iterator i, Disposer disposer) - { return this->erase_and_dispose(const_iterator(i), disposer); } - #endif - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! - //! <b>Effects</b>: Erases the element range pointed by b and e - //! No destructors are called. - //! Disposer::operator()(pointer) is called for the removed elements. - //! - //! <b>Returns</b>: the first element remaining beyond the removed elements, - //! or end() if no such element exists. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Linear to the number of elements erased. - //! - //! <b>Note</b>: Invalidates the iterators to the erased elements. - template <class Disposer> - iterator erase_and_dispose(const_iterator b, const_iterator e, Disposer disposer) - { - node_ptr bp(b.pointed_node()), ep(e.pointed_node()); - node_algorithms::unlink(bp, ep); - while(bp != ep){ - node_ptr to_erase(bp); - bp = node_traits::get_next(bp); - if(safemode_or_autounlink) - node_algorithms::init(to_erase); - disposer(get_real_value_traits().to_value_ptr(to_erase)); - this->priv_size_traits().decrement(); - } - return e.unconst(); - } - - //! <b>Effects</b>: Erases all the elements of the container. - //! No destructors are called. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Linear to the number of elements of the list. - //! if it's a safe-mode or auto-unlink value_type. Constant time otherwise. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) to the erased elements. - void clear() - { - if(safemode_or_autounlink){ - this->clear_and_dispose(detail::null_disposer()); - } - else{ - node_algorithms::init_header(this->get_root_node()); - this->priv_size_traits().set_size(size_type(0)); - } - } - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! - //! <b>Effects</b>: Erases all the elements of the container. - //! No destructors are called. - //! Disposer::operator()(pointer) is called for the removed elements. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Linear to the number of elements of the list. - //! - //! <b>Note</b>: Invalidates the iterators to the erased elements. - template <class Disposer> - void clear_and_dispose(Disposer disposer) - { - const_iterator it(this->begin()), itend(this->end()); - while(it != itend){ - node_ptr to_erase(it.pointed_node()); - ++it; - if(safemode_or_autounlink) - node_algorithms::init(to_erase); - disposer(get_real_value_traits().to_value_ptr(to_erase)); - } - node_algorithms::init_header(this->get_root_node()); - this->priv_size_traits().set_size(0); - } - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! Cloner should yield to nodes equivalent to the original nodes. - //! - //! <b>Effects</b>: Erases all the elements from *this - //! calling Disposer::operator()(pointer), clones all the - //! elements from src calling Cloner::operator()(const_reference ) - //! and inserts them on *this. - //! - //! If cloner throws, all cloned elements are unlinked and disposed - //! calling Disposer::operator()(pointer). - //! - //! <b>Complexity</b>: Linear to erased plus inserted elements. - //! - //! <b>Throws</b>: If cloner throws. Basic guarantee. - template <class Cloner, class Disposer> - void clone_from(const list_impl &src, Cloner cloner, Disposer disposer) - { - this->clear_and_dispose(disposer); - detail::exception_disposer<list_impl, Disposer> - rollback(*this, disposer); - const_iterator b(src.begin()), e(src.end()); - for(; b != e; ++b){ - this->push_back(*cloner(*b)); - } - rollback.release(); - } - - //! <b>Requires</b>: value must be an lvalue and p must be a valid iterator of *this. - //! - //! <b>Effects</b>: Inserts the value before the position pointed by p. - //! - //! <b>Returns</b>: An iterator to the inserted element. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant time. No copy constructors are called. - //! - //! <b>Note</b>: Does not affect the validity of iterators and references. - iterator insert(const_iterator p, reference value) - { - node_ptr to_insert = this->get_real_value_traits().to_node_ptr(value); - if(safemode_or_autounlink) - BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::inited(to_insert)); - node_algorithms::link_before(p.pointed_node(), to_insert); - this->priv_size_traits().increment(); - return iterator(to_insert, this); - } - - //! <b>Requires</b>: Dereferencing iterator must yield - //! an lvalue of type value_type and p must be a valid iterator of *this. - //! - //! <b>Effects</b>: Inserts the range pointed by b and e before the position p. - //! No copy constructors are called. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Linear to the number of elements inserted. - //! - //! <b>Note</b>: Does not affect the validity of iterators and references. - template<class Iterator> - void insert(const_iterator p, Iterator b, Iterator e) - { - for (; b != e; ++b) - this->insert(p, *b); - } - - //! <b>Requires</b>: Dereferencing iterator must yield - //! an lvalue of type value_type. - //! - //! <b>Effects</b>: Clears the list and inserts the range pointed by b and e. - //! No destructors or copy constructors are called. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Linear to the number of elements inserted plus - //! linear to the elements contained in the list if it's a safe-mode - //! or auto-unlink value. - //! Linear to the number of elements inserted in the list otherwise. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. - template<class Iterator> - void assign(Iterator b, Iterator e) - { - this->clear(); - this->insert(this->cend(), b, e); - } - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! - //! <b>Requires</b>: Dereferencing iterator must yield - //! an lvalue of type value_type. - //! - //! <b>Effects</b>: Clears the list and inserts the range pointed by b and e. - //! No destructors or copy constructors are called. - //! Disposer::operator()(pointer) is called for the removed elements. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Linear to the number of elements inserted plus - //! linear to the elements contained in the list. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. - template<class Iterator, class Disposer> - void dispose_and_assign(Disposer disposer, Iterator b, Iterator e) - { - this->clear_and_dispose(disposer); - this->insert(this->cend(), b, e); - } - - //! <b>Requires</b>: p must be a valid iterator of *this. - //! - //! <b>Effects</b>: Transfers all the elements of list x to this list, before the - //! the element pointed by p. No destructors or copy constructors are called. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Note</b>: Iterators of values obtained from list x now point to elements of - //! this list. Iterators of this list and all the references are not invalidated. - void splice(const_iterator p, list_impl& x) - { - if(!x.empty()){ - size_traits &thist = this->priv_size_traits(); - size_traits &xt = x.priv_size_traits(); - node_algorithms::transfer - (p.pointed_node(), x.begin().pointed_node(), x.end().pointed_node()); - thist.set_size(thist.get_size() + xt.get_size()); - xt.set_size(size_type(0)); - } - } - - //! <b>Requires</b>: p must be a valid iterator of *this. - //! new_ele must point to an element contained in list x. - //! - //! <b>Effects</b>: Transfers the value pointed by new_ele, from list x to this list, - //! before the the element pointed by p. No destructors or copy constructors are called. - //! If p == new_ele or p == ++new_ele, this function is a null operation. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Note</b>: Iterators of values obtained from list x now point to elements of this - //! list. Iterators of this list and all the references are not invalidated. - void splice(const_iterator p, list_impl&x, const_iterator new_ele) - { - node_algorithms::transfer(p.pointed_node(), new_ele.pointed_node()); - x.priv_size_traits().decrement(); - this->priv_size_traits().increment(); - } - - //! <b>Requires</b>: p must be a valid iterator of *this. - //! start and end must point to elements contained in list x. - //! - //! <b>Effects</b>: Transfers the range pointed by start and end from list x to this list, - //! before the the element pointed by p. No destructors or copy constructors are called. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Linear to the number of elements transferred - //! if constant-time size option is enabled. Constant-time otherwise. - //! - //! <b>Note</b>: Iterators of values obtained from list x now point to elements of this - //! list. Iterators of this list and all the references are not invalidated. - void splice(const_iterator p, list_impl&x, const_iterator start, const_iterator end) - { - if(constant_time_size) - this->splice(p, x, start, end, std::distance(start, end)); - else - this->splice(p, x, start, end, 1);//distance is a dummy value - } - - //! <b>Requires</b>: p must be a valid iterator of *this. - //! start and end must point to elements contained in list x. - //! n == std::distance(start, end) - //! - //! <b>Effects</b>: Transfers the range pointed by start and end from list x to this list, - //! before the the element pointed by p. No destructors or copy constructors are called. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Note</b>: Iterators of values obtained from list x now point to elements of this - //! list. Iterators of this list and all the references are not invalidated. - void splice(const_iterator p, list_impl&x, const_iterator start, const_iterator end, difference_type n) - { - if(n){ - if(constant_time_size){ - size_traits &thist = this->priv_size_traits(); - size_traits &xt = x.priv_size_traits(); - BOOST_INTRUSIVE_INVARIANT_ASSERT(n == std::distance(start, end)); - node_algorithms::transfer(p.pointed_node(), start.pointed_node(), end.pointed_node()); - thist.set_size(thist.get_size() + n); - xt.set_size(xt.get_size() - n); - } - else{ - node_algorithms::transfer(p.pointed_node(), start.pointed_node(), end.pointed_node()); - } - } - } - - //! <b>Effects</b>: This function sorts the list *this according to std::less<value_type>. - //! The sort is stable, that is, the relative order of equivalent elements is preserved. - //! - //! <b>Throws</b>: If real_value_traits::node_traits::node - //! constructor throws (this does not happen with predefined Boost.Intrusive hooks) - //! or std::less<value_type> throws. Basic guarantee. - //! - //! <b>Notes</b>: Iterators and references are not invalidated. - //! - //! <b>Complexity</b>: The number of comparisons is approximately N log N, where N - //! is the list's size. - void sort() - { this->sort(std::less<value_type>()); } - - //! <b>Requires</b>: p must be a comparison function that induces a strict weak ordering - //! - //! <b>Effects</b>: This function sorts the list *this according to p. The sort is - //! stable, that is, the relative order of equivalent elements is preserved. - //! - //! <b>Throws</b>: If real_value_traits::node_traits::node - //! constructor throws (this does not happen with predefined Boost.Intrusive hooks) - //! or the predicate throws. Basic guarantee. - //! - //! <b>Notes</b>: This won't throw if list_base_hook<> or - //! list_member_hook are used. - //! Iterators and references are not invalidated. - //! - //! <b>Complexity</b>: The number of comparisons is approximately N log N, where N - //! is the list's size. - template<class Predicate> - void sort(Predicate p) - { - if(node_traits::get_next(this->get_root_node()) - != node_traits::get_previous(this->get_root_node())){ - list_impl carry(this->priv_value_traits()); - detail::array_initializer<list_impl, 64> counter(this->priv_value_traits()); - int fill = 0; - while(!this->empty()){ - carry.splice(carry.cbegin(), *this, this->cbegin()); - int i = 0; - while(i < fill && !counter[i].empty()) { - counter[i].merge(carry, p); - carry.swap(counter[i++]); - } - carry.swap(counter[i]); - if(i == fill) - ++fill; - } - for (int i = 1; i < fill; ++i) - counter[i].merge(counter[i-1], p); - this->swap(counter[fill-1]); - } - } - - //! <b>Effects</b>: This function removes all of x's elements and inserts them - //! in order into *this according to std::less<value_type>. The merge is stable; - //! that is, if an element from *this is equivalent to one from x, then the element - //! from *this will precede the one from x. - //! - //! <b>Throws</b>: If std::less<value_type> throws. Basic guarantee. - //! - //! <b>Complexity</b>: This function is linear time: it performs at most - //! size() + x.size() - 1 comparisons. - //! - //! <b>Note</b>: Iterators and references are not invalidated - void merge(list_impl& x) - { this->merge(x, std::less<value_type>()); } - - //! <b>Requires</b>: p must be a comparison function that induces a strict weak - //! ordering and both *this and x must be sorted according to that ordering - //! The lists x and *this must be distinct. - //! - //! <b>Effects</b>: This function removes all of x's elements and inserts them - //! in order into *this. The merge is stable; that is, if an element from *this is - //! equivalent to one from x, then the element from *this will precede the one from x. - //! - //! <b>Throws</b>: If the predicate throws. Basic guarantee. - //! - //! <b>Complexity</b>: This function is linear time: it performs at most - //! size() + x.size() - 1 comparisons. - //! - //! <b>Note</b>: Iterators and references are not invalidated. - template<class Predicate> - void merge(list_impl& x, Predicate p) - { - const_iterator e(this->cend()), ex(x.cend()); - const_iterator b(this->cbegin()); - while(!x.empty()){ - const_iterator ix(x.cbegin()); - while (b != e && !p(*ix, *b)){ - ++b; - } - if(b == e){ - //Now transfer the rest to the end of the container - this->splice(e, x); - break; - } - else{ - size_type n(0); - do{ - ++ix; ++n; - } while(ix != ex && p(*ix, *b)); - this->splice(b, x, x.begin(), ix, n); - } - } - } - - //! <b>Effects</b>: Reverses the order of elements in the list. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: This function is linear time. - //! - //! <b>Note</b>: Iterators and references are not invalidated - void reverse() - { node_algorithms::reverse(this->get_root_node()); } - - //! <b>Effects</b>: Removes all the elements that compare equal to value. - //! No destructors are called. - //! - //! <b>Throws</b>: If std::equal_to<value_type> throws. Basic guarantee. - //! - //! <b>Complexity</b>: Linear time. It performs exactly size() comparisons for equality. - //! - //! <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 remove(const_reference value) - { this->remove_if(detail::equal_to_value<const_reference>(value)); } - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! - //! <b>Effects</b>: Removes all the elements that compare equal to value. - //! Disposer::operator()(pointer) is called for every removed element. - //! - //! <b>Throws</b>: If std::equal_to<value_type> throws. Basic guarantee. - //! - //! <b>Complexity</b>: Linear time. It performs exactly size() comparisons for equality. - //! - //! <b>Note</b>: The relative order of elements that are not removed is unchanged, - //! and iterators to elements that are not removed remain valid. - template<class Disposer> - void remove_and_dispose(const_reference value, Disposer disposer) - { this->remove_and_dispose_if(detail::equal_to_value<const_reference>(value), disposer); } - - //! <b>Effects</b>: Removes all the elements for which a specified - //! predicate is satisfied. No destructors are called. - //! - //! <b>Throws</b>: If pred throws. Basic guarantee. - //! - //! <b>Complexity</b>: Linear time. It performs exactly size() calls to the predicate. - //! - //! <b>Note</b>: The relative order of elements that are not removed is unchanged, - //! and iterators to elements that are not removed remain valid. - template<class Pred> - void remove_if(Pred pred) - { this->remove_and_dispose_if(pred, detail::null_disposer()); } - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! - //! <b>Effects</b>: Removes all the elements for which a specified - //! predicate is satisfied. - //! Disposer::operator()(pointer) is called for every removed element. - //! - //! <b>Throws</b>: If pred throws. Basic guarantee. - //! - //! <b>Complexity</b>: Linear time. It performs exactly size() comparisons for equality. - //! - //! <b>Note</b>: The relative order of elements that are not removed is unchanged, - //! and iterators to elements that are not removed remain valid. - template<class Pred, class Disposer> - void remove_and_dispose_if(Pred pred, Disposer disposer) - { - const_iterator cur(this->cbegin()); - const_iterator last(this->cend()); - while(cur != last) { - if(pred(*cur)){ - cur = this->erase_and_dispose(cur, disposer); - } - else{ - ++cur; - } - } - } - - //! <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>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()); } - - //! <b>Effects</b>: Removes adjacent duplicate elements or adjacent - //! elements that satisfy some binary predicate from the list. - //! No destructors are called. - //! - //! <b>Throws</b>: If pred throws. Basic guarantee. - //! - //! <b>Complexity</b>: Linear time (size()-1 comparisons equality comparisons). - //! - //! <b>Note</b>: The relative order of elements that are not removed is unchanged, - //! and iterators to elements that are not removed remain valid. - template<class BinaryPredicate> - void unique(BinaryPredicate pred) - { this->unique_and_dispose(pred, detail::null_disposer()); } - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! - //! <b>Effects</b>: Removes adjacent duplicate elements or adjacent - //! 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>Complexity</b>: Linear time (size()-1) comparisons equality comparisons. - //! - //! <b>Note</b>: The relative order of elements that are not removed is unchanged, - //! 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); } - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! - //! <b>Effects</b>: Removes adjacent duplicate elements or adjacent - //! elements that satisfy some binary predicate from the list. - //! Disposer::operator()(pointer) is called for every removed element. - //! - //! <b>Throws</b>: If pred throws. Basic guarantee. - //! - //! <b>Complexity</b>: Linear time (size()-1) comparisons equality comparisons. - //! - //! <b>Note</b>: The relative order of elements that are not removed is unchanged, - //! and iterators to elements that are not removed remain valid. - template<class BinaryPredicate, class Disposer> - void unique_and_dispose(BinaryPredicate pred, Disposer disposer) - { - const_iterator itend(this->cend()); - const_iterator cur(this->cbegin()); - - if(cur != itend){ - const_iterator after(cur); - ++after; - while(after != itend){ - if(pred(*cur, *after)){ - after = this->erase_and_dispose(after, disposer); - } - else{ - cur = after; - ++after; - } - } - } - } - - //! <b>Requires</b>: value must be a reference to a value inserted in a list. - //! - //! <b>Effects</b>: This function returns a const_iterator pointing to the element - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant time. - //! - //! <b>Note</b>: Iterators and references are not invalidated. - //! This static function is available only if the <i>value traits</i> - //! is stateless. - static iterator s_iterator_to(reference value) - { - BOOST_STATIC_ASSERT((!stateful_value_traits)); - BOOST_INTRUSIVE_INVARIANT_ASSERT(!node_algorithms::inited(real_value_traits::to_node_ptr(value))); - return iterator(real_value_traits::to_node_ptr(value), 0); - } - - //! <b>Requires</b>: value must be a const reference to a value inserted in a list. - //! - //! <b>Effects</b>: This function returns an iterator pointing to the element. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant time. - //! - //! <b>Note</b>: Iterators and references are not invalidated. - //! This static function is available only if the <i>value traits</i> - //! is stateless. - static const_iterator s_iterator_to(const_reference value) - { - BOOST_STATIC_ASSERT((!stateful_value_traits)); - BOOST_INTRUSIVE_INVARIANT_ASSERT(!node_algorithms::inited(real_value_traits::to_node_ptr(const_cast<reference> (value)))); - return const_iterator(real_value_traits::to_node_ptr(const_cast<reference> (value)), 0); - } - - //! <b>Requires</b>: value must be a reference to a value inserted in a list. - //! - //! <b>Effects</b>: This function returns a const_iterator pointing to the element - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant time. - //! - //! <b>Note</b>: Iterators and references are not invalidated. - iterator iterator_to(reference value) - { - BOOST_INTRUSIVE_INVARIANT_ASSERT(!node_algorithms::inited(real_value_traits::to_node_ptr(value))); - return iterator(real_value_traits::to_node_ptr(value), this); - } - - //! <b>Requires</b>: value must be a const reference to a value inserted in a list. - //! - //! <b>Effects</b>: This function returns an iterator pointing to the element. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant time. - //! - //! <b>Note</b>: Iterators and references are not invalidated. - const_iterator iterator_to(const_reference value) const - { - BOOST_INTRUSIVE_INVARIANT_ASSERT(!node_algorithms::inited(real_value_traits::to_node_ptr(const_cast<reference> (value)))); - return const_iterator(real_value_traits::to_node_ptr(const_cast<reference> (value)), this); - } - - /// @cond - - private: - static list_impl &priv_container_from_end_iterator(const const_iterator &end_iterator) - { - root_plus_size *r = detail::parent_from_member<root_plus_size, node> - ( boost::intrusive::detail::to_raw_pointer(end_iterator.pointed_node()), &root_plus_size::root_); - data_t *d = detail::parent_from_member<data_t, root_plus_size> - ( r, &data_t::root_plus_size_); - list_impl *s = detail::parent_from_member<list_impl, data_t>(d, &list_impl::data_); - return *s; - } - /// @endcond -}; - -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -inline bool operator< -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -(const list_impl<T, Options...> &x, const list_impl<T, Options...> &y) -#else -(const list_impl<Config> &x, const list_impl<Config> &y) -#endif -{ return std::lexicographical_compare(x.begin(), x.end(), y.begin(), y.end()); } - -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -bool operator== -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -(const list_impl<T, Options...> &x, const list_impl<T, Options...> &y) -#else -(const list_impl<Config> &x, const list_impl<Config> &y) -#endif -{ - typedef list_impl<Config> list_type; - typedef typename list_type::const_iterator const_iterator; - const bool C = list_type::constant_time_size; - if(C && x.size() != y.size()){ - return false; - } - const_iterator end1 = x.end(); - - const_iterator i1 = x.begin(); - const_iterator i2 = y.begin(); - if(C){ - while (i1 != end1 && *i1 == *i2) { - ++i1; - ++i2; - } - return i1 == end1; - } - else{ - const_iterator end2 = y.end(); - while (i1 != end1 && i2 != end2 && *i1 == *i2) { - ++i1; - ++i2; - } - return i1 == end1 && i2 == end2; - } -} - -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -inline bool operator!= -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -(const list_impl<T, Options...> &x, const list_impl<T, Options...> &y) -#else -(const list_impl<Config> &x, const list_impl<Config> &y) -#endif -{ return !(x == y); } - -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -inline bool operator> -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -(const list_impl<T, Options...> &x, const list_impl<T, Options...> &y) -#else -(const list_impl<Config> &x, const list_impl<Config> &y) -#endif -{ return y < x; } - -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -inline bool operator<= -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -(const list_impl<T, Options...> &x, const list_impl<T, Options...> &y) -#else -(const list_impl<Config> &x, const list_impl<Config> &y) -#endif -{ return !(y < x); } - -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -inline bool operator>= -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -(const list_impl<T, Options...> &x, const list_impl<T, Options...> &y) -#else -(const list_impl<Config> &x, const list_impl<Config> &y) -#endif -{ return !(x < y); } - -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -inline void swap -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -(list_impl<T, Options...> &x, list_impl<T, Options...> &y) -#else -(list_impl<Config> &x, list_impl<Config> &y) -#endif -{ x.swap(y); } - -//! Helper metafunction to define a \c list that yields to the same type when the -//! same options (either explicitly or implicitly) are used. -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) || defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template<class T, class ...Options> -#else -template<class T, class O1 = none, class O2 = none, class O3 = none> -#endif -struct make_list -{ - /// @cond - typedef typename pack_options - < list_defaults<T>, - #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) - O1, O2, O3 - #else - Options... - #endif - >::type packed_options; - - typedef typename detail::get_value_traits - <T, typename packed_options::value_traits>::type value_traits; - - typedef list_impl - < - listopt - < value_traits - , typename packed_options::size_type - , packed_options::constant_time_size - > - > implementation_defined; - /// @endcond - typedef implementation_defined type; -}; - - -#ifndef BOOST_INTRUSIVE_DOXYGEN_INVOKED - -#if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template<class T, class O1, class O2, class O3> -#else -template<class T, class ...Options> -#endif -class list - : public make_list<T, - #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) - O1, O2, O3 - #else - Options... - #endif - >::type -{ - typedef typename make_list - <T, - #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) - O1, O2, O3 - #else - Options... - #endif - >::type Base; - typedef typename Base::real_value_traits real_value_traits; - //Assert if passed value traits are compatible with the type - BOOST_STATIC_ASSERT((detail::is_same<typename real_value_traits::value_type, T>::value)); - BOOST_MOVABLE_BUT_NOT_COPYABLE(list) - - public: - typedef typename Base::value_traits value_traits; - typedef typename Base::iterator iterator; - typedef typename Base::const_iterator const_iterator; - - list(const value_traits &v_traits = value_traits()) - : Base(v_traits) - {} - - template<class Iterator> - list(Iterator b, Iterator e, const value_traits &v_traits = value_traits()) - : Base(b, e, v_traits) - {} - - list(BOOST_RV_REF(list) x) - : Base(::boost::move(static_cast<Base&>(x))) - {} - - list& operator=(BOOST_RV_REF(list) x) - { this->Base::operator=(::boost::move(static_cast<Base&>(x))); return *this; } - - static list &container_from_end_iterator(iterator end_iterator) - { return static_cast<list &>(Base::container_from_end_iterator(end_iterator)); } - - static const list &container_from_end_iterator(const_iterator end_iterator) - { return static_cast<const list &>(Base::container_from_end_iterator(end_iterator)); } -}; - -#endif - -} //namespace intrusive -} //namespace boost - -#include <boost/intrusive/detail/config_end.hpp> - -#endif //BOOST_INTRUSIVE_LIST_HPP diff --git a/src/third_party/boost/boost/intrusive/list_hook.hpp b/src/third_party/boost/boost/intrusive/list_hook.hpp deleted file mode 100644 index ed93434a3fe..00000000000 --- a/src/third_party/boost/boost/intrusive/list_hook.hpp +++ /dev/null @@ -1,290 +0,0 @@ -///////////////////////////////////////////////////////////////////////////// -// -// (C) Copyright Olaf Krzikalla 2004-2006. -// (C) Copyright Ion Gaztanaga 2006-2009 -// -// Distributed under the Boost Software License, Version 1.0. -// (See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) -// -// See http://www.boost.org/libs/intrusive for documentation. -// -///////////////////////////////////////////////////////////////////////////// - -#ifndef BOOST_INTRUSIVE_LIST_HOOK_HPP -#define BOOST_INTRUSIVE_LIST_HOOK_HPP - -#include <boost/intrusive/detail/config_begin.hpp> -#include <boost/intrusive/intrusive_fwd.hpp> -#include <boost/intrusive/detail/utilities.hpp> -#include <boost/intrusive/detail/list_node.hpp> -#include <boost/intrusive/circular_list_algorithms.hpp> -#include <boost/intrusive/options.hpp> -#include <boost/intrusive/detail/generic_hook.hpp> - -namespace boost { -namespace intrusive { - -/// @cond -template<class VoidPointer> -struct get_list_node_algo -{ - typedef circular_list_algorithms<list_node_traits<VoidPointer> > type; -}; -/// @endcond - -//! Helper metafunction to define a \c \c list_base_hook that yields to the same -//! type when the same options (either explicitly or implicitly) are used. -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) || defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template<class ...Options> -#else -template<class O1 = none, class O2 = none, class O3 = none> -#endif -struct make_list_base_hook -{ - /// @cond - typedef typename pack_options - < hook_defaults, - #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) - O1, O2, O3 - #else - Options... - #endif - >::type packed_options; - - typedef detail::generic_hook - < get_list_node_algo<typename packed_options::void_pointer> - , typename packed_options::tag - , packed_options::link_mode - , detail::ListBaseHook - > implementation_defined; - /// @endcond - typedef implementation_defined type; -}; - -//! Derive a class from this hook in order to store objects of that class -//! in an list. -//! -//! The hook admits the following options: \c tag<>, \c void_pointer<> and -//! \c link_mode<>. -//! -//! \c tag<> defines a tag to identify the node. -//! The same tag value can be used in different classes, but if a class is -//! derived from more than one \c list_base_hook, then each \c list_base_hook needs its -//! unique tag. -//! -//! \c link_mode<> will specify the linking mode of the hook (\c normal_link, -//! \c auto_unlink or \c safe_link). -//! -//! \c void_pointer<> is the pointer type that will be used internally in the hook -//! and the the container configured to use this hook. -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) || defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template<class ...Options> -#else -template<class O1, class O2, class O3> -#endif -class list_base_hook - : public make_list_base_hook - #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) - <O1, O2, O3> - #else - <Options...> - #endif - ::type -{ - #if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) - public: - //! <b>Effects</b>: If link_mode is \c auto_unlink or \c safe_link - //! initializes the node to an unlinked state. - //! - //! <b>Throws</b>: Nothing. - list_base_hook(); - - //! <b>Effects</b>: If link_mode is \c auto_unlink or \c safe_link - //! initializes the node to an unlinked state. The argument is ignored. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Rationale</b>: Providing a copy-constructor - //! makes classes using the hook STL-compliant without forcing the - //! user to do some additional work. \c swap can be used to emulate - //! move-semantics. - list_base_hook(const list_base_hook& ); - - //! <b>Effects</b>: Empty function. The argument is ignored. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Rationale</b>: Providing an assignment operator - //! makes classes using the hook STL-compliant without forcing the - //! user to do some additional work. \c swap can be used to emulate - //! move-semantics. - list_base_hook& operator=(const list_base_hook& ); - - //! <b>Effects</b>: If link_mode is \c normal_link, the destructor does - //! nothing (ie. no code is generated). If link_mode is \c safe_link and the - //! object is stored in an list an assertion is raised. If link_mode is - //! \c auto_unlink and \c is_linked() is true, the node is unlinked. - //! - //! <b>Throws</b>: Nothing. - ~list_base_hook(); - - //! <b>Effects</b>: Swapping two nodes swaps the position of the elements - //! related to those nodes in one or two containers. That is, if the node - //! this is part of the element e1, the node x is part of the element e2 - //! and both elements are included in the containers s1 and s2, then after - //! the swap-operation e1 is in s2 at the position of e2 and e2 is in s1 - //! at the position of e1. If one element is not in a container, then - //! after the swap-operation the other element is not in a container. - //! Iterators to e1 and e2 related to those nodes are invalidated. - //! - //! <b>Complexity</b>: Constant - //! - //! <b>Throws</b>: Nothing. - void swap_nodes(list_base_hook &other); - - //! <b>Precondition</b>: link_mode must be \c safe_link or \c auto_unlink. - //! - //! <b>Returns</b>: true, if the node belongs to a container, false - //! otherwise. This function can be used to test whether \c list::iterator_to - //! will return a valid iterator. - //! - //! <b>Complexity</b>: Constant - bool is_linked() const; - - //! <b>Effects</b>: Removes the node if it's inserted in a container. - //! This function is only allowed if link_mode is \c auto_unlink. - //! - //! <b>Throws</b>: Nothing. - void unlink(); - #endif -}; - -//! Helper metafunction to define a \c \c list_member_hook that yields to the same -//! type when the same options (either explicitly or implicitly) are used. -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) || defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template<class ...Options> -#else -template<class O1 = none, class O2 = none, class O3 = none> -#endif -struct make_list_member_hook -{ - /// @cond - typedef typename pack_options - < hook_defaults, - #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) - O1, O2, O3 - #else - Options... - #endif - >::type packed_options; - - typedef detail::generic_hook - < get_list_node_algo<typename packed_options::void_pointer> - , member_tag - , packed_options::link_mode - , detail::NoBaseHook - > implementation_defined; - /// @endcond - typedef implementation_defined type; -}; - -//! Store this hook in a class to be inserted -//! in an list. -//! -//! The hook admits the following options: \c void_pointer<> and -//! \c link_mode<>. -//! -//! \c link_mode<> will specify the linking mode of the hook (\c normal_link, -//! \c auto_unlink or \c safe_link). -//! -//! \c void_pointer<> is the pointer type that will be used internally in the hook -//! and the the container configured to use this hook. -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) || defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template<class ...Options> -#else -template<class O1, class O2, class O3> -#endif -class list_member_hook - : public make_list_member_hook - #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) - <O1, O2, O3> - #else - <Options...> - #endif - ::type -{ - #if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) - public: - //! <b>Effects</b>: If link_mode is \c auto_unlink or \c safe_link - //! initializes the node to an unlinked state. - //! - //! <b>Throws</b>: Nothing. - list_member_hook(); - - //! <b>Effects</b>: If link_mode is \c auto_unlink or \c safe_link - //! initializes the node to an unlinked state. The argument is ignored. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Rationale</b>: Providing a copy-constructor - //! makes classes using the hook STL-compliant without forcing the - //! user to do some additional work. \c swap can be used to emulate - //! move-semantics. - list_member_hook(const list_member_hook& ); - - //! <b>Effects</b>: Empty function. The argument is ignored. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Rationale</b>: Providing an assignment operator - //! makes classes using the hook STL-compliant without forcing the - //! user to do some additional work. \c swap can be used to emulate - //! move-semantics. - list_member_hook& operator=(const list_member_hook& ); - - //! <b>Effects</b>: If link_mode is \c normal_link, the destructor does - //! nothing (ie. no code is generated). If link_mode is \c safe_link and the - //! object is stored in an list an assertion is raised. If link_mode is - //! \c auto_unlink and \c is_linked() is true, the node is unlinked. - //! - //! <b>Throws</b>: Nothing. - ~list_member_hook(); - - //! <b>Effects</b>: Swapping two nodes swaps the position of the elements - //! related to those nodes in one or two containers. That is, if the node - //! this is part of the element e1, the node x is part of the element e2 - //! and both elements are included in the containers s1 and s2, then after - //! the swap-operation e1 is in s2 at the position of e2 and e2 is in s1 - //! at the position of e1. If one element is not in a container, then - //! after the swap-operation the other element is not in a container. - //! Iterators to e1 and e2 related to those nodes are invalidated. - //! - //! <b>Complexity</b>: Constant - //! - //! <b>Throws</b>: Nothing. - void swap_nodes(list_member_hook &other); - - //! <b>Precondition</b>: link_mode must be \c safe_link or \c auto_unlink. - //! - //! <b>Returns</b>: true, if the node belongs to a container, false - //! otherwise. This function can be used to test whether \c list::iterator_to - //! will return a valid iterator. - //! - //! <b>Complexity</b>: Constant - bool is_linked() const; - - //! <b>Effects</b>: Removes the node if it's inserted in a container. - //! This function is only allowed if link_mode is \c auto_unlink. - //! - //! <b>Throws</b>: Nothing. - void unlink(); - #endif -}; - -} //namespace intrusive -} //namespace boost - -#include <boost/intrusive/detail/config_end.hpp> - -#endif //BOOST_INTRUSIVE_LIST_HOOK_HPP diff --git a/src/third_party/boost/boost/intrusive/member_value_traits.hpp b/src/third_party/boost/boost/intrusive/member_value_traits.hpp deleted file mode 100644 index 378c4e05b82..00000000000 --- a/src/third_party/boost/boost/intrusive/member_value_traits.hpp +++ /dev/null @@ -1,70 +0,0 @@ -///////////////////////////////////////////////////////////////////////////// -// -// (C) Copyright Ion Gaztanaga 2006-2009 -// -// Distributed under the Boost Software License, Version 1.0. -// (See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) -// -// See http://www.boost.org/libs/intrusive for documentation. -// -///////////////////////////////////////////////////////////////////////////// - -#ifndef BOOST_INTRUSIVE_MEMBER_VALUE_TRAITS_HPP -#define BOOST_INTRUSIVE_MEMBER_VALUE_TRAITS_HPP - -#include <boost/intrusive/link_mode.hpp> -#include <iterator> -#include <boost/intrusive/detail/parent_from_member.hpp> -#include <boost/intrusive/pointer_traits.hpp> - -namespace boost { -namespace intrusive { - -//!This value traits template is used to create value traits -//!from user defined node traits where value_traits::value_type will -//!store a node_traits::node -template< class T, class NodeTraits - , typename NodeTraits::node T::* PtrToMember - , link_mode_type LinkMode = safe_link> -struct member_value_traits -{ - public: - typedef NodeTraits node_traits; - typedef T value_type; - typedef typename node_traits::node node; - typedef typename node_traits::node_ptr node_ptr; - typedef typename node_traits::const_node_ptr const_node_ptr; - typedef typename pointer_traits<node_ptr>::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 value_type & reference; - typedef const value_type & const_reference; - static const link_mode_type link_mode = LinkMode; - - static node_ptr to_node_ptr(reference value) - { return node_ptr(&(value.*PtrToMember)); } - - static const_node_ptr to_node_ptr(const_reference value) - { return node_ptr(&(value.*PtrToMember)); } - - static pointer to_value_ptr(const node_ptr &n) - { - return pointer(detail::parent_from_member<value_type, node> - (boost::intrusive::detail::to_raw_pointer(n), PtrToMember)); - } - - static const_pointer to_value_ptr(const const_node_ptr &n) - { - return pointer(detail::parent_from_member<value_type, node> - (boost::intrusive::detail::to_raw_pointer(n), PtrToMember)); - } -}; - -} //namespace intrusive -} //namespace boost - -#endif //BOOST_INTRUSIVE_MEMBER_VALUE_TRAITS_HPP diff --git a/src/third_party/boost/boost/intrusive/options.hpp b/src/third_party/boost/boost/intrusive/options.hpp deleted file mode 100644 index 4cdeccdeaa7..00000000000 --- a/src/third_party/boost/boost/intrusive/options.hpp +++ /dev/null @@ -1,812 +0,0 @@ -///////////////////////////////////////////////////////////////////////////// -// -// (C) Copyright Ion Gaztanaga 2007-2009 -// -// Distributed under the Boost Software License, Version 1.0. -// (See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) -// -// See http://www.boost.org/libs/intrusive for documentation. -// -///////////////////////////////////////////////////////////////////////////// - -#ifndef BOOST_INTRUSIVE_OPTIONS_HPP -#define BOOST_INTRUSIVE_OPTIONS_HPP - -#include <boost/intrusive/detail/config_begin.hpp> -#include <boost/intrusive/intrusive_fwd.hpp> -#include <boost/intrusive/link_mode.hpp> -#include <boost/intrusive/detail/mpl.hpp> -#include <boost/intrusive/detail/utilities.hpp> -#include <boost/static_assert.hpp> - - -namespace boost { -namespace intrusive { - -/// @cond - -struct default_tag; -struct member_tag; - -namespace detail{ - -struct default_hook_tag{}; - -#define BOOST_INTRUSIVE_DEFAULT_HOOK_MARKER_DEFINITION(BOOST_INTRUSIVE_DEFAULT_HOOK_MARKER) \ -struct BOOST_INTRUSIVE_DEFAULT_HOOK_MARKER : public default_hook_tag\ -{\ - template <class T>\ - struct apply\ - { typedef typename T::BOOST_INTRUSIVE_DEFAULT_HOOK_MARKER type; };\ -}\ - -BOOST_INTRUSIVE_DEFAULT_HOOK_MARKER_DEFINITION(default_list_hook); -BOOST_INTRUSIVE_DEFAULT_HOOK_MARKER_DEFINITION(default_slist_hook); -BOOST_INTRUSIVE_DEFAULT_HOOK_MARKER_DEFINITION(default_set_hook); -BOOST_INTRUSIVE_DEFAULT_HOOK_MARKER_DEFINITION(default_uset_hook); -BOOST_INTRUSIVE_DEFAULT_HOOK_MARKER_DEFINITION(default_avl_set_hook); -BOOST_INTRUSIVE_DEFAULT_HOOK_MARKER_DEFINITION(default_splay_set_hook); -BOOST_INTRUSIVE_DEFAULT_HOOK_MARKER_DEFINITION(default_bs_set_hook); - -#undef BOOST_INTRUSIVE_DEFAULT_HOOK_MARKER_DEFINITION - -template <class ValueTraits> -struct eval_value_traits -{ - typedef typename ValueTraits::value_traits type; -}; - -template <class T> -struct external_bucket_traits_is_true -{ - static const bool value = external_bucket_traits_bool<T>::value == 3; -}; - -template <class BucketTraits> -struct eval_bucket_traits -{ - typedef typename BucketTraits::bucket_traits type; -}; - -template <class T, class BaseHook> -struct concrete_hook_base_value_traits -{ - typedef typename BaseHook::boost_intrusive_tags tags; - typedef detail::base_hook_traits - < T - , typename tags::node_traits - , tags::link_mode - , typename tags::tag - , tags::hook_type> type; -}; - -template <class BaseHook> -struct concrete_hook_base_node_traits -{ typedef typename BaseHook::boost_intrusive_tags::node_traits type; }; - -template <class T, class BaseHook> -struct any_hook_base_value_traits -{ - typedef typename BaseHook::boost_intrusive_tags tags; - typedef detail::base_hook_traits - < T - , typename BaseHook::node_traits - , tags::link_mode - , typename tags::tag - , tags::hook_type> type; -}; - -template <class BaseHook> -struct any_hook_base_node_traits -{ typedef typename BaseHook::node_traits type; }; - -template<class T, class BaseHook> -struct get_base_value_traits -{ - typedef typename detail::eval_if_c - < internal_any_hook_bool_is_true<BaseHook>::value - , any_hook_base_value_traits<T, BaseHook> - , concrete_hook_base_value_traits<T, BaseHook> - >::type type; -}; - -template<class BaseHook> -struct get_base_node_traits -{ - typedef typename detail::eval_if_c - < internal_any_hook_bool_is_true<BaseHook>::value - , any_hook_base_node_traits<BaseHook> - , concrete_hook_base_node_traits<BaseHook> - >::type type; -}; - -template<class T, class MemberHook> -struct get_member_value_traits -{ - typedef typename MemberHook::member_value_traits type; -}; - -template<class MemberHook> -struct get_member_node_traits -{ - typedef typename MemberHook::member_value_traits::node_traits type; -}; - -template<class T, class SupposedValueTraits> -struct get_value_traits -{ - typedef typename detail::eval_if_c - <detail::is_convertible<SupposedValueTraits*, detail::default_hook_tag*>::value - ,detail::apply<SupposedValueTraits, T> - ,detail::identity<SupposedValueTraits> - >::type supposed_value_traits; - //...if it's a default hook - typedef typename detail::eval_if_c - < internal_base_hook_bool_is_true<supposed_value_traits>::value - //...get it's internal value traits using - //the provided T value type. - , get_base_value_traits<T, supposed_value_traits> - //...else use it's internal value traits tag - //(member hooks and custom value traits are in this group) - , detail::eval_if_c - < internal_member_value_traits<supposed_value_traits>::value - , get_member_value_traits<T, supposed_value_traits> - , detail::identity<supposed_value_traits> - > - >::type type; -}; - -template<class ValueTraits> -struct get_explicit_node_traits -{ - typedef typename ValueTraits::node_traits type; -}; - -template<class SupposedValueTraits> -struct get_node_traits -{ - typedef SupposedValueTraits supposed_value_traits; - //...if it's a base hook - typedef typename detail::eval_if_c - < internal_base_hook_bool_is_true<supposed_value_traits>::value - //...get it's internal value traits using - //the provided T value type. - , get_base_node_traits<supposed_value_traits> - //...else use it's internal value traits tag - //(member hooks and custom value traits are in this group) - , detail::eval_if_c - < internal_member_value_traits<supposed_value_traits>::value - , get_member_node_traits<supposed_value_traits> - , get_explicit_node_traits<supposed_value_traits> - > - >::type type; -}; - -} //namespace detail{ - - -//!This type indicates that no option is being used -//!and that the default options should be used -struct none -{ - template<class Base> - struct pack : Base - { }; -}; - -/// @endcond - -//!This option setter specifies if the intrusive -//!container stores its size as a member to -//!obtain constant-time size() member. -template<bool Enabled> -struct constant_time_size -{ -/// @cond - template<class Base> - struct pack : Base - { - static const bool constant_time_size = Enabled; - }; -/// @endcond -}; - -//!This option setter specifies the type that -//!the container will use to store its size. -template<class SizeType> -struct size_type -{ -/// @cond - template<class Base> - struct pack : Base - { - typedef SizeType size_type; - }; -/// @endcond -}; - -//!This option setter specifies the strict weak ordering -//!comparison functor for the value type -template<class Compare> -struct compare -{ -/// @cond - template<class Base> - struct pack : Base - { - typedef Compare compare; - }; -/// @endcond -}; - -//!This option setter for scapegoat containers specifies if -//!the intrusive scapegoat container should use a non-variable -//!alpha value that does not need floating-point operations. -//! -//!If activated, the fixed alpha value is 1/sqrt(2). This -//!option also saves some space in the container since -//!the alpha value and some additional data does not need -//!to be stored in the container. -//! -//!If the user only needs an alpha value near 1/sqrt(2), this -//!option also improves performance since avoids logarithm -//!and division operations when rebalancing the tree. -template<bool Enabled> -struct floating_point -{ -/// @cond - template<class Base> - struct pack : Base - { - static const bool floating_point = Enabled; - }; -/// @endcond -}; - -//!This option setter specifies the equality -//!functor for the value type -template<class Equal> -struct equal -{ -/// @cond - template<class Base> - struct pack : Base - { - typedef Equal equal; - }; -/// @endcond -}; - -//!This option setter specifies the equality -//!functor for the value type -template<class Priority> -struct priority -{ -/// @cond - template<class Base> - struct pack : Base - { - typedef Priority priority; - }; -/// @endcond -}; - -//!This option setter specifies the hash -//!functor for the value type -template<class Hash> -struct hash -{ -/// @cond - template<class Base> - struct pack : Base - { - typedef Hash hash; - }; -/// @endcond -}; - -//!This option setter specifies the relationship between the type -//!to be managed by the container (the value type) and the node to be -//!used in the node algorithms. It also specifies the linking policy. -template<typename ValueTraits> -struct value_traits -{ -/// @cond - template<class Base> - struct pack : Base - { - typedef ValueTraits value_traits; - }; -/// @endcond -}; - -//!This option setter specifies the member hook the -//!container must use. -template< typename Parent - , typename MemberHook - , MemberHook Parent::* PtrToMember> -struct member_hook -{ -/// @cond - typedef detail::member_hook_traits - < Parent - , MemberHook - , PtrToMember - > member_value_traits; - template<class Base> - struct pack : Base - { - typedef member_value_traits value_traits; - }; -/// @endcond -}; - - -//!This option setter specifies the function object that will -//!be used to convert between values to be inserted in a container -//!and the hook to be used for that purpose. -template< typename Functor> -struct function_hook -{ -/// @cond - typedef detail::function_hook_traits - <Functor> function_value_traits; - template<class Base> - struct pack : Base - { - typedef function_value_traits value_traits; - }; -/// @endcond -}; - - -//!This option setter specifies that the container -//!must use the specified base hook -template<typename BaseHook> -struct base_hook -{ -/// @cond - template<class Base> - struct pack : Base - { - typedef BaseHook value_traits; - }; -/// @endcond -}; - -//!This option setter specifies the type of -//!a void pointer. This will instruct the hook -//!to use this type of pointer instead of the -//!default one -template<class VoidPointer> -struct void_pointer -{ -/// @cond - template<class Base> - struct pack : Base - { - typedef VoidPointer void_pointer; - }; -/// @endcond -}; - -//!This option setter specifies the type of -//!the tag of a base hook. A type cannot have two -//!base hooks of the same type, so a tag can be used -//!to differentiate two base hooks with otherwise same type -template<class Tag> -struct tag -{ -/// @cond - template<class Base> - struct pack : Base - { - typedef Tag tag; - }; -/// @endcond -}; - -//!This option setter specifies the link mode -//!(normal_link, safe_link or auto_unlink) -template<link_mode_type LinkType> -struct link_mode -{ -/// @cond - template<class Base> - struct pack : Base - { - static const link_mode_type link_mode = LinkType; - }; -/// @endcond -}; - -//!This option setter specifies if the hook -//!should be optimized for size instead of for speed. -template<bool Enabled> -struct optimize_size -{ -/// @cond - template<class Base> - struct pack : Base - { - static const bool optimize_size = Enabled; - }; -/// @endcond -}; - -//!This option setter specifies if the list container should -//!use a linear implementation instead of a circular one. -template<bool Enabled> -struct linear -{ -/// @cond - template<class Base> - struct pack : Base - { - static const bool linear = Enabled; - }; -/// @endcond -}; - -//!This option setter specifies if the list container should -//!use a linear implementation instead of a circular one. -template<bool Enabled> -struct cache_last -{ -/// @cond - template<class Base> - struct pack : Base - { - static const bool cache_last = Enabled; - }; -/// @endcond -}; - -//!This option setter specifies the bucket traits -//!class for unordered associative containers. When this option is specified, -//!instead of using the default bucket traits, a user defined holder will be defined -template<class BucketTraits> -struct bucket_traits -{ -/// @cond - template<class Base> - struct pack : Base - { - typedef BucketTraits bucket_traits; - }; -/// @endcond -}; - -//!This option setter specifies if the unordered hook -//!should offer room to store the hash value. -//!Storing the hash in the hook will speed up rehashing -//!processes in applications where rehashing is frequent, -//!rehashing might throw or the value is heavy to hash. -template<bool Enabled> -struct store_hash -{ -/// @cond - template<class Base> - struct pack : Base - { - static const bool store_hash = Enabled; - }; -/// @endcond -}; - -//!This option setter specifies if the unordered hook -//!should offer room to store another link to another node -//!with the same key. -//!Storing this link will speed up lookups and insertions on -//!unordered_multiset containers with a great number of elements -//!with the same key. -template<bool Enabled> -struct optimize_multikey -{ -/// @cond - template<class Base> - struct pack : Base - { - static const bool optimize_multikey = Enabled; - }; -/// @endcond -}; - -//!This option setter specifies if the bucket array will be always power of two. -//!This allows using masks instead of the default modulo operation to determine -//!the bucket number from the hash value, leading to better performance. -//!In debug mode, if power of two buckets mode is activated, the bucket length -//!will be checked to through assertions to assure the bucket length is power of two. -template<bool Enabled> -struct power_2_buckets -{ -/// @cond - template<class Base> - struct pack : Base - { - static const bool power_2_buckets = Enabled; - }; -/// @endcond -}; - -//!This option setter specifies if the container will cache a pointer to the first -//!non-empty bucket so that begin() is always constant-time. -//!This is specially helpful when we can have containers with a few elements -//!but with big bucket arrays (that is, hashtables with low load factors). -template<bool Enabled> -struct cache_begin -{ -/// @cond - template<class Base> - struct pack : Base - { - static const bool cache_begin = Enabled; - }; -/// @endcond -}; - - -//!This option setter specifies if the container will compare the hash value -//!before comparing objects. This option can't be specified if store_hash<> -//!is not true. -//!This is specially helpful when we have containers with a high load factor. -//!and the comparison function is much more expensive that comparing already -//!stored hash values. -template<bool Enabled> -struct compare_hash -{ -/// @cond - template<class Base> - struct pack : Base - { - static const bool compare_hash = Enabled; - }; -/// @endcond -}; - -//!This option setter specifies if the hash container will use incremental -//!hashing. With incremental hashing the cost of hash table expansion is spread -//!out across each hash table insertion operation, as opposed to be incurred all at once. -//!Therefore linear hashing is well suited for interactive applications or real-time -//!appplications where the worst-case insertion time of non-incremental hash containers -//!(rehashing the whole bucket array) is not admisible. -template<bool Enabled> -struct incremental -{ - /// @cond - template<class Base> - struct pack : Base - { - static const bool incremental = Enabled; - }; - /// @endcond -}; - -/// @cond - -//To-do: pass to variadic templates -#if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) - -template<class Prev, class Next> -struct do_pack -{ - //Use "pack" member template to pack options - typedef typename Next::template pack<Prev> type; -}; - -template<class Prev> -struct do_pack<Prev, none> -{ - //Avoid packing "none" to shorten template names - typedef Prev type; -}; - -template - < class DefaultOptions - , class O1 = none - , class O2 = none - , class O3 = none - , class O4 = none - , class O5 = none - , class O6 = none - , class O7 = none - , class O8 = none - , class O9 = none - , class O10 = none - , class O11 = none - > -struct pack_options -{ - // join options - typedef - typename do_pack - < typename do_pack - < typename do_pack - < typename do_pack - < typename do_pack - < typename do_pack - < typename do_pack - < typename do_pack - < typename do_pack - < typename do_pack - < typename do_pack - < DefaultOptions - , O1 - >::type - , O2 - >::type - , O3 - >::type - , O4 - >::type - , O5 - >::type - , O6 - >::type - , O7 - >::type - , O8 - >::type - , O9 - >::type - , O10 - >::type - , O11 - >::type - type; -}; -#else - -//index_tuple -template<int... Indexes> -struct index_tuple{}; - -//build_number_seq -template<std::size_t Num, typename Tuple = index_tuple<> > -struct build_number_seq; - -template<std::size_t Num, int... Indexes> -struct build_number_seq<Num, index_tuple<Indexes...> > - : build_number_seq<Num - 1, index_tuple<Indexes..., sizeof...(Indexes)> > -{}; - -template<int... Indexes> -struct build_number_seq<0, index_tuple<Indexes...> > -{ typedef index_tuple<Indexes...> type; }; - -template<class ...Types> -struct typelist -{}; - -//invert_typelist -template<class T> -struct invert_typelist; - -template<int I, typename Tuple> -struct typelist_element; - -template<int I, typename Head, typename... Tail> -struct typelist_element<I, typelist<Head, Tail...> > -{ - typedef typename typelist_element<I-1, typelist<Tail...> >::type type; -}; - -template<typename Head, typename... Tail> -struct typelist_element<0, typelist<Head, Tail...> > -{ - typedef Head type; -}; - -template<int ...Ints, class ...Types> -typelist<typename typelist_element<(sizeof...(Types) - 1) - Ints, typelist<Types...> >::type...> - inverted_typelist(index_tuple<Ints...>, typelist<Types...>) -{ - return typelist<typename typelist_element<(sizeof...(Types) - 1) - Ints, typelist<Types...> >::type...>(); -} - -//sizeof_typelist -template<class Typelist> -struct sizeof_typelist; - -template<class ...Types> -struct sizeof_typelist< typelist<Types...> > -{ - static const std::size_t value = sizeof...(Types); -}; - -//invert_typelist_impl -template<class Typelist, class Indexes> -struct invert_typelist_impl; - - -template<class Typelist, int ...Ints> -struct invert_typelist_impl< Typelist, index_tuple<Ints...> > -{ - static const std::size_t last_idx = sizeof_typelist<Typelist>::value - 1; - typedef typelist - <typename typelist_element<last_idx - Ints, Typelist>::type...> type; -}; - -template<class Typelist, int Int> -struct invert_typelist_impl< Typelist, index_tuple<Int> > -{ - typedef Typelist type; -}; - -template<class Typelist> -struct invert_typelist_impl< Typelist, index_tuple<> > -{ - typedef Typelist type; -}; - -//invert_typelist -template<class Typelist> -struct invert_typelist; - -template<class ...Types> -struct invert_typelist< typelist<Types...> > -{ - typedef typelist<Types...> typelist_t; - typedef typename build_number_seq<sizeof...(Types)>::type indexes_t; - typedef typename invert_typelist_impl<typelist_t, indexes_t>::type type; -}; - -//Do pack -template<class Typelist> -struct do_pack; - -template<> -struct do_pack<typelist<> >; - -template<class Prev> -struct do_pack<typelist<Prev> > -{ - typedef Prev type; -}; - -template<class Prev, class Last> -struct do_pack<typelist<Prev, Last> > -{ - typedef typename Prev::template pack<Last> type; -}; - -template<class Prev, class ...Others> -struct do_pack<typelist<Prev, Others...> > -{ - typedef typename Prev::template pack - <typename do_pack<typelist<Others...> >::type> type; -}; - - -template<class ...Options> -struct pack_options -{ - typedef typelist<Options...> typelist_t; - typedef typename invert_typelist<typelist_t>::type inverted_typelist; - typedef typename do_pack<inverted_typelist>::type type; -}; - -#endif - -struct hook_defaults - : public pack_options - < none - , void_pointer<void*> - , link_mode<safe_link> - , tag<default_tag> - , optimize_size<false> - , store_hash<false> - , linear<false> - , optimize_multikey<false> - >::type -{}; - -/// @endcond - -} //namespace intrusive { -} //namespace boost { - -#include <boost/intrusive/detail/config_end.hpp> - -#endif //#ifndef BOOST_INTRUSIVE_OPTIONS_HPP diff --git a/src/third_party/boost/boost/intrusive/parent_from_member.hpp b/src/third_party/boost/boost/intrusive/parent_from_member.hpp deleted file mode 100644 index 882c0735319..00000000000 --- a/src/third_party/boost/boost/intrusive/parent_from_member.hpp +++ /dev/null @@ -1,42 +0,0 @@ -///////////////////////////////////////////////////////////////////////////// -// -// (C) Copyright Ion Gaztanaga 2010-2010 -// -// Distributed under the Boost Software License, Version 1.0. -// (See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) -// -// See http://www.boost.org/libs/intrusive for documentation. -// -///////////////////////////////////////////////////////////////////////////// -#ifndef BOOST_INTRUSIVE_GET_PARENT_FROM_MEMBER_HPP -#define BOOST_INTRUSIVE_GET_PARENT_FROM_MEMBER_HPP - -#include <boost/intrusive/detail/config_begin.hpp> -#include <boost/intrusive/detail/parent_from_member.hpp> - -namespace boost { -namespace intrusive { - -//! Given a pointer to a member and its corresponding pointer to data member, -//! this function returns the pointer of the parent containing that member. -//! Note: this function does not work with pointer to members that rely on -//! virtual inheritance. -template<class Parent, class Member> -inline Parent *get_parent_from_member(Member *member, const Member Parent::* ptr_to_member) -{ return ::boost::intrusive::detail::parent_from_member(member, ptr_to_member); } - -//! Given a const pointer to a member and its corresponding const pointer to data member, -//! this function returns the const pointer of the parent containing that member. -//! Note: this function does not work with pointer to members that rely on -//! virtual inheritance. -template<class Parent, class Member> -inline const Parent *get_parent_from_member(const Member *member, const Member Parent::* ptr_to_member) -{ return ::boost::intrusive::detail::parent_from_member(member, ptr_to_member); } - -} //namespace intrusive { -} //namespace boost { - -#include <boost/intrusive/detail/config_end.hpp> - -#endif //#ifndef BOOST_INTRUSIVE_GET_PARENT_FROM_MEMBER_HPP diff --git a/src/third_party/boost/boost/intrusive/pointer_plus_bits.hpp b/src/third_party/boost/boost/intrusive/pointer_plus_bits.hpp deleted file mode 100644 index 10b2fe0eb93..00000000000 --- a/src/third_party/boost/boost/intrusive/pointer_plus_bits.hpp +++ /dev/null @@ -1,82 +0,0 @@ -///////////////////////////////////////////////////////////////////////////// -// -// (C) Copyright Ion Gaztanaga 2007-2009 -// -// Distributed under the Boost Software License, Version 1.0. -// (See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) -// -// See http://www.boost.org/libs/intrusive for documentation. -// -///////////////////////////////////////////////////////////////////////////// - -#ifndef BOOST_INTRUSIVE_POINTER_PLUS_BITS_HPP -#define BOOST_INTRUSIVE_POINTER_PLUS_BITS_HPP - -#include <boost/intrusive/detail/mpl.hpp> //ls_zeros -#include <boost/intrusive/detail/assert.hpp> //BOOST_INTRUSIVE_INVARIANT_ASSERT - -namespace boost { -namespace intrusive { - -//!This trait class is used to know if a pointer -//!can embed extra bits of information if -//!it's going to be used to point to objects -//!with an alignment of "Alignment" bytes. -template<class VoidPointer, std::size_t Alignment> -struct max_pointer_plus_bits -{ - static const std::size_t value = 0; -}; - -//!This is a specialization for raw pointers. -//!Raw pointers can embed extra bits in the lower bits -//!if the alignment is multiple of 2pow(NumBits). -template<std::size_t Alignment> -struct max_pointer_plus_bits<void*, Alignment> -{ - static const std::size_t value = detail::ls_zeros<Alignment>::value; -}; - -//!This is class that is supposed to have static methods -//!to embed extra bits of information in a pointer. -//!This is a declaration and there is no default implementation, -//!because operations to embed the bits change with every pointer type. -//! -//!An implementation that detects that a pointer type whose -//!has_pointer_plus_bits<>::value is non-zero can make use of these -//!operations to embed the bits in the pointer. -template<class Pointer, std::size_t NumBits> -struct pointer_plus_bits; - -//!This is the specialization to embed extra bits of information -//!in a raw pointer. The extra bits are stored in the lower bits of the pointer. -template<class T, std::size_t NumBits> -struct pointer_plus_bits<T*, NumBits> -{ - static const std::size_t Mask = ((std::size_t(1u) << NumBits) - 1); - typedef T* pointer; - - static pointer get_pointer(pointer n) - { return pointer(std::size_t(n) & ~Mask); } - - static void set_pointer(pointer &n, pointer p) - { - BOOST_INTRUSIVE_INVARIANT_ASSERT(0 == (std::size_t(p) & Mask)); - n = pointer(std::size_t(p) | (std::size_t(n) & Mask)); - } - - static std::size_t get_bits(pointer n) - { return (std::size_t(n) & Mask); } - - static void set_bits(pointer &n, std::size_t c) - { - BOOST_INTRUSIVE_INVARIANT_ASSERT(c <= Mask); - n = pointer(std::size_t(get_pointer(n)) | c); - } -}; - -} //namespace intrusive -} //namespace boost - -#endif //BOOST_INTRUSIVE_POINTER_PLUS_BITS_HPP diff --git a/src/third_party/boost/boost/intrusive/pointer_traits.hpp b/src/third_party/boost/boost/intrusive/pointer_traits.hpp deleted file mode 100644 index 9f7d2fa4438..00000000000 --- a/src/third_party/boost/boost/intrusive/pointer_traits.hpp +++ /dev/null @@ -1,265 +0,0 @@ -////////////////////////////////////////////////////////////////////////////// -// -// (C) Copyright Pablo Halpern 2009. Distributed under the Boost -// Software License, Version 1.0. (See accompanying file -// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -// -////////////////////////////////////////////////////////////////////////////// -// -// (C) Copyright Ion Gaztanaga 2011-2011. Distributed under the Boost -// Software License, Version 1.0. (See accompanying file -// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -// -// See http://www.boost.org/libs/intrusive for documentation. -// -////////////////////////////////////////////////////////////////////////////// - -#ifndef BOOST_INTRUSIVE_POINTER_TRAITS_HPP -#define BOOST_INTRUSIVE_POINTER_TRAITS_HPP - -#if (defined _MSC_VER) && (_MSC_VER >= 1200) -# pragma once -#endif - -#include <boost/intrusive/detail/config_begin.hpp> -#include <boost/intrusive/detail/workaround.hpp> -#include <boost/intrusive/detail/memory_util.hpp> -#include <boost/type_traits/integral_constant.hpp> -#include <cstddef> - -namespace boost { -namespace intrusive { - -//! pointer_traits is the implementation of C++11 std::pointer_traits class with some -//! extensions like castings. -//! -//! pointer_traits supplies a uniform interface to certain attributes of pointer-like types. -template <typename Ptr> -struct pointer_traits -{ - #ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED - //!The pointer type - //!queried by this pointer_traits instantiation - typedef Ptr pointer; - - //!Ptr::element_type if such a type exists; otherwise, T if Ptr is a class - //!template instantiation of the form SomePointer<T, Args>, where Args is zero or - //!more type arguments ; otherwise , the specialization is ill-formed. - typedef unspecified_type element_type; - - //!Ptr::difference_type if such a type exists; otherwise, - //!std::ptrdiff_t. - typedef unspecified_type difference_type; - - //!Ptr::rebind<U> if such a type exists; otherwise, SomePointer<U, Args> if Ptr is - //!a class template instantiation of the form SomePointer<T, Args>, where Args is zero or - //!more type arguments ; otherwise, the instantiation of rebind is ill-formed. - //! - //!For portable code for C++03 and C++11, <pre>typename rebind_pointer<U>::type</pre> - //!shall be used instead of rebind<U> to obtain a pointer to U. - template <class U> using rebind = unspecified; - - //!Ptr::rebind<U> if such a type exists; otherwise, SomePointer<U, Args> if Ptr is - //!a class template instantiation of the form SomePointer<T, Args>, where Args is zero or - //!more type arguments ; otherwise, the instantiation of rebind is ill-formed. - //! - typedef element_type &reference; - #else - typedef Ptr pointer; - // - typedef BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_EVAL_DEFAULT - ( boost::intrusive::detail::, Ptr, element_type - , boost::intrusive::detail::first_param<Ptr>) element_type; - // - typedef BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_DEFAULT - (boost::intrusive::detail::, Ptr, difference_type, std::ptrdiff_t) difference_type; - // - typedef typename boost::intrusive::detail::unvoid<element_type>::type& reference; - // - template <class U> struct rebind_pointer - { - typedef typename boost::intrusive::detail::type_rebinder<Ptr, U>::type type; - }; - - #if !defined(BOOST_NO_TEMPLATE_ALIASES) - template <class U> using rebind = typename boost::intrusive::detail::type_rebinder<Ptr, U>::type; - #endif - #endif //#if !defined(BOOST_NO_TEMPLATE_ALIASES) - - //! <b>Remark</b>: If element_type is (possibly cv-qualified) void, r type is unspecified; otherwise, - //! it is element_type &. - //! - //! <b>Returns</b>: A dereferenceable pointer to r obtained by calling Ptr::pointer_to(r). - //! Non-standard extension: If such function does not exist, returns pointer(addressof(r)); - static pointer pointer_to(reference r) - { - //Non-standard extension, it does not require Ptr::pointer_to. If not present - //tries to converts &r to pointer. - const bool value = boost::intrusive::detail:: - has_member_function_callable_with_pointer_to - <Ptr, typename boost::intrusive::detail::unvoid<element_type &>::type>::value; - ::boost::integral_constant<bool, value> flag; - return pointer_traits::priv_pointer_to(flag, r); - } - - //! <b>Remark</b>: Non-standard extension. - //! - //! <b>Returns</b>: A dereferenceable pointer to r obtained by calling Ptr::static_cast_from(r). - //! If such function does not exist, returns pointer_to(static_cast<element_type&>(*uptr)) - template<class UPtr> - static pointer static_cast_from(const UPtr &uptr) - { - const bool value = boost::intrusive::detail:: - has_member_function_callable_with_static_cast_from - <Ptr, const UPtr>::value; - ::boost::integral_constant<bool, value> flag; - return pointer_traits::priv_static_cast_from(flag, uptr); - } - - //! <b>Remark</b>: Non-standard extension. - //! - //! <b>Returns</b>: A dereferenceable pointer to r obtained by calling Ptr::const_cast_from(r). - //! If such function does not exist, returns pointer_to(const_cast<element_type&>(*uptr)) - template<class UPtr> - static pointer const_cast_from(const UPtr &uptr) - { - const bool value = boost::intrusive::detail:: - has_member_function_callable_with_const_cast_from - <Ptr, const UPtr>::value; - ::boost::integral_constant<bool, value> flag; - return pointer_traits::priv_const_cast_from(flag, uptr); - } - - //! <b>Remark</b>: Non-standard extension. - //! - //! <b>Returns</b>: A dereferenceable pointer to r obtained by calling Ptr::dynamic_cast_from(r). - //! If such function does not exist, returns pointer_to(*dynamic_cast<element_type*>(&*uptr)) - template<class UPtr> - static pointer dynamic_cast_from(const UPtr &uptr) - { - const bool value = boost::intrusive::detail:: - has_member_function_callable_with_dynamic_cast_from - <Ptr, const UPtr>::value; - ::boost::integral_constant<bool, value> flag; - return pointer_traits::priv_dynamic_cast_from(flag, uptr); - } - - ///@cond - private: - //priv_to_raw_pointer - template <class T> - static T* to_raw_pointer(T* p) - { return p; } - - template <class Pointer> - static typename pointer_traits<Pointer>::element_type* - to_raw_pointer(const Pointer &p) - { return pointer_traits::to_raw_pointer(p.operator->()); } - - //priv_pointer_to - static pointer priv_pointer_to(boost::true_type, typename boost::intrusive::detail::unvoid<element_type>::type& r) - { return Ptr::pointer_to(r); } - - static pointer priv_pointer_to(boost::false_type, typename boost::intrusive::detail::unvoid<element_type>::type& r) - { return pointer(boost::intrusive::detail::addressof(r)); } - - //priv_static_cast_from - template<class UPtr> - static pointer priv_static_cast_from(boost::true_type, const UPtr &uptr) - { return Ptr::static_cast_from(uptr); } - - template<class UPtr> - static pointer priv_static_cast_from(boost::false_type, const UPtr &uptr) - { return pointer_to(static_cast<element_type&>(*uptr)); } - - //priv_const_cast_from - template<class UPtr> - static pointer priv_const_cast_from(boost::true_type, const UPtr &uptr) - { return Ptr::const_cast_from(uptr); } - - template<class UPtr> - static pointer priv_const_cast_from(boost::false_type, const UPtr &uptr) - { return pointer_to(const_cast<element_type&>(*uptr)); } - - //priv_dynamic_cast_from - template<class UPtr> - static pointer priv_dynamic_cast_from(boost::true_type, const UPtr &uptr) - { return Ptr::dynamic_cast_from(uptr); } - - template<class UPtr> - static pointer priv_dynamic_cast_from(boost::false_type, const UPtr &uptr) - { return pointer_to(*dynamic_cast<element_type*>(&*uptr)); } - ///@endcond -}; - -///@cond - -// Remove cv qualification from Ptr parameter to pointer_traits: -template <typename Ptr> -struct pointer_traits<const Ptr> : pointer_traits<Ptr> {}; -template <typename Ptr> -struct pointer_traits<volatile Ptr> : pointer_traits<Ptr> { }; -template <typename Ptr> -struct pointer_traits<const volatile Ptr> : pointer_traits<Ptr> { }; -// Remove reference from Ptr parameter to pointer_traits: -template <typename Ptr> -struct pointer_traits<Ptr&> : pointer_traits<Ptr> { }; - -///@endcond - -//! Specialization of pointer_traits for raw pointers -//! -template <typename T> -struct pointer_traits<T*> -{ - typedef T element_type; - typedef T* pointer; - typedef std::ptrdiff_t difference_type; - - #ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED - typedef T & reference; - //!typedef for <pre>U *</pre> - //! - //!For portable code for C++03 and C++11, <pre>typename rebind_pointer<U>::type</pre> - //!shall be used instead of rebind<U> to obtain a pointer to U. - template <class U> using rebind = U*; - #else - typedef typename boost::intrusive::detail::unvoid<element_type>::type& reference; - #if !defined(BOOST_NO_TEMPLATE_ALIASES) - template <class U> using rebind = U*; - #endif - #endif - - template <class U> struct rebind_pointer - { typedef U* type; }; - - //! <b>Returns</b>: addressof(r) - //! - static pointer pointer_to(reference r) - { return boost::intrusive::detail::addressof(r); } - - //! <b>Returns</b>: static_cast<pointer>(uptr) - //! - template<class U> - static pointer static_cast_from(U *uptr) - { return static_cast<pointer>(uptr); } - - //! <b>Returns</b>: const_cast<pointer>(uptr) - //! - template<class U> - static pointer const_cast_from(U *uptr) - { return const_cast<pointer>(uptr); } - - //! <b>Returns</b>: dynamic_cast<pointer>(uptr) - //! - template<class U> - static pointer dynamic_cast_from(U *uptr) - { return dynamic_cast<pointer>(uptr); } -}; - -} //namespace container { -} //namespace boost { - -#include <boost/intrusive/detail/config_end.hpp> - -#endif // ! defined(BOOST_INTRUSIVE_POINTER_TRAITS_HPP) diff --git a/src/third_party/boost/boost/intrusive/priority_compare.hpp b/src/third_party/boost/boost/intrusive/priority_compare.hpp deleted file mode 100644 index abde27ac0dd..00000000000 --- a/src/third_party/boost/boost/intrusive/priority_compare.hpp +++ /dev/null @@ -1,39 +0,0 @@ -///////////////////////////////////////////////////////////////////////////// -// -// (C) Copyright Ion Gaztanaga 2008 -// -// Distributed under the Boost Software License, Version 1.0. -// (See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) -// -// See http://www.boost.org/libs/intrusive for documentation. -// -///////////////////////////////////////////////////////////////////////////// - -#ifndef BOOST_INTRUSIVE_PRIORITY_COMPARE_HPP -#define BOOST_INTRUSIVE_PRIORITY_COMPARE_HPP - -#include <boost/intrusive/detail/config_begin.hpp> -#include <boost/intrusive/intrusive_fwd.hpp> - -#include <functional> - -namespace boost { -namespace intrusive { - -template <class T> -struct priority_compare - : public std::binary_function<T, T, bool> -{ - bool operator()(const T &val, const T &val2) const - { - return priority_order(val, val2); - } -}; - -} //namespace intrusive -} //namespace boost - -#include <boost/intrusive/detail/config_end.hpp> - -#endif //BOOST_INTRUSIVE_PRIORITY_COMPARE_HPP diff --git a/src/third_party/boost/boost/intrusive/rbtree.hpp b/src/third_party/boost/boost/intrusive/rbtree.hpp deleted file mode 100644 index 26dfb4d8900..00000000000 --- a/src/third_party/boost/boost/intrusive/rbtree.hpp +++ /dev/null @@ -1,1687 +0,0 @@ -///////////////////////////////////////////////////////////////////////////// -// -// (C) Copyright Ion Gaztanaga 2006-2009 -// -// Distributed under the Boost Software License, Version 1.0. -// (See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) -// -// See http://www.boost.org/libs/intrusive for documentation. -// -///////////////////////////////////////////////////////////////////////////// -#ifndef BOOST_INTRUSIVE_RBTREE_HPP -#define BOOST_INTRUSIVE_RBTREE_HPP - -#include <boost/intrusive/detail/config_begin.hpp> -#include <algorithm> -#include <cstddef> -#include <functional> -#include <iterator> -#include <utility> - -#include <boost/intrusive/detail/assert.hpp> -#include <boost/static_assert.hpp> -#include <boost/intrusive/intrusive_fwd.hpp> -#include <boost/intrusive/set_hook.hpp> -#include <boost/intrusive/detail/rbtree_node.hpp> -#include <boost/intrusive/detail/tree_node.hpp> -#include <boost/intrusive/detail/ebo_functor_holder.hpp> -#include <boost/intrusive/detail/mpl.hpp> -#include <boost/intrusive/pointer_traits.hpp> -#include <boost/intrusive/detail/clear_on_destructor_base.hpp> -#include <boost/intrusive/detail/function_detector.hpp> -#include <boost/intrusive/detail/utilities.hpp> -#include <boost/intrusive/options.hpp> -#include <boost/intrusive/rbtree_algorithms.hpp> -#include <boost/intrusive/link_mode.hpp> -#include <boost/move/move.hpp> - -namespace boost { -namespace intrusive { - -/// @cond - -template <class ValueTraits, class Compare, class SizeType, bool ConstantTimeSize> -struct setopt -{ - typedef ValueTraits value_traits; - typedef Compare compare; - typedef SizeType size_type; - static const bool constant_time_size = ConstantTimeSize; -}; - -template <class T> -struct set_defaults - : pack_options - < none - , base_hook<detail::default_set_hook> - , constant_time_size<true> - , size_type<std::size_t> - , compare<std::less<T> > - >::type -{}; - -/// @endcond - -//! The class template rbtree is an intrusive red-black tree container, that -//! is used to construct intrusive set and multiset containers. The no-throw -//! guarantee holds only, if the value_compare object -//! doesn't throw. -//! -//! The template parameter \c T is the type to be managed by the container. -//! The user can specify additional options and if no options are provided -//! default options are used. -//! -//! The container supports the following options: -//! \c base_hook<>/member_hook<>/value_traits<>, -//! \c constant_time_size<>, \c size_type<> and -//! \c compare<>. -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -class rbtree_impl - : private detail::clear_on_destructor_base<rbtree_impl<Config> > -{ - template<class C> friend class detail::clear_on_destructor_base; - public: - typedef typename Config::value_traits value_traits; - /// @cond - static const bool external_value_traits = - detail::external_value_traits_is_true<value_traits>::value; - typedef typename detail::eval_if_c - < external_value_traits - , detail::eval_value_traits<value_traits> - , detail::identity<value_traits> - >::type real_value_traits; - /// @endcond - typedef typename real_value_traits::pointer pointer; - typedef typename real_value_traits::const_pointer const_pointer; - - typedef typename pointer_traits<pointer>::element_type value_type; - typedef value_type key_type; - typedef typename pointer_traits<pointer>::reference reference; - typedef typename pointer_traits<const_pointer>::reference const_reference; - typedef typename pointer_traits<const_pointer>::difference_type difference_type; - typedef typename Config::size_type size_type; - typedef typename Config::compare value_compare; - typedef value_compare key_compare; - typedef tree_iterator<rbtree_impl, false> iterator; - typedef tree_iterator<rbtree_impl, true> const_iterator; - typedef boost::intrusive::detail::reverse_iterator<iterator> reverse_iterator; - typedef boost::intrusive::detail::reverse_iterator<const_iterator>const_reverse_iterator; - typedef typename real_value_traits::node_traits node_traits; - typedef typename node_traits::node node; - typedef typename node_traits::node_ptr node_ptr; - typedef typename node_traits::const_node_ptr const_node_ptr; - typedef rbtree_algorithms<node_traits> node_algorithms; - - static const bool constant_time_size = Config::constant_time_size; - static const bool stateful_value_traits = detail::is_stateful_value_traits<real_value_traits>::value; - /// @cond - private: - typedef detail::size_holder<constant_time_size, size_type> size_traits; - - //noncopyable - BOOST_MOVABLE_BUT_NOT_COPYABLE(rbtree_impl) - - enum { safemode_or_autounlink = - (int)real_value_traits::link_mode == (int)auto_unlink || - (int)real_value_traits::link_mode == (int)safe_link }; - - //Constant-time size is incompatible with auto-unlink hooks! - BOOST_STATIC_ASSERT(!(constant_time_size && ((int)real_value_traits::link_mode == (int)auto_unlink))); - - struct header_plus_size : public size_traits - { node header_; }; - - struct node_plus_pred_t : public detail::ebo_functor_holder<value_compare> - { - node_plus_pred_t(const value_compare &comp) - : detail::ebo_functor_holder<value_compare>(comp) - {} - header_plus_size header_plus_size_; - }; - - struct data_t : public rbtree_impl::value_traits - { - typedef typename rbtree_impl::value_traits value_traits; - data_t(const value_compare & comp, const value_traits &val_traits) - : value_traits(val_traits), node_plus_pred_(comp) - {} - node_plus_pred_t node_plus_pred_; - } data_; - - const value_compare &priv_comp() const - { return data_.node_plus_pred_.get(); } - - value_compare &priv_comp() - { return data_.node_plus_pred_.get(); } - - const value_traits &priv_value_traits() const - { return data_; } - - value_traits &priv_value_traits() - { return data_; } - - node_ptr priv_header_ptr() - { return pointer_traits<node_ptr>::pointer_to(data_.node_plus_pred_.header_plus_size_.header_); } - - const_node_ptr priv_header_ptr() const - { return pointer_traits<const_node_ptr>::pointer_to(data_.node_plus_pred_.header_plus_size_.header_); } - - static node_ptr uncast(const const_node_ptr & ptr) - { return pointer_traits<node_ptr>::const_cast_from(ptr); } - - size_traits &priv_size_traits() - { return data_.node_plus_pred_.header_plus_size_; } - - const size_traits &priv_size_traits() const - { return data_.node_plus_pred_.header_plus_size_; } - - const real_value_traits &get_real_value_traits(detail::bool_<false>) const - { return data_; } - - const real_value_traits &get_real_value_traits(detail::bool_<true>) const - { return data_.get_value_traits(*this); } - - real_value_traits &get_real_value_traits(detail::bool_<false>) - { return data_; } - - real_value_traits &get_real_value_traits(detail::bool_<true>) - { return data_.get_value_traits(*this); } - - protected: - value_compare &prot_comp() - { return priv_comp(); } - - const node &prot_header_node() const - { return data_.node_plus_pred_.header_plus_size_.header_; } - - node &prot_header_node() - { return data_.node_plus_pred_.header_plus_size_.header_; } - - void prot_set_size(size_type s) - { this->priv_size_traits().set_size(s); } - - /// @endcond - - public: - - const real_value_traits &get_real_value_traits() const - { return this->get_real_value_traits(detail::bool_<external_value_traits>()); } - - real_value_traits &get_real_value_traits() - { return this->get_real_value_traits(detail::bool_<external_value_traits>()); } - - typedef typename node_algorithms::insert_commit_data insert_commit_data; - - //! <b>Effects</b>: Constructs an empty tree. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: If value_traits::node_traits::node - //! constructor throws (this does not happen with predefined Boost.Intrusive hooks) - //! or the copy constructorof the value_compare object throws. Basic guarantee. - rbtree_impl( const value_compare &cmp = value_compare() - , const value_traits &v_traits = value_traits()) - : data_(cmp, v_traits) - { - node_algorithms::init_header(this->priv_header_ptr()); - this->priv_size_traits().set_size(size_type(0)); - } - - //! <b>Requires</b>: Dereferencing iterator must yield an lvalue of type value_type. - //! cmp must be a comparison function that induces a strict weak ordering. - //! - //! <b>Effects</b>: Constructs an empty tree and inserts elements from - //! [b, e). - //! - //! <b>Complexity</b>: Linear in N if [b, e) is already sorted using - //! comp and otherwise N * log N, where N is the distance between first and last. - //! - //! <b>Throws</b>: If value_traits::node_traits::node - //! constructor throws (this does not happen with predefined Boost.Intrusive hooks) - //! or the copy constructor/operator() of the value_compare object throws. Basic guarantee. - template<class Iterator> - rbtree_impl( bool unique, Iterator b, Iterator e - , const value_compare &cmp = value_compare() - , const value_traits &v_traits = value_traits()) - : data_(cmp, v_traits) - { - node_algorithms::init_header(this->priv_header_ptr()); - this->priv_size_traits().set_size(size_type(0)); - if(unique) - this->insert_unique(b, e); - else - this->insert_equal(b, e); - } - - //! <b>Effects</b>: to-do - //! - rbtree_impl(BOOST_RV_REF(rbtree_impl) x) - : data_(::boost::move(x.priv_comp()), ::boost::move(x.priv_value_traits())) - { - node_algorithms::init_header(this->priv_header_ptr()); - this->priv_size_traits().set_size(size_type(0)); - this->swap(x); - } - - //! <b>Effects</b>: to-do - //! - rbtree_impl& operator=(BOOST_RV_REF(rbtree_impl) x) - { this->swap(x); return *this; } - - //! <b>Effects</b>: Detaches all elements from this. The objects in the set - //! are not deleted (i.e. no destructors are called), but the nodes according to - //! the value_traits template parameter are reinitialized and thus can be reused. - //! - //! <b>Complexity</b>: Linear to elements contained in *this. - //! - //! <b>Throws</b>: Nothing. - ~rbtree_impl() - {} - - //! <b>Effects</b>: Returns an iterator pointing to the beginning of the tree. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - iterator begin() - { return iterator (node_traits::get_left(this->priv_header_ptr()), this); } - - //! <b>Effects</b>: Returns a const_iterator pointing to the beginning of the tree. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_iterator begin() const - { return cbegin(); } - - //! <b>Effects</b>: Returns a const_iterator pointing to the beginning of the tree. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_iterator cbegin() const - { return const_iterator (node_traits::get_left(this->priv_header_ptr()), this); } - - //! <b>Effects</b>: Returns an iterator pointing to the end of the tree. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - iterator end() - { return iterator (this->priv_header_ptr(), this); } - - //! <b>Effects</b>: Returns a const_iterator pointing to the end of the tree. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_iterator end() const - { return cend(); } - - //! <b>Effects</b>: Returns a const_iterator pointing to the end of the tree. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_iterator cend() const - { return const_iterator (uncast(this->priv_header_ptr()), this); } - - //! <b>Effects</b>: Returns a reverse_iterator pointing to the beginning of the - //! reversed tree. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - reverse_iterator rbegin() - { return reverse_iterator(end()); } - - //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning - //! of the reversed tree. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_reverse_iterator rbegin() const - { return const_reverse_iterator(end()); } - - //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning - //! of the reversed tree. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_reverse_iterator crbegin() const - { return const_reverse_iterator(end()); } - - //! <b>Effects</b>: Returns a reverse_iterator pointing to the end - //! of the reversed tree. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - reverse_iterator rend() - { return reverse_iterator(begin()); } - - //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the end - //! of the reversed tree. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_reverse_iterator rend() const - { return const_reverse_iterator(begin()); } - - //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the end - //! of the reversed tree. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_reverse_iterator crend() const - { return const_reverse_iterator(begin()); } - - //! <b>Precondition</b>: end_iterator must be a valid end iterator - //! of rbtree. - //! - //! <b>Effects</b>: Returns a const reference to the rbtree associated to the end iterator - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - static rbtree_impl &container_from_end_iterator(iterator end_iterator) - { return priv_container_from_end_iterator(end_iterator); } - - //! <b>Precondition</b>: end_iterator must be a valid end const_iterator - //! of rbtree. - //! - //! <b>Effects</b>: Returns a const reference to the rbtree associated to the iterator - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - static const rbtree_impl &container_from_end_iterator(const_iterator end_iterator) - { return priv_container_from_end_iterator(end_iterator); } - - //! <b>Precondition</b>: it must be a valid iterator - //! of rbtree. - //! - //! <b>Effects</b>: Returns a const reference to the tree associated to the iterator - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Logarithmic. - static rbtree_impl &container_from_iterator(iterator it) - { return priv_container_from_iterator(it); } - - //! <b>Precondition</b>: it must be a valid end const_iterator - //! of rbtree. - //! - //! <b>Effects</b>: Returns a const reference to the tree associated to the end iterator - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Logarithmic. - static const rbtree_impl &container_from_iterator(const_iterator it) - { return priv_container_from_iterator(it); } - - //! <b>Effects</b>: Returns the value_compare object used by the tree. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: If value_compare copy-constructor throws. - value_compare value_comp() const - { return priv_comp(); } - - //! <b>Effects</b>: Returns true if the container is empty. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - bool empty() const - { return node_algorithms::unique(this->priv_header_ptr()); } - - //! <b>Effects</b>: Returns the number of elements stored in the tree. - //! - //! <b>Complexity</b>: Linear to elements contained in *this - //! if constant-time size option is disabled. Constant time otherwise. - //! - //! <b>Throws</b>: Nothing. - size_type size() const - { - if(constant_time_size) - return this->priv_size_traits().get_size(); - else{ - return (size_type)node_algorithms::size(this->priv_header_ptr()); - } - } - - //! <b>Effects</b>: Swaps the contents of two rbtrees. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: If the comparison functor's swap call throws. - void swap(rbtree_impl& other) - { - //This can throw - using std::swap; - swap(priv_comp(), priv_comp()); - //These can't throw - node_algorithms::swap_tree(this->priv_header_ptr(), node_ptr(other.priv_header_ptr())); - if(constant_time_size){ - size_type backup = this->priv_size_traits().get_size(); - this->priv_size_traits().set_size(other.priv_size_traits().get_size()); - other.priv_size_traits().set_size(backup); - } - } - - //! <b>Requires</b>: value must be an lvalue - //! - //! <b>Effects</b>: Inserts value into the tree before the upper bound. - //! - //! <b>Complexity</b>: Average complexity for insert element is at - //! most logarithmic. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. Strong guarantee. - //! - //! <b>Note</b>: Does not affect the validity of iterators and references. - //! No copy-constructors are called. - iterator insert_equal(reference value) - { - detail::key_nodeptr_comp<value_compare, rbtree_impl> - key_node_comp(priv_comp(), this); - node_ptr to_insert(get_real_value_traits().to_node_ptr(value)); - if(safemode_or_autounlink) - BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert)); - iterator ret(node_algorithms::insert_equal_upper_bound - (this->priv_header_ptr(), to_insert, key_node_comp), this); - this->priv_size_traits().increment(); - return ret; - } - - //! <b>Requires</b>: value must be an lvalue, and "hint" must be - //! a valid iterator. - //! - //! <b>Effects</b>: Inserts x into the tree, using "hint" as a hint to - //! where it will be inserted. If "hint" is the upper_bound - //! the insertion takes constant time (two comparisons in the worst case) - //! - //! <b>Complexity</b>: Logarithmic in general, but it is amortized - //! constant time if t is inserted immediately before hint. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. Strong guarantee. - //! - //! <b>Note</b>: Does not affect the validity of iterators and references. - //! No copy-constructors are called. - iterator insert_equal(const_iterator hint, reference value) - { - detail::key_nodeptr_comp<value_compare, rbtree_impl> - key_node_comp(priv_comp(), this); - node_ptr to_insert(get_real_value_traits().to_node_ptr(value)); - if(safemode_or_autounlink) - BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert)); - iterator ret(node_algorithms::insert_equal - (this->priv_header_ptr(), hint.pointed_node(), to_insert, key_node_comp), this); - this->priv_size_traits().increment(); - return ret; - } - - //! <b>Requires</b>: Dereferencing iterator must yield an lvalue - //! of type value_type. - //! - //! <b>Effects</b>: Inserts a each element of a range into the tree - //! before the upper bound of the key of each element. - //! - //! <b>Complexity</b>: Insert range is in general O(N * log(N)), where N is the - //! size of the range. However, it is linear in N if the range is already sorted - //! by value_comp(). - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Does not affect the validity of iterators and references. - //! No copy-constructors are called. - template<class Iterator> - void insert_equal(Iterator b, Iterator e) - { - iterator iend(this->end()); - for (; b != e; ++b) - this->insert_equal(iend, *b); - } - - //! <b>Requires</b>: value must be an lvalue - //! - //! <b>Effects</b>: Inserts value into the tree if the value - //! is not already present. - //! - //! <b>Complexity</b>: Average complexity for insert element is at - //! most logarithmic. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Does not affect the validity of iterators and references. - //! No copy-constructors are called. - std::pair<iterator, bool> insert_unique(reference value) - { - insert_commit_data commit_data; - std::pair<iterator, bool> ret = insert_unique_check(value, priv_comp(), commit_data); - if(!ret.second) - return ret; - return std::pair<iterator, bool> (insert_unique_commit(value, commit_data), true); - } - - //! <b>Requires</b>: value must be an lvalue, and "hint" must be - //! a valid iterator - //! - //! <b>Effects</b>: Tries to insert x into the tree, using "hint" as a hint - //! to where it will be inserted. - //! - //! <b>Complexity</b>: Logarithmic in general, but it is amortized - //! constant time (two comparisons in the worst case) - //! if t is inserted immediately before hint. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Does not affect the validity of iterators and references. - //! No copy-constructors are called. - iterator insert_unique(const_iterator hint, reference value) - { - insert_commit_data commit_data; - std::pair<iterator, bool> ret = insert_unique_check(hint, value, priv_comp(), commit_data); - if(!ret.second) - return ret.first; - return insert_unique_commit(value, commit_data); - } - - //! <b>Requires</b>: Dereferencing iterator must yield an lvalue - //! of type value_type. - //! - //! <b>Effects</b>: Tries to insert each element of a range into the tree. - //! - //! <b>Complexity</b>: Insert range is in general O(N * log(N)), where N is the - //! size of the range. However, it is linear in N if the range is already sorted - //! by value_comp(). - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Does not affect the validity of iterators and references. - //! No copy-constructors are called. - template<class Iterator> - void insert_unique(Iterator b, Iterator e) - { - if(this->empty()){ - iterator iend(this->end()); - for (; b != e; ++b) - this->insert_unique(iend, *b); - } - else{ - for (; b != e; ++b) - this->insert_unique(*b); - } - } - - //! <b>Requires</b>: key_value_comp must be a comparison function that induces - //! the same strict weak ordering as value_compare. The difference is that - //! key_value_comp compares an arbitrary key with the contained values. - //! - //! <b>Effects</b>: Checks if a value can be inserted in the container, using - //! a user provided key instead of the value itself. - //! - //! <b>Returns</b>: If there is an equivalent value - //! returns a pair containing an iterator to the already present value - //! and false. If the value can be inserted returns true in the returned - //! pair boolean and fills "commit_data" that is meant to be used with - //! the "insert_commit" function. - //! - //! <b>Complexity</b>: Average complexity is at most logarithmic. - //! - //! <b>Throws</b>: If the key_value_comp ordering function throws. Strong guarantee. - //! - //! <b>Notes</b>: This function is used to improve performance when constructing - //! a value_type is expensive: if there is an equivalent value - //! the constructed object must be discarded. Many times, the part of the - //! node that is used to impose the order is much cheaper to construct - //! than the value_type and this function offers the possibility to use that - //! part to check if the insertion will be successful. - //! - //! If the check is successful, the user can construct the value_type and use - //! "insert_commit" to insert the object in constant-time. This gives a total - //! logarithmic complexity to the insertion: check(O(log(N)) + commit(O(1)). - //! - //! "commit_data" remains valid for a subsequent "insert_commit" only if no more - //! objects are inserted or erased from the container. - template<class KeyType, class KeyValueCompare> - std::pair<iterator, bool> insert_unique_check - (const KeyType &key, KeyValueCompare key_value_comp, insert_commit_data &commit_data) - { - detail::key_nodeptr_comp<KeyValueCompare, rbtree_impl> - comp(key_value_comp, this); - std::pair<node_ptr, bool> ret = - (node_algorithms::insert_unique_check - (this->priv_header_ptr(), key, comp, commit_data)); - return std::pair<iterator, bool>(iterator(ret.first, this), ret.second); - } - - //! <b>Requires</b>: key_value_comp must be a comparison function that induces - //! the same strict weak ordering as value_compare. The difference is that - //! key_value_comp compares an arbitrary key with the contained values. - //! - //! <b>Effects</b>: Checks if a value can be inserted in the container, using - //! a user provided key instead of the value itself, using "hint" - //! as a hint to where it will be inserted. - //! - //! <b>Returns</b>: If there is an equivalent value - //! returns a pair containing an iterator to the already present value - //! and false. If the value can be inserted returns true in the returned - //! pair boolean and fills "commit_data" that is meant to be used with - //! the "insert_commit" function. - //! - //! <b>Complexity</b>: Logarithmic in general, but it's amortized - //! constant time if t is inserted immediately before hint. - //! - //! <b>Throws</b>: If the key_value_comp ordering function throws. Strong guarantee. - //! - //! <b>Notes</b>: This function is used to improve performance when constructing - //! a value_type is expensive: if there is an equivalent value - //! the constructed object must be discarded. Many times, the part of the - //! constructing that is used to impose the order is much cheaper to construct - //! than the value_type and this function offers the possibility to use that key - //! to check if the insertion will be successful. - //! - //! If the check is successful, the user can construct the value_type and use - //! "insert_commit" to insert the object in constant-time. This can give a total - //! constant-time complexity to the insertion: check(O(1)) + commit(O(1)). - //! - //! "commit_data" remains valid for a subsequent "insert_commit" only if no more - //! objects are inserted or erased from the container. - template<class KeyType, class KeyValueCompare> - std::pair<iterator, bool> insert_unique_check - (const_iterator hint, const KeyType &key - ,KeyValueCompare key_value_comp, insert_commit_data &commit_data) - { - detail::key_nodeptr_comp<KeyValueCompare, rbtree_impl> - comp(key_value_comp, this); - std::pair<node_ptr, bool> ret = - (node_algorithms::insert_unique_check - (this->priv_header_ptr(), hint.pointed_node(), key, comp, commit_data)); - return std::pair<iterator, bool>(iterator(ret.first, this), ret.second); - } - - //! <b>Requires</b>: value must be an lvalue of type value_type. commit_data - //! must have been obtained from a previous call to "insert_check". - //! No objects should have been inserted or erased from the container between - //! the "insert_check" that filled "commit_data" and the call to "insert_commit". - //! - //! <b>Effects</b>: Inserts the value in the avl_set using the information obtained - //! from the "commit_data" that a previous "insert_check" filled. - //! - //! <b>Returns</b>: An iterator to the newly inserted object. - //! - //! <b>Complexity</b>: Constant time. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Notes</b>: This function has only sense if a "insert_check" has been - //! previously executed to fill "commit_data". No value should be inserted or - //! erased between the "insert_check" and "insert_commit" calls. - iterator insert_unique_commit(reference value, const insert_commit_data &commit_data) - { - node_ptr to_insert(get_real_value_traits().to_node_ptr(value)); - if(safemode_or_autounlink) - BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert)); - node_algorithms::insert_unique_commit - (this->priv_header_ptr(), to_insert, commit_data); - this->priv_size_traits().increment(); - return iterator(to_insert, this); - } - - //! <b>Requires</b>: value must be an lvalue, "pos" must be - //! a valid iterator (or end) and must be the succesor of value - //! once inserted according to the predicate - //! - //! <b>Effects</b>: Inserts x into the tree before "pos". - //! - //! <b>Complexity</b>: Constant time. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: This function does not check preconditions so if "pos" is not - //! the successor of "value" tree ordering invariant will be broken. - //! This is a low-level function to be used only for performance reasons - //! by advanced users. - iterator insert_before(const_iterator pos, reference value) - { - node_ptr to_insert(get_real_value_traits().to_node_ptr(value)); - if(safemode_or_autounlink) - BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert)); - this->priv_size_traits().increment(); - return iterator(node_algorithms::insert_before - (this->priv_header_ptr(), pos.pointed_node(), to_insert), this); - } - - //! <b>Requires</b>: value must be an lvalue, and it must be no less - //! than the greatest inserted key - //! - //! <b>Effects</b>: Inserts x into the tree in the last position. - //! - //! <b>Complexity</b>: Constant time. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: This function does not check preconditions so if value is - //! less than the greatest inserted key tree ordering invariant will be broken. - //! This function is slightly more efficient than using "insert_before". - //! This is a low-level function to be used only for performance reasons - //! by advanced users. - void push_back(reference value) - { - node_ptr to_insert(get_real_value_traits().to_node_ptr(value)); - if(safemode_or_autounlink) - BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert)); - this->priv_size_traits().increment(); - node_algorithms::push_back(this->priv_header_ptr(), to_insert); - } - - //! <b>Requires</b>: value must be an lvalue, and it must be no greater - //! than the minimum inserted key - //! - //! <b>Effects</b>: Inserts x into the tree in the first position. - //! - //! <b>Complexity</b>: Constant time. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: This function does not check preconditions so if value is - //! greater than the minimum inserted key tree ordering invariant will be broken. - //! This function is slightly more efficient than using "insert_before". - //! This is a low-level function to be used only for performance reasons - //! by advanced users. - void push_front(reference value) - { - node_ptr to_insert(get_real_value_traits().to_node_ptr(value)); - if(safemode_or_autounlink) - BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert)); - this->priv_size_traits().increment(); - node_algorithms::push_front(this->priv_header_ptr(), to_insert); - } - - //! <b>Effects</b>: Erases the element pointed to by pos. - //! - //! <b>Complexity</b>: Average complexity for erase element is constant time. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - iterator erase(const_iterator i) - { - const_iterator ret(i); - ++ret; - node_ptr to_erase(i.pointed_node()); - if(safemode_or_autounlink) - BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(!node_algorithms::unique(to_erase)); - node_algorithms::erase(this->priv_header_ptr(), to_erase); - this->priv_size_traits().decrement(); - if(safemode_or_autounlink) - node_algorithms::init(to_erase); - return ret.unconst(); - } - - //! <b>Effects</b>: Erases the range pointed to by b end e. - //! - //! <b>Complexity</b>: Average complexity for erase range is at most - //! O(log(size() + N)), where N is the number of elements in the range. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - iterator erase(const_iterator b, const_iterator e) - { size_type n; return private_erase(b, e, n); } - - //! <b>Effects</b>: Erases all the elements with the given value. - //! - //! <b>Returns</b>: The number of erased elements. - //! - //! <b>Complexity</b>: O(log(size() + N). - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - size_type erase(const_reference value) - { return this->erase(value, priv_comp()); } - - //! <b>Effects</b>: Erases all the elements with the given key. - //! according to the comparison functor "comp". - //! - //! <b>Returns</b>: The number of erased elements. - //! - //! <b>Complexity</b>: O(log(size() + N). - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - template<class KeyType, class KeyValueCompare> - size_type erase(const KeyType& key, KeyValueCompare comp - /// @cond - , typename detail::enable_if_c<!detail::is_convertible<KeyValueCompare, const_iterator>::value >::type * = 0 - /// @endcond - ) - { - std::pair<iterator,iterator> p = this->equal_range(key, comp); - size_type n; - private_erase(p.first, p.second, n); - return n; - } - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! - //! <b>Effects</b>: Erases the element pointed to by pos. - //! Disposer::operator()(pointer) is called for the removed element. - //! - //! <b>Complexity</b>: Average complexity for erase element is constant time. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators - //! to the erased elements. - template<class Disposer> - iterator erase_and_dispose(const_iterator i, Disposer disposer) - { - node_ptr to_erase(i.pointed_node()); - iterator ret(this->erase(i)); - disposer(get_real_value_traits().to_value_ptr(to_erase)); - return ret; - } - - #if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) - template<class Disposer> - iterator erase_and_dispose(iterator i, Disposer disposer) - { return this->erase_and_dispose(const_iterator(i), disposer); } - #endif - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! - //! <b>Effects</b>: Erases all the elements with the given value. - //! Disposer::operator()(pointer) is called for the removed elements. - //! - //! <b>Returns</b>: The number of erased elements. - //! - //! <b>Complexity</b>: O(log(size() + N). - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - template<class Disposer> - size_type erase_and_dispose(const_reference value, Disposer disposer) - { - std::pair<iterator,iterator> p = this->equal_range(value); - size_type n; - private_erase(p.first, p.second, n, disposer); - return n; - } - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! - //! <b>Effects</b>: Erases the range pointed to by b end e. - //! Disposer::operator()(pointer) is called for the removed elements. - //! - //! <b>Complexity</b>: Average complexity for erase range is at most - //! O(log(size() + N)), where N is the number of elements in the range. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators - //! to the erased elements. - template<class Disposer> - iterator erase_and_dispose(const_iterator b, const_iterator e, Disposer disposer) - { size_type n; return private_erase(b, e, n, disposer); } - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! - //! <b>Effects</b>: Erases all the elements with the given key. - //! according to the comparison functor "comp". - //! Disposer::operator()(pointer) is called for the removed elements. - //! - //! <b>Returns</b>: The number of erased elements. - //! - //! <b>Complexity</b>: O(log(size() + N). - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators - //! to the erased elements. - template<class KeyType, class KeyValueCompare, class Disposer> - size_type erase_and_dispose(const KeyType& key, KeyValueCompare comp, Disposer disposer - /// @cond - , typename detail::enable_if_c<!detail::is_convertible<KeyValueCompare, const_iterator>::value >::type * = 0 - /// @endcond - ) - { - std::pair<iterator,iterator> p = this->equal_range(key, comp); - size_type n; - private_erase(p.first, p.second, n, disposer); - return n; - } - - //! <b>Effects</b>: Erases all of the elements. - //! - //! <b>Complexity</b>: Linear to the number of elements on the container. - //! if it's a safe-mode or auto-unlink value_type. Constant time otherwise. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - void clear() - { - if(safemode_or_autounlink){ - this->clear_and_dispose(detail::null_disposer()); - } - else{ - node_algorithms::init_header(this->priv_header_ptr()); - this->priv_size_traits().set_size(0); - } - } - - //! <b>Effects</b>: Erases all of the elements calling disposer(p) for - //! each node to be erased. - //! <b>Complexity</b>: Average complexity for is at most O(log(size() + N)), - //! where N is the number of elements in the container. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. Calls N times to disposer functor. - template<class Disposer> - void clear_and_dispose(Disposer disposer) - { - node_algorithms::clear_and_dispose(this->priv_header_ptr() - , detail::node_disposer<Disposer, rbtree_impl>(disposer, this)); - node_algorithms::init_header(this->priv_header_ptr()); - this->priv_size_traits().set_size(0); - } - - //! <b>Effects</b>: Returns the number of contained elements with the given value - //! - //! <b>Complexity</b>: Logarithmic to the number of elements contained plus lineal - //! to number of objects with the given value. - //! - //! <b>Throws</b>: Nothing. - size_type count(const_reference value) const - { return this->count(value, priv_comp()); } - - //! <b>Effects</b>: Returns the number of contained elements with the given key - //! - //! <b>Complexity</b>: Logarithmic to the number of elements contained plus lineal - //! to number of objects with the given key. - //! - //! <b>Throws</b>: Nothing. - template<class KeyType, class KeyValueCompare> - size_type count(const KeyType &key, KeyValueCompare comp) const - { - std::pair<const_iterator, const_iterator> ret = this->equal_range(key, comp); - return std::distance(ret.first, ret.second); - } - - //! <b>Effects</b>: Returns an iterator to the first element whose - //! key is not less than k or end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: Nothing. - iterator lower_bound(const_reference value) - { return this->lower_bound(value, priv_comp()); } - - //! <b>Effects</b>: Returns an iterator to the first element whose - //! key is not less than k or end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: Nothing. - const_iterator lower_bound(const_reference value) const - { return this->lower_bound(value, priv_comp()); } - - //! <b>Effects</b>: Returns an iterator to the first element whose - //! key is not less than k or end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: Nothing. - template<class KeyType, class KeyValueCompare> - iterator lower_bound(const KeyType &key, KeyValueCompare comp) - { - detail::key_nodeptr_comp<KeyValueCompare, rbtree_impl> - key_node_comp(comp, this); - return iterator(node_algorithms::lower_bound - (this->priv_header_ptr(), key, key_node_comp), this); - } - - //! <b>Effects</b>: Returns a const iterator to the first element whose - //! key is not less than k or end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: Nothing. - template<class KeyType, class KeyValueCompare> - const_iterator lower_bound(const KeyType &key, KeyValueCompare comp) const - { - detail::key_nodeptr_comp<KeyValueCompare, rbtree_impl> - key_node_comp(comp, this); - return const_iterator(node_algorithms::lower_bound - (this->priv_header_ptr(), key, key_node_comp), this); - } - - //! <b>Effects</b>: Returns an iterator to the first element whose - //! key is greater than k or end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: Nothing. - iterator upper_bound(const_reference value) - { return this->upper_bound(value, priv_comp()); } - - //! <b>Effects</b>: Returns an iterator to the first element whose - //! key is greater than k according to comp or end() if that element - //! does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: Nothing. - template<class KeyType, class KeyValueCompare> - iterator upper_bound(const KeyType &key, KeyValueCompare comp) - { - detail::key_nodeptr_comp<KeyValueCompare, rbtree_impl> - key_node_comp(comp, this); - return iterator(node_algorithms::upper_bound - (this->priv_header_ptr(), key, key_node_comp), this); - } - - //! <b>Effects</b>: Returns an iterator to the first element whose - //! key is greater than k or end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: Nothing. - const_iterator upper_bound(const_reference value) const - { return this->upper_bound(value, priv_comp()); } - - //! <b>Effects</b>: Returns an iterator to the first element whose - //! key is greater than k according to comp or end() if that element - //! does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: Nothing. - template<class KeyType, class KeyValueCompare> - const_iterator upper_bound(const KeyType &key, KeyValueCompare comp) const - { - detail::key_nodeptr_comp<KeyValueCompare, rbtree_impl> - key_node_comp(comp, this); - return const_iterator(node_algorithms::upper_bound - (this->priv_header_ptr(), key, key_node_comp), this); - } - - //! <b>Effects</b>: Finds an iterator to the first element whose key is - //! k or end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: Nothing. - iterator find(const_reference value) - { return this->find(value, priv_comp()); } - - //! <b>Effects</b>: Finds an iterator to the first element whose key is - //! k or end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: Nothing. - template<class KeyType, class KeyValueCompare> - iterator find(const KeyType &key, KeyValueCompare comp) - { - detail::key_nodeptr_comp<KeyValueCompare, rbtree_impl> - key_node_comp(comp, this); - return iterator - (node_algorithms::find(this->priv_header_ptr(), key, key_node_comp), this); - } - - //! <b>Effects</b>: Finds a const_iterator to the first element whose key is - //! k or end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: Nothing. - const_iterator find(const_reference value) const - { return this->find(value, priv_comp()); } - - //! <b>Effects</b>: Finds a const_iterator to the first element whose key is - //! k or end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: Nothing. - template<class KeyType, class KeyValueCompare> - const_iterator find(const KeyType &key, KeyValueCompare comp) const - { - detail::key_nodeptr_comp<KeyValueCompare, rbtree_impl> - key_node_comp(comp, this); - return const_iterator - (node_algorithms::find(this->priv_header_ptr(), key, key_node_comp), this); - } - - //! <b>Effects</b>: Finds a range containing all elements whose key is k or - //! an empty range that indicates the position where those elements would be - //! if they there is no elements with key k. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: Nothing. - std::pair<iterator,iterator> equal_range(const_reference value) - { return this->equal_range(value, priv_comp()); } - - //! <b>Effects</b>: Finds a range containing all elements whose key is k or - //! an empty range that indicates the position where those elements would be - //! if they there is no elements with key k. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: Nothing. - template<class KeyType, class KeyValueCompare> - std::pair<iterator,iterator> equal_range(const KeyType &key, KeyValueCompare comp) - { - detail::key_nodeptr_comp<KeyValueCompare, rbtree_impl> - key_node_comp(comp, this); - std::pair<node_ptr, node_ptr> ret - (node_algorithms::equal_range(this->priv_header_ptr(), key, key_node_comp)); - return std::pair<iterator, iterator>(iterator(ret.first, this), iterator(ret.second, this)); - } - - //! <b>Effects</b>: Finds a range containing all elements whose key is k or - //! an empty range that indicates the position where those elements would be - //! if they there is no elements with key k. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: Nothing. - std::pair<const_iterator, const_iterator> - equal_range(const_reference value) const - { return this->equal_range(value, priv_comp()); } - - //! <b>Effects</b>: Finds a range containing all elements whose key is k or - //! an empty range that indicates the position where those elements would be - //! if they there is no elements with key k. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: Nothing. - template<class KeyType, class KeyValueCompare> - std::pair<const_iterator, const_iterator> - equal_range(const KeyType &key, KeyValueCompare comp) const - { - detail::key_nodeptr_comp<KeyValueCompare, rbtree_impl> - key_node_comp(comp, this); - std::pair<node_ptr, node_ptr> ret - (node_algorithms::equal_range(this->priv_header_ptr(), key, key_node_comp)); - return std::pair<const_iterator, const_iterator>(const_iterator(ret.first, this), const_iterator(ret.second, this)); - } - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! Cloner should yield to nodes equivalent to the original nodes. - //! - //! <b>Effects</b>: Erases all the elements from *this - //! calling Disposer::operator()(pointer), clones all the - //! elements from src calling Cloner::operator()(const_reference ) - //! and inserts them on *this. Copies the predicate from the source container. - //! - //! If cloner throws, all cloned elements are unlinked and disposed - //! calling Disposer::operator()(pointer). - //! - //! <b>Complexity</b>: Linear to erased plus inserted elements. - //! - //! <b>Throws</b>: If cloner throws or predicate copy assignment throws. Basic guarantee. - template <class Cloner, class Disposer> - void clone_from(const rbtree_impl &src, Cloner cloner, Disposer disposer) - { - this->clear_and_dispose(disposer); - if(!src.empty()){ - detail::exception_disposer<rbtree_impl, Disposer> - rollback(*this, disposer); - node_algorithms::clone - (const_node_ptr(src.priv_header_ptr()) - ,node_ptr(this->priv_header_ptr()) - ,detail::node_cloner<Cloner, rbtree_impl>(cloner, this) - ,detail::node_disposer<Disposer, rbtree_impl>(disposer, this)); - this->priv_size_traits().set_size(src.priv_size_traits().get_size()); - this->priv_comp() = src.priv_comp(); - rollback.release(); - } - } - - //! <b>Effects</b>: Unlinks the leftmost node from the tree. - //! - //! <b>Complexity</b>: Average complexity is constant time. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Notes</b>: This function breaks the tree and the tree can - //! only be used for more unlink_leftmost_without_rebalance calls. - //! This function is normally used to achieve a step by step - //! controlled destruction of the tree. - pointer unlink_leftmost_without_rebalance() - { - node_ptr to_be_disposed(node_algorithms::unlink_leftmost_without_rebalance - (this->priv_header_ptr())); - if(!to_be_disposed) - return 0; - this->priv_size_traits().decrement(); - if(safemode_or_autounlink)//If this is commented does not work with normal_link - node_algorithms::init(to_be_disposed); - return get_real_value_traits().to_value_ptr(to_be_disposed); - } - - //! <b>Requires</b>: replace_this must be a valid iterator of *this - //! and with_this must not be inserted in any tree. - //! - //! <b>Effects</b>: Replaces replace_this in its position in the - //! tree with with_this. The tree does not need to be rebalanced. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: This function will break container ordering invariants if - //! with_this is not equivalent to *replace_this according to the - //! ordering rules. This function is faster than erasing and inserting - //! the node, since no rebalancing or comparison is needed. - void replace_node(iterator replace_this, reference with_this) - { - node_algorithms::replace_node( get_real_value_traits().to_node_ptr(*replace_this) - , this->priv_header_ptr() - , get_real_value_traits().to_node_ptr(with_this)); - if(safemode_or_autounlink) - node_algorithms::init(replace_this.pointed_node()); - } - - //! <b>Requires</b>: value must be an lvalue and shall be in a set of - //! appropriate type. Otherwise the behavior is undefined. - //! - //! <b>Effects</b>: Returns: a valid iterator i belonging to the set - //! that points to the value - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: This static function is available only if the <i>value traits</i> - //! is stateless. - static iterator s_iterator_to(reference value) - { - BOOST_STATIC_ASSERT((!stateful_value_traits)); - return iterator (value_traits::to_node_ptr(value), 0); - } - - //! <b>Requires</b>: value must be an lvalue and shall be in a set of - //! appropriate type. Otherwise the behavior is undefined. - //! - //! <b>Effects</b>: Returns: a valid const_iterator i belonging to the - //! set that points to the value - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: This static function is available only if the <i>value traits</i> - //! is stateless. - static const_iterator s_iterator_to(const_reference value) - { - BOOST_STATIC_ASSERT((!stateful_value_traits)); - return const_iterator (value_traits::to_node_ptr(const_cast<reference> (value)), 0); - } - - //! <b>Requires</b>: value must be an lvalue and shall be in a set of - //! appropriate type. Otherwise the behavior is undefined. - //! - //! <b>Effects</b>: Returns: a valid iterator i belonging to the set - //! that points to the value - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - iterator iterator_to(reference value) - { return iterator (value_traits::to_node_ptr(value), this); } - - //! <b>Requires</b>: value must be an lvalue and shall be in a set of - //! appropriate type. Otherwise the behavior is undefined. - //! - //! <b>Effects</b>: Returns: a valid const_iterator i belonging to the - //! set that points to the value - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_iterator iterator_to(const_reference value) const - { return const_iterator (value_traits::to_node_ptr(const_cast<reference> (value)), this); } - - //! <b>Requires</b>: value shall not be in a tree. - //! - //! <b>Effects</b>: init_node puts the hook of a value in a well-known default - //! state. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant time. - //! - //! <b>Note</b>: This function puts the hook in the well-known default state - //! used by auto_unlink and safe hooks. - static void init_node(reference value) - { node_algorithms::init(value_traits::to_node_ptr(value)); } - - //! <b>Effects</b>: removes "value" from the container. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Logarithmic time. - //! - //! <b>Note</b>: This static function is only usable with non-constant - //! time size containers that have stateless comparison functors. - //! - //! If the user calls - //! this function with a constant time size container or stateful comparison - //! functor a compilation error will be issued. - static void remove_node(reference value) - { - BOOST_STATIC_ASSERT((!constant_time_size)); - node_ptr to_remove(value_traits::to_node_ptr(value)); - node_algorithms::unlink(to_remove); - if(safemode_or_autounlink) - node_algorithms::init(to_remove); - } - - /// @cond - private: - template<class Disposer> - iterator private_erase(const_iterator b, const_iterator e, size_type &n, Disposer disposer) - { - for(n = 0; b != e; ++n) - this->erase_and_dispose(b++, disposer); - return b.unconst(); - } - - iterator private_erase(const_iterator b, const_iterator e, size_type &n) - { - for(n = 0; b != e; ++n) - this->erase(b++); - return b.unconst(); - } - /// @endcond - - private: - static rbtree_impl &priv_container_from_end_iterator(const const_iterator &end_iterator) - { - header_plus_size *r = detail::parent_from_member<header_plus_size, node> - ( boost::intrusive::detail::to_raw_pointer(end_iterator.pointed_node()), &header_plus_size::header_); - node_plus_pred_t *n = detail::parent_from_member - <node_plus_pred_t, header_plus_size>(r, &node_plus_pred_t::header_plus_size_); - data_t *d = detail::parent_from_member<data_t, node_plus_pred_t>(n, &data_t::node_plus_pred_); - rbtree_impl *rb = detail::parent_from_member<rbtree_impl, data_t>(d, &rbtree_impl::data_); - return *rb; - } - - static rbtree_impl &priv_container_from_iterator(const const_iterator &it) - { return priv_container_from_end_iterator(it.end_iterator_from_it()); } -}; - -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -inline bool operator< -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -(const rbtree_impl<T, Options...> &x, const rbtree_impl<T, Options...> &y) -#else -(const rbtree_impl<Config> &x, const rbtree_impl<Config> &y) -#endif -{ return std::lexicographical_compare(x.begin(), x.end(), y.begin(), y.end()); } - -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -bool operator== -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -(const rbtree_impl<T, Options...> &x, const rbtree_impl<T, Options...> &y) -#else -(const rbtree_impl<Config> &x, const rbtree_impl<Config> &y) -#endif -{ - typedef rbtree_impl<Config> tree_type; - typedef typename tree_type::const_iterator const_iterator; - - if(tree_type::constant_time_size && x.size() != y.size()){ - return false; - } - const_iterator end1 = x.end(); - const_iterator i1 = x.begin(); - const_iterator i2 = y.begin(); - if(tree_type::constant_time_size){ - while (i1 != end1 && *i1 == *i2) { - ++i1; - ++i2; - } - return i1 == end1; - } - else{ - const_iterator end2 = y.end(); - while (i1 != end1 && i2 != end2 && *i1 == *i2) { - ++i1; - ++i2; - } - return i1 == end1 && i2 == end2; - } -} - -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -inline bool operator!= -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -(const rbtree_impl<T, Options...> &x, const rbtree_impl<T, Options...> &y) -#else -(const rbtree_impl<Config> &x, const rbtree_impl<Config> &y) -#endif -{ return !(x == y); } - -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -inline bool operator> -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -(const rbtree_impl<T, Options...> &x, const rbtree_impl<T, Options...> &y) -#else -(const rbtree_impl<Config> &x, const rbtree_impl<Config> &y) -#endif -{ return y < x; } - -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -inline bool operator<= -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -(const rbtree_impl<T, Options...> &x, const rbtree_impl<T, Options...> &y) -#else -(const rbtree_impl<Config> &x, const rbtree_impl<Config> &y) -#endif -{ return !(y < x); } - -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -inline bool operator>= -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -(const rbtree_impl<T, Options...> &x, const rbtree_impl<T, Options...> &y) -#else -(const rbtree_impl<Config> &x, const rbtree_impl<Config> &y) -#endif -{ return !(x < y); } - -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -inline void swap -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -(rbtree_impl<T, Options...> &x, rbtree_impl<T, Options...> &y) -#else -(rbtree_impl<Config> &x, rbtree_impl<Config> &y) -#endif -{ x.swap(y); } - -/// @cond -#if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template<class T, class O1 = none, class O2 = none - , class O3 = none, class O4 = none - > -#else -template<class T, class ...Options> -#endif -struct make_rbtree_opt -{ - typedef typename pack_options - < set_defaults<T>, - #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) - O1, O2, O3, O4 - #else - Options... - #endif - >::type packed_options; - typedef typename detail::get_value_traits - <T, typename packed_options::value_traits>::type value_traits; - - typedef setopt - < value_traits - , typename packed_options::compare - , typename packed_options::size_type - , packed_options::constant_time_size - > type; -}; -/// @endcond - -//! Helper metafunction to define a \c rbtree that yields to the same type when the -//! same options (either explicitly or implicitly) are used. -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) || defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template<class T, class ...Options> -#else -template<class T, class O1 = none, class O2 = none - , class O3 = none, class O4 = none> -#endif -struct make_rbtree -{ - /// @cond - typedef rbtree_impl - < typename make_rbtree_opt<T, - #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) - O1, O2, O3, O4 - #else - Options... - #endif - >::type - > implementation_defined; - /// @endcond - typedef implementation_defined type; -}; - -#ifndef BOOST_INTRUSIVE_DOXYGEN_INVOKED - -#if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template<class T, class O1, class O2, class O3, class O4> -#else -template<class T, class ...Options> -#endif -class rbtree - : public make_rbtree<T, - #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) - O1, O2, O3, O4 - #else - Options... - #endif - >::type -{ - typedef typename make_rbtree - <T, - #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) - O1, O2, O3, O4 - #else - Options... - #endif - >::type Base; - BOOST_MOVABLE_BUT_NOT_COPYABLE(rbtree) - - public: - typedef typename Base::value_compare value_compare; - typedef typename Base::value_traits value_traits; - typedef typename Base::real_value_traits real_value_traits; - typedef typename Base::iterator iterator; - typedef typename Base::const_iterator const_iterator; - - //Assert if passed value traits are compatible with the type - BOOST_STATIC_ASSERT((detail::is_same<typename real_value_traits::value_type, T>::value)); - - rbtree( const value_compare &cmp = value_compare() - , const value_traits &v_traits = value_traits()) - : Base(cmp, v_traits) - {} - - template<class Iterator> - rbtree( bool unique, Iterator b, Iterator e - , const value_compare &cmp = value_compare() - , const value_traits &v_traits = value_traits()) - : Base(unique, b, e, cmp, v_traits) - {} - - rbtree(BOOST_RV_REF(rbtree) x) - : Base(::boost::move(static_cast<Base&>(x))) - {} - - rbtree& operator=(BOOST_RV_REF(rbtree) x) - { this->Base::operator=(::boost::move(static_cast<Base&>(x))); return *this; } - - static rbtree &container_from_end_iterator(iterator end_iterator) - { return static_cast<rbtree &>(Base::container_from_end_iterator(end_iterator)); } - - static const rbtree &container_from_end_iterator(const_iterator end_iterator) - { return static_cast<const rbtree &>(Base::container_from_end_iterator(end_iterator)); } - - static rbtree &container_from_it(iterator it) - { return static_cast<rbtree &>(Base::container_from_iterator(it)); } - - static const rbtree &container_from_it(const_iterator it) - { return static_cast<const rbtree &>(Base::container_from_iterator(it)); } -}; - -#endif - - -} //namespace intrusive -} //namespace boost - -#include <boost/intrusive/detail/config_end.hpp> - -#endif //BOOST_INTRUSIVE_RBTREE_HPP diff --git a/src/third_party/boost/boost/intrusive/rbtree_algorithms.hpp b/src/third_party/boost/boost/intrusive/rbtree_algorithms.hpp deleted file mode 100644 index de012c2cad8..00000000000 --- a/src/third_party/boost/boost/intrusive/rbtree_algorithms.hpp +++ /dev/null @@ -1,910 +0,0 @@ -///////////////////////////////////////////////////////////////////////////// -// -// (C) Copyright Olaf Krzikalla 2004-2006. -// (C) Copyright Ion Gaztanaga 2006-2009. -// -// Distributed under the Boost Software License, Version 1.0. -// (See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) -// -// See http://www.boost.org/libs/intrusive for documentation. -// -///////////////////////////////////////////////////////////////////////////// -// The internal implementation of red-black trees is based on that of SGI STL -// stl_tree.h file: -// -// Copyright (c) 1996,1997 -// Silicon Graphics Computer Systems, Inc. -// -// Permission to use, copy, modify, distribute and sell this software -// and its documentation for any purpose is hereby granted without fee, -// provided that the above copyright notice appear in all copies and -// that both that copyright notice and this permission notice appear -// in supporting documentation. Silicon Graphics makes no -// representations about the suitability of this software for any -// purpose. It is provided "as is" without express or implied warranty. -// -// -// Copyright (c) 1994 -// Hewlett-Packard Company -// -// Permission to use, copy, modify, distribute and sell this software -// and its documentation for any purpose is hereby granted without fee, -// provided that the above copyright notice appear in all copies and -// that both that copyright notice and this permission notice appear -// in supporting documentation. Hewlett-Packard Company makes no -// representations about the suitability of this software for any -// purpose. It is provided "as is" without express or implied warranty. -// -// The tree destruction algorithm is based on Julienne Walker and The EC Team code: -// -// This code is in the public domain. Anyone may use it or change it in any way that -// they see fit. The author assumes no responsibility for damages incurred through -// use of the original code or any variations thereof. -// -// It is requested, but not required, that due credit is given to the original author -// and anyone who has modified the code through a header comment, such as this one. - -#ifndef BOOST_INTRUSIVE_RBTREE_ALGORITHMS_HPP -#define BOOST_INTRUSIVE_RBTREE_ALGORITHMS_HPP - -#include <boost/intrusive/detail/config_begin.hpp> - -#include <cstddef> -#include <boost/intrusive/intrusive_fwd.hpp> - -#include <boost/intrusive/detail/assert.hpp> -#include <boost/intrusive/detail/utilities.hpp> -#include <boost/intrusive/detail/tree_algorithms.hpp> -#include <boost/intrusive/pointer_traits.hpp> - -namespace boost { -namespace intrusive { - -//! rbtree_algorithms provides basic algorithms to manipulate -//! nodes forming a red-black tree. The insertion and deletion algorithms are -//! based on those in Cormen, Leiserson, and Rivest, Introduction to Algorithms -//! (MIT Press, 1990), except that -//! -//! (1) the header node is maintained with links not only to the root -//! but also to the leftmost node of the tree, to enable constant time -//! begin(), and to the rightmost node of the tree, to enable linear time -//! performance when used with the generic set algorithms (set_union, -//! etc.); -//! -//! (2) when a node being deleted has two children its successor node is -//! relinked into its place, rather than copied, so that the only -//! pointers invalidated are those referring to the deleted node. -//! -//! rbtree_algorithms is configured with a NodeTraits class, which encapsulates the -//! information about the node to be manipulated. NodeTraits must support the -//! following interface: -//! -//! <b>Typedefs</b>: -//! -//! <tt>node</tt>: The type of the node that forms the circular list -//! -//! <tt>node_ptr</tt>: A pointer to a node -//! -//! <tt>const_node_ptr</tt>: A pointer to a const node -//! -//! <tt>color</tt>: The type that can store the color of a node -//! -//! <b>Static functions</b>: -//! -//! <tt>static node_ptr get_parent(const_node_ptr n);</tt> -//! -//! <tt>static void set_parent(node_ptr n, node_ptr parent);</tt> -//! -//! <tt>static node_ptr get_left(const_node_ptr n);</tt> -//! -//! <tt>static void set_left(node_ptr n, node_ptr left);</tt> -//! -//! <tt>static node_ptr get_right(const_node_ptr n);</tt> -//! -//! <tt>static void set_right(node_ptr n, node_ptr right);</tt> -//! -//! <tt>static color get_color(const_node_ptr n);</tt> -//! -//! <tt>static void set_color(node_ptr n, color c);</tt> -//! -//! <tt>static color black();</tt> -//! -//! <tt>static color red();</tt> -template<class NodeTraits> -class rbtree_algorithms -{ - public: - typedef NodeTraits node_traits; - typedef typename NodeTraits::node node; - typedef typename NodeTraits::node_ptr node_ptr; - typedef typename NodeTraits::const_node_ptr const_node_ptr; - typedef typename NodeTraits::color color; - - /// @cond - private: - - typedef detail::tree_algorithms<NodeTraits> tree_algorithms; - - template<class F> - struct rbtree_node_cloner - : private detail::ebo_functor_holder<F> - { - typedef detail::ebo_functor_holder<F> base_t; - - rbtree_node_cloner(F f) - : base_t(f) - {} - - node_ptr operator()(const node_ptr & p) - { - node_ptr n = base_t::get()(p); - NodeTraits::set_color(n, NodeTraits::get_color(p)); - return n; - } - }; - - struct rbtree_erase_fixup - { - void operator()(const node_ptr & to_erase, const node_ptr & successor) - { - //Swap color of y and z - color tmp(NodeTraits::get_color(successor)); - NodeTraits::set_color(successor, NodeTraits::get_color(to_erase)); - NodeTraits::set_color(to_erase, tmp); - } - }; - - static node_ptr uncast(const const_node_ptr & ptr) - { return pointer_traits<node_ptr>::const_cast_from(ptr); } - /// @endcond - - public: - static node_ptr begin_node(const const_node_ptr & header) - { return tree_algorithms::begin_node(header); } - - static node_ptr end_node(const const_node_ptr & header) - { return tree_algorithms::end_node(header); } - - //! This type is the information that will be - //! filled by insert_unique_check - typedef typename tree_algorithms::insert_commit_data insert_commit_data; - - //! <b>Requires</b>: header1 and header2 must be the header nodes - //! of two trees. - //! - //! <b>Effects</b>: Swaps two trees. After the function header1 will contain - //! links to the second tree and header2 will have links to the first tree. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - static void swap_tree(const node_ptr & header1, const node_ptr & header2) - { return tree_algorithms::swap_tree(header1, header2); } - - //! <b>Requires</b>: node1 and node2 can't be header nodes - //! of two trees. - //! - //! <b>Effects</b>: Swaps two nodes. After the function node1 will be inserted - //! in the position node2 before the function. node2 will be inserted in the - //! position node1 had before the function. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: This function will break container ordering invariants if - //! node1 and node2 are not equivalent according to the ordering rules. - //! - //!Experimental function - static void swap_nodes(const node_ptr & node1, const node_ptr & node2) - { - if(node1 == node2) - return; - - node_ptr header1(tree_algorithms::get_header(node1)), header2(tree_algorithms::get_header(node2)); - swap_nodes(node1, header1, node2, header2); - } - - //! <b>Requires</b>: node1 and node2 can't be header nodes - //! of two trees with header header1 and header2. - //! - //! <b>Effects</b>: Swaps two nodes. After the function node1 will be inserted - //! in the position node2 before the function. node2 will be inserted in the - //! position node1 had before the function. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: This function will break container ordering invariants if - //! node1 and node2 are not equivalent according to the ordering rules. - //! - //!Experimental function - static void swap_nodes(const node_ptr & node1, const node_ptr & header1, const node_ptr & node2, const node_ptr & header2) - { - if(node1 == node2) return; - - tree_algorithms::swap_nodes(node1, header1, node2, header2); - //Swap color - color c = NodeTraits::get_color(node1); - NodeTraits::set_color(node1, NodeTraits::get_color(node2)); - NodeTraits::set_color(node2, c); - } - - //! <b>Requires</b>: node_to_be_replaced must be inserted in a tree - //! and new_node must not be inserted in a tree. - //! - //! <b>Effects</b>: Replaces node_to_be_replaced in its position in the - //! tree with new_node. The tree does not need to be rebalanced - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: This function will break container ordering invariants if - //! 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 - static void replace_node(const node_ptr & node_to_be_replaced, const node_ptr & new_node) - { - if(node_to_be_replaced == new_node) - return; - replace_node(node_to_be_replaced, tree_algorithms::get_header(node_to_be_replaced), new_node); - } - - //! <b>Requires</b>: node_to_be_replaced must be inserted in a tree - //! with header "header" and new_node must not be inserted in a tree. - //! - //! <b>Effects</b>: Replaces node_to_be_replaced in its position in the - //! tree with new_node. The tree does not need to be rebalanced - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: This function will break container ordering invariants if - //! 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 or comparison is needed. - //! - //!Experimental function - static void replace_node(const node_ptr & node_to_be_replaced, const node_ptr & header, const node_ptr & new_node) - { - tree_algorithms::replace_node(node_to_be_replaced, header, new_node); - NodeTraits::set_color(new_node, NodeTraits::get_color(node_to_be_replaced)); - } - - //! <b>Requires</b>: node is a tree node but not the header. - //! - //! <b>Effects</b>: Unlinks the node and rebalances the tree. - //! - //! <b>Complexity</b>: Average complexity is constant time. - //! - //! <b>Throws</b>: Nothing. - static void unlink(const node_ptr & node) - { - node_ptr x = NodeTraits::get_parent(node); - if(x){ - while(!is_header(x)) - x = NodeTraits::get_parent(x); - erase(x, node); - } - } - - //! <b>Requires</b>: header is the header of a tree. - //! - //! <b>Effects</b>: Unlinks the leftmost node from the tree, and - //! updates the header link to the new leftmost node. - //! - //! <b>Complexity</b>: Average complexity is constant time. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Notes</b>: This function breaks the tree and the tree can - //! only be used for more unlink_leftmost_without_rebalance calls. - //! This function is normally used to achieve a step by step - //! controlled destruction of the tree. - static node_ptr unlink_leftmost_without_rebalance(const node_ptr & header) - { return tree_algorithms::unlink_leftmost_without_rebalance(header); } - - //! <b>Requires</b>: node is a node of the tree or an node initialized - //! by init(...). - //! - //! <b>Effects</b>: Returns true if the node is initialized by init(). - //! - //! <b>Complexity</b>: Constant time. - //! - //! <b>Throws</b>: Nothing. - static bool unique(const const_node_ptr & node) - { return tree_algorithms::unique(node); } - - //! <b>Requires</b>: node is a node of the tree but it's not the header. - //! - //! <b>Effects</b>: Returns the number of nodes of the subtree. - //! - //! <b>Complexity</b>: Linear time. - //! - //! <b>Throws</b>: Nothing. - static std::size_t count(const const_node_ptr & node) - { return tree_algorithms::count(node); } - - //! <b>Requires</b>: header is the header node of the tree. - //! - //! <b>Effects</b>: Returns the number of nodes above the header. - //! - //! <b>Complexity</b>: Linear time. - //! - //! <b>Throws</b>: Nothing. - static std::size_t size(const const_node_ptr & header) - { return tree_algorithms::size(header); } - - //! <b>Requires</b>: p is a node from the tree except the header. - //! - //! <b>Effects</b>: Returns the next node of the tree. - //! - //! <b>Complexity</b>: Average constant time. - //! - //! <b>Throws</b>: Nothing. - static node_ptr next_node(const node_ptr & p) - { return tree_algorithms::next_node(p); } - - //! <b>Requires</b>: p is a node from the tree except the leftmost node. - //! - //! <b>Effects</b>: Returns the previous node of the tree. - //! - //! <b>Complexity</b>: Average constant time. - //! - //! <b>Throws</b>: Nothing. - static node_ptr prev_node(const node_ptr & p) - { return tree_algorithms::prev_node(p); } - - //! <b>Requires</b>: node must not be part of any tree. - //! - //! <b>Effects</b>: After the function unique(node) == true. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Nodes</b>: If node is inserted in a tree, this function corrupts the tree. - static void init(const node_ptr & node) - { tree_algorithms::init(node); } - - //! <b>Requires</b>: node must not be part of any tree. - //! - //! <b>Effects</b>: Initializes the header to represent an empty tree. - //! unique(header) == true. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Nodes</b>: If node is inserted in a tree, this function corrupts the tree. - static void init_header(const node_ptr & header) - { - tree_algorithms::init_header(header); - NodeTraits::set_color(header, NodeTraits::red()); - } - - //! <b>Requires</b>: header must be the header of a tree, z a node - //! of that tree and z != header. - //! - //! <b>Effects</b>: Erases node "z" from the tree with header "header". - //! - //! <b>Complexity</b>: Amortized constant time. - //! - //! <b>Throws</b>: Nothing. - static node_ptr erase(const node_ptr & header, const node_ptr & z) - { - typename tree_algorithms::data_for_rebalance info; - tree_algorithms::erase(header, z, rbtree_erase_fixup(), info); - node_ptr x = info.x; - node_ptr x_parent = info.x_parent; - - //Rebalance rbtree - if(NodeTraits::get_color(z) != NodeTraits::red()){ - rebalance_after_erasure(header, x, x_parent); - } - return z; - } - - //! <b>Requires</b>: "cloner" must be a function - //! object taking a node_ptr and returning a new cloned node of it. "disposer" must - //! take a node_ptr and shouldn't throw. - //! - //! <b>Effects</b>: First empties target tree calling - //! <tt>void disposer::operator()(const node_ptr &)</tt> for every node of the tree - //! except the header. - //! - //! Then, duplicates the entire tree pointed by "source_header" cloning each - //! source node with <tt>node_ptr Cloner::operator()(const node_ptr &)</tt> to obtain - //! the nodes of the target tree. If "cloner" throws, the cloned target nodes - //! are disposed using <tt>void disposer(const node_ptr &)</tt>. - //! - //! <b>Complexity</b>: Linear to the number of element of the source tree plus the. - //! number of elements of tree target tree when calling this function. - //! - //! <b>Throws</b>: If cloner functor throws. If this happens target nodes are disposed. - template <class Cloner, class Disposer> - static void clone - (const const_node_ptr & source_header, const node_ptr & target_header, Cloner cloner, Disposer disposer) - { - rbtree_node_cloner<Cloner> new_cloner(cloner); - tree_algorithms::clone(source_header, target_header, new_cloner, disposer); - } - - //! <b>Requires</b>: "disposer" must be an object function - //! taking a node_ptr parameter and shouldn't throw. - //! - //! <b>Effects</b>: Empties the target tree calling - //! <tt>void disposer::operator()(const node_ptr &)</tt> for every node of the tree - //! except the header. - //! - //! <b>Complexity</b>: Linear to the number of element of the source tree plus the. - //! number of elements of tree target tree when calling this function. - //! - //! <b>Throws</b>: If cloner functor throws. If this happens target nodes are disposed. - template<class Disposer> - static void clear_and_dispose(const node_ptr & header, Disposer disposer) - { tree_algorithms::clear_and_dispose(header, disposer); } - - //! <b>Requires</b>: "header" must be the header node of a tree. - //! KeyNodePtrCompare is a function object that induces a strict weak - //! ordering compatible with the strict weak ordering used to create the - //! the tree. KeyNodePtrCompare can compare KeyType with tree's node_ptrs. - //! - //! <b>Effects</b>: Returns an node_ptr to the first element that is - //! not less than "key" according to "comp" or "header" if that element does - //! not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If "comp" throws. - template<class KeyType, class KeyNodePtrCompare> - static node_ptr lower_bound - (const const_node_ptr & header, const KeyType &key, KeyNodePtrCompare comp) - { return tree_algorithms::lower_bound(header, key, comp); } - - //! <b>Requires</b>: "header" must be the header node of a tree. - //! KeyNodePtrCompare is a function object that induces a strict weak - //! ordering compatible with the strict weak ordering used to create the - //! the tree. KeyNodePtrCompare can compare KeyType with tree's node_ptrs. - //! - //! <b>Effects</b>: Returns an node_ptr to the first element that is greater - //! than "key" according to "comp" or "header" if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If "comp" throws. - template<class KeyType, class KeyNodePtrCompare> - static node_ptr upper_bound - (const const_node_ptr & header, const KeyType &key, KeyNodePtrCompare comp) - { return tree_algorithms::upper_bound(header, key, comp); } - - //! <b>Requires</b>: "header" must be the header node of a tree. - //! KeyNodePtrCompare is a function object that induces a strict weak - //! ordering compatible with the strict weak ordering used to create the - //! the tree. KeyNodePtrCompare can compare KeyType with tree's node_ptrs. - //! - //! <b>Effects</b>: Returns an node_ptr to the element that is equivalent to - //! "key" according to "comp" or "header" if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If "comp" throws. - template<class KeyType, class KeyNodePtrCompare> - static node_ptr find - (const const_node_ptr & header, const KeyType &key, KeyNodePtrCompare comp) - { return tree_algorithms::find(header, key, comp); } - - //! <b>Requires</b>: "header" must be the header node of a tree. - //! KeyNodePtrCompare is a function object that induces a strict weak - //! ordering compatible with the strict weak ordering used to create the - //! the tree. KeyNodePtrCompare can compare KeyType with tree's node_ptrs. - //! - //! <b>Effects</b>: Returns an a pair of node_ptr delimiting a range containing - //! all elements that are equivalent to "key" according to "comp" or an - //! empty range that indicates the position where those elements would be - //! if they there are no equivalent elements. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If "comp" throws. - template<class KeyType, class KeyNodePtrCompare> - static std::pair<node_ptr, node_ptr> equal_range - (const const_node_ptr & header, const KeyType &key, KeyNodePtrCompare comp) - { return tree_algorithms::equal_range(header, key, comp); } - - //! <b>Requires</b>: "h" must be the header node of a tree. - //! NodePtrCompare is a function object that induces a strict weak - //! ordering compatible with the strict weak ordering used to create the - //! the tree. NodePtrCompare compares two node_ptrs. - //! - //! <b>Effects</b>: Inserts new_node into the tree before the upper bound - //! according to "comp". - //! - //! <b>Complexity</b>: Average complexity for insert element is at - //! most logarithmic. - //! - //! <b>Throws</b>: If "comp" throws. - template<class NodePtrCompare> - static node_ptr insert_equal_upper_bound - (const node_ptr & h, const node_ptr & new_node, NodePtrCompare comp) - { - tree_algorithms::insert_equal_upper_bound(h, new_node, comp); - rebalance_after_insertion(h, new_node); - return new_node; - } - - //! <b>Requires</b>: "h" must be the header node of a tree. - //! NodePtrCompare is a function object that induces a strict weak - //! ordering compatible with the strict weak ordering used to create the - //! the tree. NodePtrCompare compares two node_ptrs. - //! - //! <b>Effects</b>: Inserts new_node into the tree before the lower bound - //! according to "comp". - //! - //! <b>Complexity</b>: Average complexity for insert element is at - //! most logarithmic. - //! - //! <b>Throws</b>: If "comp" throws. - template<class NodePtrCompare> - static node_ptr insert_equal_lower_bound - (const node_ptr & h, const node_ptr & new_node, NodePtrCompare comp) - { - tree_algorithms::insert_equal_lower_bound(h, new_node, comp); - rebalance_after_insertion(h, new_node); - return new_node; - } - - //! <b>Requires</b>: "header" must be the header node of a tree. - //! NodePtrCompare is a function object that induces a strict weak - //! ordering compatible with the strict weak ordering used to create the - //! the tree. NodePtrCompare compares two node_ptrs. "hint" is node from - //! the "header"'s tree. - //! - //! <b>Effects</b>: Inserts new_node into the tree, using "hint" as a hint to - //! where it will be inserted. If "hint" is the upper_bound - //! the insertion takes constant time (two comparisons in the worst case). - //! - //! <b>Complexity</b>: Logarithmic in general, but it is amortized - //! constant time if new_node is inserted immediately before "hint". - //! - //! <b>Throws</b>: If "comp" throws. - template<class NodePtrCompare> - static node_ptr insert_equal - (const node_ptr & header, const node_ptr & hint, const node_ptr & new_node, NodePtrCompare comp) - { - tree_algorithms::insert_equal(header, hint, new_node, comp); - rebalance_after_insertion(header, new_node); - return new_node; - } - - //! <b>Requires</b>: "header" must be the header node of a tree. - //! "pos" must be a valid iterator or header (end) node. - //! "pos" must be an iterator pointing to the successor to "new_node" - //! once inserted according to the order of already inserted nodes. This function does not - //! check "pos" and this precondition must be guaranteed by the caller. - //! - //! <b>Effects</b>: Inserts new_node into the tree before "pos". - //! - //! <b>Complexity</b>: Constant-time. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: If "pos" is not the successor of the newly inserted "new_node" - //! tree invariants might be broken. - static node_ptr insert_before - (const node_ptr & header, const node_ptr & pos, const node_ptr & new_node) - { - tree_algorithms::insert_before(header, pos, new_node); - rebalance_after_insertion(header, new_node); - return new_node; - } - - //! <b>Requires</b>: "header" must be the header node of a tree. - //! "new_node" must be, according to the used ordering no less than the - //! greatest inserted key. - //! - //! <b>Effects</b>: Inserts new_node into the tree before "pos". - //! - //! <b>Complexity</b>: Constant-time. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: If "new_node" is less than the greatest inserted key - //! tree invariants are broken. This function is slightly faster than - //! using "insert_before". - static void push_back(const node_ptr & header, const node_ptr & new_node) - { - tree_algorithms::push_back(header, new_node); - rebalance_after_insertion(header, new_node); - } - - //! <b>Requires</b>: "header" must be the header node of a tree. - //! "new_node" must be, according to the used ordering, no greater than the - //! lowest inserted key. - //! - //! <b>Effects</b>: Inserts new_node into the tree before "pos". - //! - //! <b>Complexity</b>: Constant-time. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: If "new_node" is greater than the lowest inserted key - //! tree invariants are broken. This function is slightly faster than - //! using "insert_before". - static void push_front(const node_ptr & header, const node_ptr & new_node) - { - tree_algorithms::push_front(header, new_node); - rebalance_after_insertion(header, new_node); - } - - //! <b>Requires</b>: "header" must be the header node of a tree. - //! KeyNodePtrCompare is a function object that induces a strict weak - //! ordering compatible with the strict weak ordering used to create the - //! the tree. NodePtrCompare compares KeyType with a node_ptr. - //! - //! <b>Effects</b>: Checks if there is an equivalent node to "key" in the - //! tree according to "comp" and obtains the needed information to realize - //! a constant-time node insertion if there is no equivalent node. - //! - //! <b>Returns</b>: If there is an equivalent value - //! returns a pair containing a node_ptr to the already present node - //! and false. If there is not equivalent key can be inserted returns true - //! in the returned pair's boolean and fills "commit_data" that is meant to - //! be used with the "insert_commit" function to achieve a constant-time - //! insertion function. - //! - //! <b>Complexity</b>: Average complexity is at most logarithmic. - //! - //! <b>Throws</b>: If "comp" throws. - //! - //! <b>Notes</b>: This function is used to improve performance when constructing - //! a node is expensive and the user does not want to have two equivalent nodes - //! in the tree: if there is an equivalent value - //! the constructed object must be discarded. Many times, the part of the - //! node that is used to impose the order is much cheaper to construct - //! than the node and this function offers the possibility to use that part - //! to check if the insertion will be successful. - //! - //! If the check is successful, the user can construct the node and use - //! "insert_commit" to insert the node in constant-time. This gives a total - //! logarithmic complexity to the insertion: check(O(log(N)) + commit(O(1)). - //! - //! "commit_data" remains valid for a subsequent "insert_unique_commit" only - //! if no more objects are inserted or erased from the set. - template<class KeyType, class KeyNodePtrCompare> - static std::pair<node_ptr, bool> insert_unique_check - (const const_node_ptr & header, const KeyType &key - ,KeyNodePtrCompare comp, insert_commit_data &commit_data) - { return tree_algorithms::insert_unique_check(header, key, comp, commit_data); } - - //! <b>Requires</b>: "header" must be the header node of a tree. - //! KeyNodePtrCompare is a function object that induces a strict weak - //! ordering compatible with the strict weak ordering used to create the - //! the tree. NodePtrCompare compares KeyType with a node_ptr. - //! "hint" is node from the "header"'s tree. - //! - //! <b>Effects</b>: Checks if there is an equivalent node to "key" in the - //! tree according to "comp" using "hint" as a hint to where it should be - //! inserted and obtains the needed information to realize - //! a constant-time node insertion if there is no equivalent node. - //! If "hint" is the upper_bound the function has constant time - //! complexity (two comparisons in the worst case). - //! - //! <b>Returns</b>: If there is an equivalent value - //! returns a pair containing a node_ptr to the already present node - //! and false. If there is not equivalent key can be inserted returns true - //! in the returned pair's boolean and fills "commit_data" that is meant to - //! be used with the "insert_commit" function to achieve a constant-time - //! insertion function. - //! - //! <b>Complexity</b>: Average complexity is at most logarithmic, but it is - //! amortized constant time if new_node should be inserted immediately before "hint". - //! - //! <b>Throws</b>: If "comp" throws. - //! - //! <b>Notes</b>: This function is used to improve performance when constructing - //! a node is expensive and the user does not want to have two equivalent nodes - //! in the tree: if there is an equivalent value - //! the constructed object must be discarded. Many times, the part of the - //! node that is used to impose the order is much cheaper to construct - //! than the node and this function offers the possibility to use that part - //! to check if the insertion will be successful. - //! - //! If the check is successful, the user can construct the node and use - //! "insert_commit" to insert the node in constant-time. This gives a total - //! logarithmic complexity to the insertion: check(O(log(N)) + commit(O(1)). - //! - //! "commit_data" remains valid for a subsequent "insert_unique_commit" only - //! if no more objects are inserted or erased from the set. - template<class KeyType, class KeyNodePtrCompare> - static std::pair<node_ptr, bool> insert_unique_check - (const const_node_ptr & header, const node_ptr &hint, const KeyType &key - ,KeyNodePtrCompare comp, insert_commit_data &commit_data) - { return tree_algorithms::insert_unique_check(header, hint, key, comp, commit_data); } - - //! <b>Requires</b>: "header" must be the header node of a tree. - //! "commit_data" must have been obtained from a previous call to - //! "insert_unique_check". No objects should have been inserted or erased - //! from the set between the "insert_unique_check" that filled "commit_data" - //! and the call to "insert_commit". - //! - //! - //! <b>Effects</b>: Inserts new_node in the set using the information obtained - //! from the "commit_data" that a previous "insert_check" filled. - //! - //! <b>Complexity</b>: Constant time. - //! - //! <b>Throws</b>: Nothing. - //! - //! <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. - static void insert_unique_commit - (const node_ptr & header, const node_ptr & new_value, const insert_commit_data &commit_data) - { - tree_algorithms::insert_unique_commit(header, new_value, commit_data); - rebalance_after_insertion(header, new_value); - } - - //! <b>Requires</b>: "n" must be a node inserted in a tree. - //! - //! <b>Effects</b>: Returns a pointer to the header node of the tree. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: Nothing. - static node_ptr get_header(const node_ptr & n) - { return tree_algorithms::get_header(n); } - - /// @cond - private: - - //! <b>Requires</b>: p is a node of a tree. - //! - //! <b>Effects</b>: Returns true if p is the header of the tree. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - static bool is_header(const const_node_ptr & p) - { - return NodeTraits::get_color(p) == NodeTraits::red() && - tree_algorithms::is_header(p); - //return NodeTraits::get_color(p) == NodeTraits::red() && - // NodeTraits::get_parent(NodeTraits::get_parent(p)) == p; - } - - static void rebalance_after_erasure(const node_ptr & header, const node_ptr &xnode, const node_ptr &xnode_parent) - { - node_ptr x(xnode), x_parent(xnode_parent); - while(x != NodeTraits::get_parent(header) && (x == node_ptr() || NodeTraits::get_color(x) == NodeTraits::black())){ - if(x == NodeTraits::get_left(x_parent)){ - node_ptr w = NodeTraits::get_right(x_parent); - if(NodeTraits::get_color(w) == NodeTraits::red()){ - NodeTraits::set_color(w, NodeTraits::black()); - NodeTraits::set_color(x_parent, NodeTraits::red()); - tree_algorithms::rotate_left(x_parent, header); - w = NodeTraits::get_right(x_parent); - } - if((NodeTraits::get_left(w) == node_ptr() || NodeTraits::get_color(NodeTraits::get_left(w)) == NodeTraits::black()) && - (NodeTraits::get_right(w) == node_ptr() || NodeTraits::get_color(NodeTraits::get_right(w)) == NodeTraits::black())){ - NodeTraits::set_color(w, NodeTraits::red()); - x = x_parent; - x_parent = NodeTraits::get_parent(x_parent); - } - else { - if(NodeTraits::get_right(w) == node_ptr() || NodeTraits::get_color(NodeTraits::get_right(w)) == NodeTraits::black()){ - NodeTraits::set_color(NodeTraits::get_left(w), NodeTraits::black()); - NodeTraits::set_color(w, NodeTraits::red()); - tree_algorithms::rotate_right(w, header); - w = NodeTraits::get_right(x_parent); - } - NodeTraits::set_color(w, NodeTraits::get_color(x_parent)); - NodeTraits::set_color(x_parent, NodeTraits::black()); - if(NodeTraits::get_right(w)) - NodeTraits::set_color(NodeTraits::get_right(w), NodeTraits::black()); - tree_algorithms::rotate_left(x_parent, header); - break; - } - } - else { - // same as above, with right_ <-> left_. - node_ptr w = NodeTraits::get_left(x_parent); - if(NodeTraits::get_color(w) == NodeTraits::red()){ - NodeTraits::set_color(w, NodeTraits::black()); - NodeTraits::set_color(x_parent, NodeTraits::red()); - tree_algorithms::rotate_right(x_parent, header); - w = NodeTraits::get_left(x_parent); - } - if((NodeTraits::get_right(w) == node_ptr() || NodeTraits::get_color(NodeTraits::get_right(w)) == NodeTraits::black()) && - (NodeTraits::get_left(w) == node_ptr() || NodeTraits::get_color(NodeTraits::get_left(w)) == NodeTraits::black())){ - NodeTraits::set_color(w, NodeTraits::red()); - x = x_parent; - x_parent = NodeTraits::get_parent(x_parent); - } - else { - if(NodeTraits::get_left(w) == node_ptr() || NodeTraits::get_color(NodeTraits::get_left(w)) == NodeTraits::black()){ - NodeTraits::set_color(NodeTraits::get_right(w), NodeTraits::black()); - NodeTraits::set_color(w, NodeTraits::red()); - tree_algorithms::rotate_left(w, header); - w = NodeTraits::get_left(x_parent); - } - NodeTraits::set_color(w, NodeTraits::get_color(x_parent)); - NodeTraits::set_color(x_parent, NodeTraits::black()); - if(NodeTraits::get_left(w)) - NodeTraits::set_color(NodeTraits::get_left(w), NodeTraits::black()); - tree_algorithms::rotate_right(x_parent, header); - break; - } - } - } - if(x) - NodeTraits::set_color(x, NodeTraits::black()); - } - - - static void rebalance_after_insertion(const node_ptr & header, const node_ptr &pnode) - { - node_ptr p(pnode); - NodeTraits::set_color(p, NodeTraits::red()); - while(p != NodeTraits::get_parent(header) && NodeTraits::get_color(NodeTraits::get_parent(p)) == NodeTraits::red()){ - node_ptr p_parent(NodeTraits::get_parent(p)); - node_ptr p_parent_parent(NodeTraits::get_parent(p_parent)); - if(tree_algorithms::is_left_child(p_parent)){ - node_ptr x = NodeTraits::get_right(p_parent_parent); - if(x && NodeTraits::get_color(x) == NodeTraits::red()){ - NodeTraits::set_color(p_parent, NodeTraits::black()); - NodeTraits::set_color(p_parent_parent, NodeTraits::red()); - NodeTraits::set_color(x, NodeTraits::black()); - p = p_parent_parent; - } - else { - if(!tree_algorithms::is_left_child(p)){ - p = p_parent; - tree_algorithms::rotate_left(p, header); - } - node_ptr new_p_parent(NodeTraits::get_parent(p)); - node_ptr new_p_parent_parent(NodeTraits::get_parent(new_p_parent)); - NodeTraits::set_color(new_p_parent, NodeTraits::black()); - NodeTraits::set_color(new_p_parent_parent, NodeTraits::red()); - tree_algorithms::rotate_right(new_p_parent_parent, header); - } - } - else{ - node_ptr x = NodeTraits::get_left(p_parent_parent); - if(x && NodeTraits::get_color(x) == NodeTraits::red()){ - NodeTraits::set_color(p_parent, NodeTraits::black()); - NodeTraits::set_color(p_parent_parent, NodeTraits::red()); - NodeTraits::set_color(x, NodeTraits::black()); - p = p_parent_parent; - } - else{ - if(tree_algorithms::is_left_child(p)){ - p = p_parent; - tree_algorithms::rotate_right(p, header); - } - node_ptr new_p_parent(NodeTraits::get_parent(p)); - node_ptr new_p_parent_parent(NodeTraits::get_parent(new_p_parent)); - NodeTraits::set_color(new_p_parent, NodeTraits::black()); - NodeTraits::set_color(new_p_parent_parent, NodeTraits::red()); - tree_algorithms::rotate_left(new_p_parent_parent, header); - } - } - } - NodeTraits::set_color(NodeTraits::get_parent(header), NodeTraits::black()); - } - /// @endcond -}; - -} //namespace intrusive -} //namespace boost - -#include <boost/intrusive/detail/config_end.hpp> - -#endif //BOOST_INTRUSIVE_RBTREE_ALGORITHMS_HPP diff --git a/src/third_party/boost/boost/intrusive/set.hpp b/src/third_party/boost/boost/intrusive/set.hpp deleted file mode 100644 index 9b0207023d5..00000000000 --- a/src/third_party/boost/boost/intrusive/set.hpp +++ /dev/null @@ -1,2384 +0,0 @@ -///////////////////////////////////////////////////////////////////////////// -// -// (C) Copyright Olaf Krzikalla 2004-2006. -// (C) Copyright Ion Gaztanaga 2006-2009 -// -// Distributed under the Boost Software License, Version 1.0. -// (See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) -// -// See http://www.boost.org/libs/intrusive for documentation. -// -///////////////////////////////////////////////////////////////////////////// -#ifndef BOOST_INTRUSIVE_SET_HPP -#define BOOST_INTRUSIVE_SET_HPP - -#include <boost/intrusive/detail/config_begin.hpp> -#include <boost/intrusive/intrusive_fwd.hpp> -#include <boost/intrusive/detail/mpl.hpp> -#include <boost/intrusive/rbtree.hpp> -#include <iterator> -#include <boost/move/move.hpp> - -namespace boost { -namespace intrusive { - -//! The class template set is an intrusive container, that mimics most of -//! the interface of std::set as described in the C++ standard. -//! -//! The template parameter \c T is the type to be managed by the container. -//! The user can specify additional options and if no options are provided -//! default options are used. -//! -//! The container supports the following options: -//! \c base_hook<>/member_hook<>/value_traits<>, -//! \c constant_time_size<>, \c size_type<> and -//! \c compare<>. -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -class set_impl -{ - /// @cond - typedef rbtree_impl<Config> tree_type; - BOOST_MOVABLE_BUT_NOT_COPYABLE(set_impl) - - typedef tree_type implementation_defined; - /// @endcond - - public: - typedef typename implementation_defined::value_type value_type; - typedef typename implementation_defined::value_traits value_traits; - typedef typename implementation_defined::pointer pointer; - typedef typename implementation_defined::const_pointer const_pointer; - typedef typename implementation_defined::reference reference; - typedef typename implementation_defined::const_reference const_reference; - typedef typename implementation_defined::difference_type difference_type; - typedef typename implementation_defined::size_type size_type; - typedef typename implementation_defined::value_compare value_compare; - typedef typename implementation_defined::key_compare key_compare; - typedef typename implementation_defined::iterator iterator; - typedef typename implementation_defined::const_iterator const_iterator; - typedef typename implementation_defined::reverse_iterator reverse_iterator; - typedef typename implementation_defined::const_reverse_iterator const_reverse_iterator; - typedef typename implementation_defined::insert_commit_data insert_commit_data; - typedef typename implementation_defined::node_traits node_traits; - typedef typename implementation_defined::node node; - typedef typename implementation_defined::node_ptr node_ptr; - typedef typename implementation_defined::const_node_ptr const_node_ptr; - typedef typename implementation_defined::node_algorithms node_algorithms; - - static const bool constant_time_size = Config::constant_time_size; - //static const bool stateful_value_traits = detail::is_stateful_value_traits<real_value_traits>::value; - - /// @cond - private: - tree_type tree_; - - protected: - node &prot_header_node(){ return tree_.prot_header_node(); } - node const &prot_header_node() const{ return tree_.prot_header_node(); } - void prot_set_size(size_type s){ tree_.prot_set_size(s); } - value_compare &prot_comp(){ return tree_.prot_comp(); } - - /// @endcond - - public: - //! <b>Effects</b>: Constructs an empty set. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: If value_traits::node_traits::node - //! constructor throws (this does not happen with predefined Boost.Intrusive hooks) - //! or the copy constructor of the value_compare object throws. - set_impl( const value_compare &cmp = value_compare() - , const value_traits &v_traits = value_traits()) - : tree_(cmp, v_traits) - {} - - //! <b>Requires</b>: Dereferencing iterator must yield an lvalue of type value_type. - //! cmp must be a comparison function that induces a strict weak ordering. - //! - //! <b>Effects</b>: Constructs an empty set and inserts elements from - //! [b, e). - //! - //! <b>Complexity</b>: Linear in N if [b, e) is already sorted using - //! comp and otherwise N * log N, where N is std::distance(last, first). - //! - //! <b>Throws</b>: If value_traits::node_traits::node - //! constructor throws (this does not happen with predefined Boost.Intrusive hooks) - //! or the copy constructor/operator() of the value_compare object throws. - template<class Iterator> - set_impl( Iterator b, Iterator e - , const value_compare &cmp = value_compare() - , const value_traits &v_traits = value_traits()) - : tree_(true, b, e, cmp, v_traits) - {} - - //! <b>Effects</b>: to-do - //! - set_impl(BOOST_RV_REF(set_impl) x) - : tree_(::boost::move(x.tree_)) - {} - - //! <b>Effects</b>: to-do - //! - set_impl& operator=(BOOST_RV_REF(set_impl) x) - { tree_ = ::boost::move(x.tree_); return *this; } - - //! <b>Effects</b>: Detaches all elements from this. The objects in the set - //! are not deleted (i.e. no destructors are called). - //! - //! <b>Complexity</b>: Linear to the number of elements on the container. - //! if it's a safe-mode or auto-unlink value_type. Constant time otherwise. - //! - //! <b>Throws</b>: Nothing. - ~set_impl() - {} - - //! <b>Effects</b>: Returns an iterator pointing to the beginning of the set. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - iterator begin() - { return tree_.begin(); } - - //! <b>Effects</b>: Returns a const_iterator pointing to the beginning of the set. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_iterator begin() const - { return tree_.begin(); } - - //! <b>Effects</b>: Returns a const_iterator pointing to the beginning of the set. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_iterator cbegin() const - { return tree_.cbegin(); } - - //! <b>Effects</b>: Returns an iterator pointing to the end of the set. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - iterator end() - { return tree_.end(); } - - //! <b>Effects</b>: Returns a const_iterator pointing to the end of the set. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_iterator end() const - { return tree_.end(); } - - //! <b>Effects</b>: Returns a const_iterator pointing to the end of the set. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_iterator cend() const - { return tree_.cend(); } - - //! <b>Effects</b>: Returns a reverse_iterator pointing to the beginning of the - //! reversed set. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - reverse_iterator rbegin() - { return tree_.rbegin(); } - - //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning - //! of the reversed set. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_reverse_iterator rbegin() const - { return tree_.rbegin(); } - - //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning - //! of the reversed set. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_reverse_iterator crbegin() const - { return tree_.crbegin(); } - - //! <b>Effects</b>: Returns a reverse_iterator pointing to the end - //! of the reversed set. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - reverse_iterator rend() - { return tree_.rend(); } - - //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the end - //! of the reversed set. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_reverse_iterator rend() const - { return tree_.rend(); } - - //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the end - //! of the reversed set. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_reverse_iterator crend() const - { return tree_.crend(); } - - //! <b>Precondition</b>: end_iterator must be a valid end iterator - //! of set. - //! - //! <b>Effects</b>: Returns a reference to the set associated to the end iterator - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - static set_impl &container_from_end_iterator(iterator end_iterator) - { - return *detail::parent_from_member<set_impl, tree_type> - ( &tree_type::container_from_end_iterator(end_iterator) - , &set_impl::tree_); - } - - //! <b>Precondition</b>: end_iterator must be a valid end const_iterator - //! of set. - //! - //! <b>Effects</b>: Returns a const reference to the set associated to the end iterator - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - static const set_impl &container_from_end_iterator(const_iterator end_iterator) - { - return *detail::parent_from_member<set_impl, tree_type> - ( &tree_type::container_from_end_iterator(end_iterator) - , &set_impl::tree_); - } - - //! <b>Precondition</b>: it must be a valid iterator of set. - //! - //! <b>Effects</b>: Returns a reference to the set associated to the iterator - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Logarithmic. - static set_impl &container_from_iterator(iterator it) - { - return *detail::parent_from_member<set_impl, tree_type> - ( &tree_type::container_from_iterator(it) - , &set_impl::tree_); - } - - //! <b>Precondition</b>: it must be a valid const_iterator of set. - //! - //! <b>Effects</b>: Returns a const reference to the set associated to the iterator - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Logarithmic. - static const set_impl &container_from_iterator(const_iterator it) - { - return *detail::parent_from_member<set_impl, tree_type> - ( &tree_type::container_from_iterator(it) - , &set_impl::tree_); - } - - //! <b>Effects</b>: Returns the key_compare object used by the set. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: If key_compare copy-constructor throws. - key_compare key_comp() const - { return tree_.value_comp(); } - - //! <b>Effects</b>: Returns the value_compare object used by the set. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: If value_compare copy-constructor throws. - value_compare value_comp() const - { return tree_.value_comp(); } - - //! <b>Effects</b>: Returns true if the container is empty. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - bool empty() const - { return tree_.empty(); } - - //! <b>Effects</b>: Returns the number of elements stored in the set. - //! - //! <b>Complexity</b>: Linear to elements contained in *this if, - //! constant-time size option is enabled. Constant-time otherwise. - //! - //! <b>Throws</b>: Nothing. - size_type size() const - { return tree_.size(); } - - //! <b>Effects</b>: Swaps the contents of two sets. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: If the swap() call for the comparison functor - //! found using ADL throws. Strong guarantee. - void swap(set_impl& other) - { tree_.swap(other.tree_); } - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! Cloner should yield to nodes equivalent to the original nodes. - //! - //! <b>Effects</b>: Erases all the elements from *this - //! calling Disposer::operator()(pointer), clones all the - //! elements from src calling Cloner::operator()(const_reference ) - //! and inserts them on *this. Copies the predicate from the source container. - //! - //! If cloner throws, all cloned elements are unlinked and disposed - //! calling Disposer::operator()(pointer). - //! - //! <b>Complexity</b>: Linear to erased plus inserted elements. - //! - //! <b>Throws</b>: If cloner throws or predicate copy assignment throws. Basic guarantee. - template <class Cloner, class Disposer> - void clone_from(const set_impl &src, Cloner cloner, Disposer disposer) - { tree_.clone_from(src.tree_, cloner, disposer); } - - //! <b>Requires</b>: value must be an lvalue - //! - //! <b>Effects</b>: Tries to inserts value into the set. - //! - //! <b>Returns</b>: If the value - //! is not already present inserts it and returns a pair containing the - //! iterator to the new value and true. If there is an equivalent value - //! returns a pair containing an iterator to the already present value - //! and false. - //! - //! <b>Complexity</b>: Average complexity for insert element is at - //! most logarithmic. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. Strong guarantee. - //! - //! <b>Note</b>: Does not affect the validity of iterators and references. - //! No copy-constructors are called. - std::pair<iterator, bool> insert(reference value) - { return tree_.insert_unique(value); } - - //! <b>Requires</b>: value must be an lvalue - //! - //! <b>Effects</b>: Tries to to insert x into the set, using "hint" - //! as a hint to where it will be inserted. - //! - //! <b>Returns</b>: An iterator that points to the position where the - //! new element was inserted into the set. - //! - //! <b>Complexity</b>: Logarithmic in general, but it's amortized - //! constant time if t is inserted immediately before hint. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. Strong guarantee. - //! - //! <b>Note</b>: Does not affect the validity of iterators and references. - //! No copy-constructors are called. - iterator insert(const_iterator hint, reference value) - { return tree_.insert_unique(hint, value); } - - //! <b>Requires</b>: key_value_comp must be a comparison function that induces - //! the same strict weak ordering as value_compare. The difference is that - //! key_value_comp compares an arbitrary key with the contained values. - //! - //! <b>Effects</b>: Checks if a value can be inserted in the set, using - //! a user provided key instead of the value itself. - //! - //! <b>Returns</b>: If there is an equivalent value - //! returns a pair containing an iterator to the already present value - //! and false. If the value can be inserted returns true in the returned - //! pair boolean and fills "commit_data" that is meant to be used with - //! the "insert_commit" function. - //! - //! <b>Complexity</b>: Average complexity is at most logarithmic. - //! - //! <b>Throws</b>: If the key_value_comp ordering function throws. Strong guarantee. - //! - //! <b>Notes</b>: This function is used to improve performance when constructing - //! a value_type is expensive: if there is an equivalent value - //! the constructed object must be discarded. Many times, the part of the - //! node that is used to impose the order is much cheaper to construct - //! than the value_type and this function offers the possibility to use that - //! part to check if the insertion will be successful. - //! - //! If the check is successful, the user can construct the value_type and use - //! "insert_commit" to insert the object in constant-time. This gives a total - //! logarithmic complexity to the insertion: check(O(log(N)) + commit(O(1)). - //! - //! "commit_data" remains valid for a subsequent "insert_commit" only if no more - //! objects are inserted or erased from the set. - template<class KeyType, class KeyValueCompare> - std::pair<iterator, bool> insert_check - (const KeyType &key, KeyValueCompare key_value_comp, insert_commit_data &commit_data) - { return tree_.insert_unique_check(key, key_value_comp, commit_data); } - - //! <b>Requires</b>: key_value_comp must be a comparison function that induces - //! the same strict weak ordering as value_compare. The difference is that - //! key_value_comp compares an arbitrary key with the contained values. - //! - //! <b>Effects</b>: Checks if a value can be inserted in the set, using - //! a user provided key instead of the value itself, using "hint" - //! as a hint to where it will be inserted. - //! - //! <b>Returns</b>: If there is an equivalent value - //! returns a pair containing an iterator to the already present value - //! and false. If the value can be inserted returns true in the returned - //! pair boolean and fills "commit_data" that is meant to be used with - //! the "insert_commit" function. - //! - //! <b>Complexity</b>: Logarithmic in general, but it's amortized - //! constant time if t is inserted immediately before hint. - //! - //! <b>Throws</b>: If the key_value_comp ordering function throws. Strong guarantee. - //! - //! <b>Notes</b>: This function is used to improve performance when constructing - //! a value_type is expensive: if there is an equivalent value - //! the constructed object must be discarded. Many times, the part of the - //! constructing that is used to impose the order is much cheaper to construct - //! than the value_type and this function offers the possibility to use that key - //! to check if the insertion will be successful. - //! - //! If the check is successful, the user can construct the value_type and use - //! "insert_commit" to insert the object in constant-time. This can give a total - //! constant-time complexity to the insertion: check(O(1)) + commit(O(1)). - //! - //! "commit_data" remains valid for a subsequent "insert_commit" only if no more - //! objects are inserted or erased from the set. - template<class KeyType, class KeyValueCompare> - std::pair<iterator, bool> insert_check - (const_iterator hint, const KeyType &key - ,KeyValueCompare key_value_comp, insert_commit_data &commit_data) - { return tree_.insert_unique_check(hint, key, key_value_comp, commit_data); } - - //! <b>Requires</b>: value must be an lvalue of type value_type. commit_data - //! must have been obtained from a previous call to "insert_check". - //! No objects should have been inserted or erased from the set between - //! the "insert_check" that filled "commit_data" and the call to "insert_commit". - //! - //! <b>Effects</b>: Inserts the value in the set using the information obtained - //! from the "commit_data" that a previous "insert_check" filled. - //! - //! <b>Returns</b>: An iterator to the newly inserted object. - //! - //! <b>Complexity</b>: Constant time. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Notes</b>: This function has only sense if a "insert_check" has been - //! previously executed to fill "commit_data". No value should be inserted or - //! erased between the "insert_check" and "insert_commit" calls. - iterator insert_commit(reference value, const insert_commit_data &commit_data) - { return tree_.insert_unique_commit(value, commit_data); } - - //! <b>Requires</b>: Dereferencing iterator must yield an lvalue - //! of type value_type. - //! - //! <b>Effects</b>: Inserts a range into the set. - //! - //! <b>Complexity</b>: Insert range is in general O(N * log(N)), where N is the - //! size of the range. However, it is linear in N if the range is already sorted - //! by value_comp(). - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. Basic guarantee. - //! - //! <b>Note</b>: Does not affect the validity of iterators and references. - //! No copy-constructors are called. - template<class Iterator> - void insert(Iterator b, Iterator e) - { tree_.insert_unique(b, e); } - - //! <b>Requires</b>: value must be an lvalue, "pos" must be - //! a valid iterator (or end) and must be the succesor of value - //! once inserted according to the predicate. "value" must not be equal to any - //! inserted key according to the predicate. - //! - //! <b>Effects</b>: Inserts x into the tree before "pos". - //! - //! <b>Complexity</b>: Constant time. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: This function does not check preconditions so if "pos" is not - //! the successor of "value" or "value" is not unique tree ordering and uniqueness - //! invariants will be broken respectively. - //! This is a low-level function to be used only for performance reasons - //! by advanced users. - iterator insert_before(const_iterator pos, reference value) - { return tree_.insert_before(pos, value); } - - //! <b>Requires</b>: value must be an lvalue, and it must be greater than - //! any inserted key according to the predicate. - //! - //! <b>Effects</b>: Inserts x into the tree in the last position. - //! - //! <b>Complexity</b>: Constant time. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: This function does not check preconditions so if value is - //! less than or equal to the greatest inserted key tree ordering invariant will be broken. - //! This function is slightly more efficient than using "insert_before". - //! This is a low-level function to be used only for performance reasons - //! by advanced users. - void push_back(reference value) - { tree_.push_back(value); } - - //! <b>Requires</b>: value must be an lvalue, and it must be less - //! than any inserted key according to the predicate. - //! - //! <b>Effects</b>: Inserts x into the tree in the first position. - //! - //! <b>Complexity</b>: Constant time. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: This function does not check preconditions so if value is - //! greater than or equal to the the mimum inserted key tree ordering or uniqueness - //! invariants will be broken. - //! This function is slightly more efficient than using "insert_before". - //! This is a low-level function to be used only for performance reasons - //! by advanced users. - void push_front(reference value) - { tree_.push_front(value); } - - //! <b>Effects</b>: Erases the element pointed to by pos. - //! - //! <b>Complexity</b>: Average complexity is constant time. - //! - //! <b>Returns</b>: An iterator to the element after the erased element. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - iterator erase(const_iterator i) - { return tree_.erase(i); } - - //! <b>Effects</b>: Erases the range pointed to by b end e. - //! - //! <b>Complexity</b>: Average complexity for erase range is at most - //! O(log(size() + N)), where N is the number of elements in the range. - //! - //! <b>Returns</b>: An iterator to the element after the erased elements. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - iterator erase(const_iterator b, const_iterator e) - { return tree_.erase(b, e); } - - //! <b>Effects</b>: Erases all the elements with the given value. - //! - //! <b>Returns</b>: The number of erased elements. - //! - //! <b>Complexity</b>: O(log(size()) + this->count(value)). - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. Basic guarantee. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - size_type erase(const_reference value) - { return tree_.erase(value); } - - //! <b>Effects</b>: Erases all the elements that compare equal with - //! the given key and the given comparison functor. - //! - //! <b>Returns</b>: The number of erased elements. - //! - //! <b>Complexity</b>: O(log(size() + this->count(key, comp)). - //! - //! <b>Throws</b>: If the comp ordering function throws. Basic guarantee. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - template<class KeyType, class KeyValueCompare> - size_type erase(const KeyType& key, KeyValueCompare comp - /// @cond - , typename detail::enable_if_c<!detail::is_convertible<KeyValueCompare, const_iterator>::value >::type * = 0 - /// @endcond - ) - { return tree_.erase(key, comp); } - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! - //! <b>Effects</b>: Erases the element pointed to by pos. - //! Disposer::operator()(pointer) is called for the removed element. - //! - //! <b>Complexity</b>: Average complexity for erase element is constant time. - //! - //! <b>Returns</b>: An iterator to the element after the erased element. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators - //! to the erased elements. - template<class Disposer> - iterator erase_and_dispose(const_iterator i, Disposer disposer) - { return tree_.erase_and_dispose(i, disposer); } - - #if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) - template<class Disposer> - iterator erase_and_dispose(iterator i, Disposer disposer) - { return this->erase_and_dispose(const_iterator(i), disposer); } - #endif - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! - //! <b>Effects</b>: Erases the range pointed to by b end e. - //! Disposer::operator()(pointer) is called for the removed elements. - //! - //! <b>Complexity</b>: Average complexity for erase range is at most - //! O(log(size() + N)), where N is the number of elements in the range. - //! - //! <b>Returns</b>: An iterator to the element after the erased elements. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators - //! to the erased elements. - template<class Disposer> - iterator erase_and_dispose(const_iterator b, const_iterator e, Disposer disposer) - { return tree_.erase_and_dispose(b, e, disposer); } - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! - //! <b>Effects</b>: Erases all the elements with the given value. - //! Disposer::operator()(pointer) is called for the removed elements. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. - //! - //! <b>Complexity</b>: O(log(size() + this->count(value)). Basic guarantee. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - template<class Disposer> - size_type erase_and_dispose(const_reference value, Disposer disposer) - { return tree_.erase_and_dispose(value, disposer); } - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! - //! <b>Effects</b>: Erases all the elements with the given key. - //! according to the comparison functor "comp". - //! Disposer::operator()(pointer) is called for the removed elements. - //! - //! <b>Returns</b>: The number of erased elements. - //! - //! <b>Complexity</b>: O(log(size() + this->count(key, comp)). - //! - //! <b>Throws</b>: If comp ordering function throws. Basic guarantee. - //! - //! <b>Note</b>: Invalidates the iterators - //! to the erased elements. - template<class KeyType, class KeyValueCompare, class Disposer> - size_type erase_and_dispose(const KeyType& key, KeyValueCompare comp, Disposer disposer - /// @cond - , typename detail::enable_if_c<!detail::is_convertible<KeyValueCompare, const_iterator>::value >::type * = 0 - /// @endcond - ) - { return tree_.erase_and_dispose(key, comp, disposer); } - - //! <b>Effects</b>: Erases all the elements of the container. - //! - //! <b>Complexity</b>: Linear to the number of elements on the container. - //! if it's a safe-mode or auto-unlink value_type. Constant time otherwise. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - void clear() - { return tree_.clear(); } - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! - //! <b>Effects</b>: Erases all the elements of the container. - //! - //! <b>Complexity</b>: Linear to the number of elements on the container. - //! Disposer::operator()(pointer) is called for the removed elements. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - template<class Disposer> - void clear_and_dispose(Disposer disposer) - { return tree_.clear_and_dispose(disposer); } - - //! <b>Effects</b>: Returns the number of contained elements with the given key - //! - //! <b>Complexity</b>: Logarithmic to the number of elements contained plus lineal - //! to number of objects with the given key. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. - size_type count(const_reference value) const - { return tree_.find(value) != end(); } - - //! <b>Effects</b>: Returns the number of contained elements with the same key - //! compared with the given comparison functor. - //! - //! <b>Complexity</b>: Logarithmic to the number of elements contained plus lineal - //! to number of objects with the given key. - //! - //! <b>Throws</b>: If comp ordering function throws. - template<class KeyType, class KeyValueCompare> - size_type count(const KeyType& key, KeyValueCompare comp) const - { return tree_.find(key, comp) != end(); } - - //! <b>Effects</b>: Returns an iterator to the first element whose - //! key is not less than k or end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. - iterator lower_bound(const_reference value) - { return tree_.lower_bound(value); } - - //! <b>Requires</b>: comp must imply the same element order as - //! value_compare. Usually key is the part of the value_type - //! that is used in the ordering functor. - //! - //! <b>Effects</b>: Returns an iterator to the first element whose - //! key according to the comparison functor is not less than k or - //! end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If comp ordering function throws. - //! - //! <b>Note</b>: This function is used when constructing a value_type - //! is expensive and the value_type can be compared with a cheaper - //! key type. Usually this key is part of the value_type. - template<class KeyType, class KeyValueCompare> - iterator lower_bound(const KeyType& key, KeyValueCompare comp) - { return tree_.lower_bound(key, comp); } - - //! <b>Effects</b>: Returns a const iterator to the first element whose - //! key is not less than k or end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. - const_iterator lower_bound(const_reference value) const - { return tree_.lower_bound(value); } - - //! <b>Requires</b>: comp must imply the same element order as - //! value_compare. Usually key is the part of the value_type - //! that is used in the ordering functor. - //! - //! <b>Effects</b>: Returns a const_iterator to the first element whose - //! key according to the comparison functor is not less than k or - //! end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If comp ordering function throws. - //! - //! <b>Note</b>: This function is used when constructing a value_type - //! is expensive and the value_type can be compared with a cheaper - //! key type. Usually this key is part of the value_type. - template<class KeyType, class KeyValueCompare> - const_iterator lower_bound(const KeyType& key, KeyValueCompare comp) const - { return tree_.lower_bound(key, comp); } - - //! <b>Effects</b>: Returns an iterator to the first element whose - //! key is greater than k or end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. - iterator upper_bound(const_reference value) - { return tree_.upper_bound(value); } - - //! <b>Requires</b>: comp must imply the same element order as - //! value_compare. Usually key is the part of the value_type - //! that is used in the ordering functor. - //! - //! <b>Effects</b>: Returns an iterator to the first element whose - //! key according to the comparison functor is greater than key or - //! end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If comp ordering function throws. - //! - //! <b>Note</b>: This function is used when constructing a value_type - //! is expensive and the value_type can be compared with a cheaper - //! key type. Usually this key is part of the value_type. - template<class KeyType, class KeyValueCompare> - iterator upper_bound(const KeyType& key, KeyValueCompare comp) - { return tree_.upper_bound(key, comp); } - - //! <b>Effects</b>: Returns an iterator to the first element whose - //! key is greater than k or end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. - const_iterator upper_bound(const_reference value) const - { return tree_.upper_bound(value); } - - //! <b>Requires</b>: comp must imply the same element order as - //! value_compare. Usually key is the part of the value_type - //! that is used in the ordering functor. - //! - //! <b>Effects</b>: Returns a const_iterator to the first element whose - //! key according to the comparison functor is greater than key or - //! end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If comp ordering function throws. - //! - //! <b>Note</b>: This function is used when constructing a value_type - //! is expensive and the value_type can be compared with a cheaper - //! key type. Usually this key is part of the value_type. - template<class KeyType, class KeyValueCompare> - const_iterator upper_bound(const KeyType& key, KeyValueCompare comp) const - { return tree_.upper_bound(key, comp); } - - //! <b>Effects</b>: Finds an iterator to the first element whose value is - //! "value" or end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. - iterator find(const_reference value) - { return tree_.find(value); } - - //! <b>Requires</b>: comp must imply the same element order as - //! value_compare. Usually key is the part of the value_type - //! that is used in the ordering functor. - //! - //! <b>Effects</b>: Finds an iterator to the first element whose key is - //! "key" according to the comparison functor or end() if that element - //! does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If comp ordering function throws. - //! - //! <b>Note</b>: This function is used when constructing a value_type - //! is expensive and the value_type can be compared with a cheaper - //! key type. Usually this key is part of the value_type. - template<class KeyType, class KeyValueCompare> - iterator find(const KeyType& key, KeyValueCompare comp) - { return tree_.find(key, comp); } - - //! <b>Effects</b>: Finds a const_iterator to the first element whose value is - //! "value" or end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. - const_iterator find(const_reference value) const - { return tree_.find(value); } - - //! <b>Requires</b>: comp must imply the same element order as - //! value_compare. Usually key is the part of the value_type - //! that is used in the ordering functor. - //! - //! <b>Effects</b>: Finds a const_iterator to the first element whose key is - //! "key" according to the comparison functor or end() if that element - //! does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If comp ordering function throws. - //! - //! <b>Note</b>: This function is used when constructing a value_type - //! is expensive and the value_type can be compared with a cheaper - //! key type. Usually this key is part of the value_type. - template<class KeyType, class KeyValueCompare> - const_iterator find(const KeyType& key, KeyValueCompare comp) const - { return tree_.find(key, comp); } - - //! <b>Effects</b>: Finds a range containing all elements whose key is k or - //! an empty range that indicates the position where those elements would be - //! if they there is no elements with key k. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. - std::pair<iterator,iterator> equal_range(const_reference value) - { return tree_.equal_range(value); } - - //! <b>Requires</b>: comp must imply the same element order as - //! value_compare. Usually key is the part of the value_type - //! that is used in the ordering functor. - //! - //! <b>Effects</b>: Finds a range containing all elements whose key is k - //! according to the comparison functor or an empty range - //! that indicates the position where those elements would be - //! if they there is no elements with key k. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If comp ordering function throws. - //! - //! <b>Note</b>: This function is used when constructing a value_type - //! is expensive and the value_type can be compared with a cheaper - //! key type. Usually this key is part of the value_type. - template<class KeyType, class KeyValueCompare> - std::pair<iterator,iterator> equal_range(const KeyType& key, KeyValueCompare comp) - { return tree_.equal_range(key, comp); } - - //! <b>Effects</b>: Finds a range containing all elements whose key is k or - //! an empty range that indicates the position where those elements would be - //! if they there is no elements with key k. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. - std::pair<const_iterator, const_iterator> - equal_range(const_reference value) const - { return tree_.equal_range(value); } - - //! <b>Requires</b>: comp must imply the same element order as - //! value_compare. Usually key is the part of the value_type - //! that is used in the ordering functor. - //! - //! <b>Effects</b>: Finds a range containing all elements whose key is k - //! according to the comparison functor or an empty range - //! that indicates the position where those elements would be - //! if they there is no elements with key k. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If comp ordering function throws. - //! - //! <b>Note</b>: This function is used when constructing a value_type - //! is expensive and the value_type can be compared with a cheaper - //! key type. Usually this key is part of the value_type. - template<class KeyType, class KeyValueCompare> - std::pair<const_iterator, const_iterator> - equal_range(const KeyType& key, KeyValueCompare comp) const - { return tree_.equal_range(key, comp); } - - //! <b>Requires</b>: value must be an lvalue and shall be in a set of - //! appropriate type. Otherwise the behavior is undefined. - //! - //! <b>Effects</b>: Returns: a valid iterator i belonging to the set - //! that points to the value - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: This static function is available only if the <i>value traits</i> - //! is stateless. - static iterator s_iterator_to(reference value) - { return tree_type::s_iterator_to(value); } - - //! <b>Requires</b>: value must be an lvalue and shall be in a set of - //! appropriate type. Otherwise the behavior is undefined. - //! - //! <b>Effects</b>: Returns: a valid const_iterator i belonging to the - //! set that points to the value - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: This static function is available only if the <i>value traits</i> - //! is stateless. - static const_iterator s_iterator_to(const_reference value) - { return tree_type::s_iterator_to(value); } - - //! <b>Requires</b>: value must be an lvalue and shall be in a set of - //! appropriate type. Otherwise the behavior is undefined. - //! - //! <b>Effects</b>: Returns: a valid iterator i belonging to the set - //! that points to the value - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - iterator iterator_to(reference value) - { return tree_.iterator_to(value); } - - //! <b>Requires</b>: value must be an lvalue and shall be in a set of - //! appropriate type. Otherwise the behavior is undefined. - //! - //! <b>Effects</b>: Returns: a valid const_iterator i belonging to the - //! set that points to the value - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_iterator iterator_to(const_reference value) const - { return tree_.iterator_to(value); } - - //! <b>Requires</b>: value shall not be in a set/multiset. - //! - //! <b>Effects</b>: init_node puts the hook of a value in a well-known default - //! state. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant time. - //! - //! <b>Note</b>: This function puts the hook in the well-known default state - //! used by auto_unlink and safe hooks. - static void init_node(reference value) - { tree_type::init_node(value); } - - //! <b>Effects</b>: Unlinks the leftmost node from the tree. - //! - //! <b>Complexity</b>: Average complexity is constant time. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Notes</b>: This function breaks the tree and the tree can - //! only be used for more unlink_leftmost_without_rebalance calls. - //! This function is normally used to achieve a step by step - //! controlled destruction of the tree. - pointer unlink_leftmost_without_rebalance() - { return tree_.unlink_leftmost_without_rebalance(); } - - //! <b>Requires</b>: replace_this must be a valid iterator of *this - //! and with_this must not be inserted in any tree. - //! - //! <b>Effects</b>: Replaces replace_this in its position in the - //! tree with with_this. The tree does not need to be rebalanced. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: This function will break container ordering invariants if - //! with_this is not equivalent to *replace_this according to the - //! ordering rules. This function is faster than erasing and inserting - //! the node, since no rebalancing or comparison is needed. - void replace_node(iterator replace_this, reference with_this) - { tree_.replace_node(replace_this, with_this); } - - /// @cond - friend bool operator==(const set_impl &x, const set_impl &y) - { return x.tree_ == y.tree_; } - - friend bool operator<(const set_impl &x, const set_impl &y) - { return x.tree_ < y.tree_; } - /// @endcond -}; - -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -inline bool operator!= -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -(const set_impl<T, Options...> &x, const set_impl<T, Options...> &y) -#else -(const set_impl<Config> &x, const set_impl<Config> &y) -#endif -{ return !(x == y); } - -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -inline bool operator> -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -(const set_impl<T, Options...> &x, const set_impl<T, Options...> &y) -#else -(const set_impl<Config> &x, const set_impl<Config> &y) -#endif -{ return y < x; } - -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -inline bool operator<= -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -(const set_impl<T, Options...> &x, const set_impl<T, Options...> &y) -#else -(const set_impl<Config> &x, const set_impl<Config> &y) -#endif -{ return !(y < x); } - -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -inline bool operator>= -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -(const set_impl<T, Options...> &x, const set_impl<T, Options...> &y) -#else -(const set_impl<Config> &x, const set_impl<Config> &y) -#endif -{ return !(x < y); } - -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -inline void swap -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -(set_impl<T, Options...> &x, set_impl<T, Options...> &y) -#else -(set_impl<Config> &x, set_impl<Config> &y) -#endif -{ x.swap(y); } - -//! Helper metafunction to define a \c set that yields to the same type when the -//! same options (either explicitly or implicitly) are used. -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) || defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template<class T, class ...Options> -#else -template<class T, class O1 = none, class O2 = none - , class O3 = none, class O4 = none> -#endif -struct make_set -{ - /// @cond - typedef set_impl - < typename make_rbtree_opt<T, - #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) - O1, O2, O3, O4 - #else - Options... - #endif - >::type - > implementation_defined; - /// @endcond - typedef implementation_defined type; -}; - -#ifndef BOOST_INTRUSIVE_DOXYGEN_INVOKED -#if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template<class T, class O1, class O2, class O3, class O4> -#else -template<class T, class ...Options> -#endif -class set - : public make_set<T, - #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) - O1, O2, O3, O4 - #else - Options... - #endif - >::type -{ - typedef typename make_set - <T, - #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) - O1, O2, O3, O4 - #else - Options... - #endif - >::type Base; - - BOOST_MOVABLE_BUT_NOT_COPYABLE(set) - public: - typedef typename Base::value_compare value_compare; - typedef typename Base::value_traits value_traits; - typedef typename Base::iterator iterator; - typedef typename Base::const_iterator const_iterator; - - //Assert if passed value traits are compatible with the type - BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value)); - - set( const value_compare &cmp = value_compare() - , const value_traits &v_traits = value_traits()) - : Base(cmp, v_traits) - {} - - template<class Iterator> - set( Iterator b, Iterator e - , const value_compare &cmp = value_compare() - , const value_traits &v_traits = value_traits()) - : Base(b, e, cmp, v_traits) - {} - - set(BOOST_RV_REF(set) x) - : Base(::boost::move(static_cast<Base&>(x))) - {} - - set& operator=(BOOST_RV_REF(set) x) - { this->Base::operator=(::boost::move(static_cast<Base&>(x))); return *this; } - - static set &container_from_end_iterator(iterator end_iterator) - { return static_cast<set &>(Base::container_from_end_iterator(end_iterator)); } - - static const set &container_from_end_iterator(const_iterator end_iterator) - { return static_cast<const set &>(Base::container_from_end_iterator(end_iterator)); } - - static set &container_from_iterator(iterator it) - { return static_cast<set &>(Base::container_from_iterator(it)); } - - static const set &container_from_iterator(const_iterator it) - { return static_cast<const set &>(Base::container_from_iterator(it)); } -}; - -#endif - -//! The class template multiset is an intrusive container, that mimics most of -//! the interface of std::multiset as described in the C++ standard. -//! -//! The template parameter \c T is the type to be managed by the container. -//! The user can specify additional options and if no options are provided -//! default options are used. -//! -//! The container supports the following options: -//! \c base_hook<>/member_hook<>/value_traits<>, -//! \c constant_time_size<>, \c size_type<> and -//! \c compare<>. -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -class multiset_impl -{ - /// @cond - typedef rbtree_impl<Config> tree_type; - - BOOST_MOVABLE_BUT_NOT_COPYABLE(multiset_impl) - typedef tree_type implementation_defined; - /// @endcond - - public: - typedef typename implementation_defined::value_type value_type; - typedef typename implementation_defined::value_traits value_traits; - typedef typename implementation_defined::pointer pointer; - typedef typename implementation_defined::const_pointer const_pointer; - typedef typename implementation_defined::reference reference; - typedef typename implementation_defined::const_reference const_reference; - typedef typename implementation_defined::difference_type difference_type; - typedef typename implementation_defined::size_type size_type; - typedef typename implementation_defined::value_compare value_compare; - typedef typename implementation_defined::key_compare key_compare; - typedef typename implementation_defined::iterator iterator; - typedef typename implementation_defined::const_iterator const_iterator; - typedef typename implementation_defined::reverse_iterator reverse_iterator; - typedef typename implementation_defined::const_reverse_iterator const_reverse_iterator; - typedef typename implementation_defined::insert_commit_data insert_commit_data; - typedef typename implementation_defined::node_traits node_traits; - typedef typename implementation_defined::node node; - typedef typename implementation_defined::node_ptr node_ptr; - typedef typename implementation_defined::const_node_ptr const_node_ptr; - typedef typename implementation_defined::node_algorithms node_algorithms; - - static const bool constant_time_size = Config::constant_time_size; - //static const bool stateful_value_traits = detail::is_stateful_value_traits<real_value_traits>::value; - - /// @cond - private: - tree_type tree_; - - protected: - node &prot_header_node(){ return tree_.prot_header_node(); } - node const &prot_header_node() const{ return tree_.prot_header_node(); } - void prot_set_size(size_type s){ tree_.prot_set_size(s); } - value_compare &prot_comp(){ return tree_.prot_comp(); } - /// @endcond - - public: - //! <b>Effects</b>: Constructs an empty multiset. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: If value_traits::node_traits::node - //! constructor throws (this does not happen with predefined Boost.Intrusive hooks) - //! or the copy constructor/operator() of the value_compare object throws. - multiset_impl( const value_compare &cmp = value_compare() - , const value_traits &v_traits = value_traits()) - : tree_(cmp, v_traits) - {} - - //! <b>Requires</b>: Dereferencing iterator must yield an lvalue of type value_type. - //! cmp must be a comparison function that induces a strict weak ordering. - //! - //! <b>Effects</b>: Constructs an empty multiset and inserts elements from - //! [b, e). - //! - //! <b>Complexity</b>: Linear in N if [b, e) is already sorted using - //! comp and otherwise N * log N, where N is the distance between first and last - //! - //! <b>Throws</b>: If value_traits::node_traits::node - //! constructor throws (this does not happen with predefined Boost.Intrusive hooks) - //! or the copy constructor/operator() of the value_compare object throws. - template<class Iterator> - multiset_impl( Iterator b, Iterator e - , const value_compare &cmp = value_compare() - , const value_traits &v_traits = value_traits()) - : tree_(false, b, e, cmp, v_traits) - {} - - //! <b>Effects</b>: to-do - //! - multiset_impl(BOOST_RV_REF(multiset_impl) x) - : tree_(::boost::move(x.tree_)) - {} - - //! <b>Effects</b>: to-do - //! - multiset_impl& operator=(BOOST_RV_REF(multiset_impl) x) - { tree_ = ::boost::move(x.tree_); return *this; } - - //! <b>Effects</b>: Detaches all elements from this. The objects in the set - //! are not deleted (i.e. no destructors are called). - //! - //! <b>Complexity</b>: Linear to the number of elements on the container. - //! if it's a safe-mode or auto-unlink value_type. Constant time otherwise. - //! - //! <b>Throws</b>: Nothing. - ~multiset_impl() - {} - - //! <b>Effects</b>: Returns an iterator pointing to the beginning of the multiset. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - iterator begin() - { return tree_.begin(); } - - //! <b>Effects</b>: Returns a const_iterator pointing to the beginning of the multiset. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_iterator begin() const - { return tree_.begin(); } - - //! <b>Effects</b>: Returns a const_iterator pointing to the beginning of the multiset. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_iterator cbegin() const - { return tree_.cbegin(); } - - //! <b>Effects</b>: Returns an iterator pointing to the end of the multiset. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - iterator end() - { return tree_.end(); } - - //! <b>Effects</b>: Returns a const_iterator pointing to the end of the multiset. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_iterator end() const - { return tree_.end(); } - - //! <b>Effects</b>: Returns a const_iterator pointing to the end of the multiset. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_iterator cend() const - { return tree_.cend(); } - - //! <b>Effects</b>: Returns a reverse_iterator pointing to the beginning of the - //! reversed multiset. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - reverse_iterator rbegin() - { return tree_.rbegin(); } - - //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning - //! of the reversed multiset. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_reverse_iterator rbegin() const - { return tree_.rbegin(); } - - //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning - //! of the reversed multiset. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_reverse_iterator crbegin() const - { return tree_.crbegin(); } - - //! <b>Effects</b>: Returns a reverse_iterator pointing to the end - //! of the reversed multiset. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - reverse_iterator rend() - { return tree_.rend(); } - - //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the end - //! of the reversed multiset. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_reverse_iterator rend() const - { return tree_.rend(); } - - //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the end - //! of the reversed multiset. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_reverse_iterator crend() const - { return tree_.crend(); } - - //! <b>Precondition</b>: end_iterator must be a valid end iterator - //! of multiset. - //! - //! <b>Effects</b>: Returns a const reference to the multiset associated to the end iterator - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - static multiset_impl &container_from_end_iterator(iterator end_iterator) - { - return *detail::parent_from_member<multiset_impl, tree_type> - ( &tree_type::container_from_end_iterator(end_iterator) - , &multiset_impl::tree_); - } - - //! <b>Precondition</b>: end_iterator must be a valid end const_iterator - //! of multiset. - //! - //! <b>Effects</b>: Returns a const reference to the multiset associated to the end iterator - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - static const multiset_impl &container_from_end_iterator(const_iterator end_iterator) - { - return *detail::parent_from_member<multiset_impl, tree_type> - ( &tree_type::container_from_end_iterator(end_iterator) - , &multiset_impl::tree_); - } - - //! <b>Precondition</b>: it must be a valid iterator of multiset. - //! - //! <b>Effects</b>: Returns a const reference to the multiset associated to the iterator - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Logarithmic. - static multiset_impl &container_from_iterator(iterator it) - { - return *detail::parent_from_member<multiset_impl, tree_type> - ( &tree_type::container_from_iterator(it) - , &multiset_impl::tree_); - } - - //! <b>Precondition</b>: it must be a valid const_iterator of multiset. - //! - //! <b>Effects</b>: Returns a const reference to the multiset associated to the iterator - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Logarithmic. - static const multiset_impl &container_from_iterator(const_iterator it) - { - return *detail::parent_from_member<multiset_impl, tree_type> - ( &tree_type::container_from_iterator(it) - , &multiset_impl::tree_); - } - - //! <b>Effects</b>: Returns the key_compare object used by the multiset. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: If key_compare copy-constructor throws. - key_compare key_comp() const - { return tree_.value_comp(); } - - //! <b>Effects</b>: Returns the value_compare object used by the multiset. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: If value_compare copy-constructor throws. - value_compare value_comp() const - { return tree_.value_comp(); } - - //! <b>Effects</b>: Returns true if the container is empty. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - bool empty() const - { return tree_.empty(); } - - //! <b>Effects</b>: Returns the number of elements stored in the multiset. - //! - //! <b>Complexity</b>: Linear to elements contained in *this if, - //! constant-time size option is enabled. Constant-time otherwise. - //! - //! <b>Throws</b>: Nothing. - size_type size() const - { return tree_.size(); } - - //! <b>Effects</b>: Swaps the contents of two multisets. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: If the swap() call for the comparison functor - //! found using ADL throws. Strong guarantee. - void swap(multiset_impl& other) - { tree_.swap(other.tree_); } - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! Cloner should yield to nodes equivalent to the original nodes. - //! - //! <b>Effects</b>: Erases all the elements from *this - //! calling Disposer::operator()(pointer), clones all the - //! elements from src calling Cloner::operator()(const_reference ) - //! and inserts them on *this. Copies the predicate from the source container. - //! - //! If cloner throws, all cloned elements are unlinked and disposed - //! calling Disposer::operator()(pointer). - //! - //! <b>Complexity</b>: Linear to erased plus inserted elements. - //! - //! <b>Throws</b>: If cloner throws or predicate copy assignment throws. Basic guarantee. - template <class Cloner, class Disposer> - void clone_from(const multiset_impl &src, Cloner cloner, Disposer disposer) - { tree_.clone_from(src.tree_, cloner, disposer); } - - //! <b>Requires</b>: value must be an lvalue - //! - //! <b>Effects</b>: Inserts value into the multiset. - //! - //! <b>Returns</b>: An iterator that points to the position where the new - //! element was inserted. - //! - //! <b>Complexity</b>: Average complexity for insert element is at - //! most logarithmic. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. Strong guarantee. - //! - //! <b>Note</b>: Does not affect the validity of iterators and references. - //! No copy-constructors are called. - iterator insert(reference value) - { return tree_.insert_equal(value); } - - //! <b>Requires</b>: value must be an lvalue - //! - //! <b>Effects</b>: Inserts x into the multiset, using pos as a hint to - //! where it will be inserted. - //! - //! <b>Returns</b>: An iterator that points to the position where the new - //! element was inserted. - //! - //! <b>Complexity</b>: Logarithmic in general, but it is amortized - //! constant time if t is inserted immediately before hint. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. Strong guarantee. - //! - //! <b>Note</b>: Does not affect the validity of iterators and references. - //! No copy-constructors are called. - iterator insert(const_iterator hint, reference value) - { return tree_.insert_equal(hint, value); } - - //! <b>Requires</b>: Dereferencing iterator must yield an lvalue - //! of type value_type. - //! - //! <b>Effects</b>: Inserts a range into the multiset. - //! - //! <b>Returns</b>: An iterator that points to the position where the new - //! element was inserted. - //! - //! <b>Complexity</b>: Insert range is in general O(N * log(N)), where N is the - //! size of the range. However, it is linear in N if the range is already sorted - //! by value_comp(). - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. Basic guarantee. - //! - //! <b>Note</b>: Does not affect the validity of iterators and references. - //! No copy-constructors are called. - template<class Iterator> - void insert(Iterator b, Iterator e) - { tree_.insert_equal(b, e); } - - //! <b>Requires</b>: value must be an lvalue, "pos" must be - //! a valid iterator (or end) and must be the succesor of value - //! once inserted according to the predicate - //! - //! <b>Effects</b>: Inserts x into the tree before "pos". - //! - //! <b>Complexity</b>: Constant time. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: This function does not check preconditions so if "pos" is not - //! the successor of "value" tree ordering invariant will be broken. - //! This is a low-level function to be used only for performance reasons - //! by advanced users. - iterator insert_before(const_iterator pos, reference value) - { return tree_.insert_before(pos, value); } - - //! <b>Requires</b>: value must be an lvalue, and it must be no less - //! than the greatest inserted key - //! - //! <b>Effects</b>: Inserts x into the tree in the last position. - //! - //! <b>Complexity</b>: Constant time. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: This function does not check preconditions so if value is - //! less than the greatest inserted key tree ordering invariant will be broken. - //! This function is slightly more efficient than using "insert_before". - //! This is a low-level function to be used only for performance reasons - //! by advanced users. - void push_back(reference value) - { tree_.push_back(value); } - - //! <b>Requires</b>: value must be an lvalue, and it must be no greater - //! than the minimum inserted key - //! - //! <b>Effects</b>: Inserts x into the tree in the first position. - //! - //! <b>Complexity</b>: Constant time. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: This function does not check preconditions so if value is - //! greater than the minimum inserted key tree ordering invariant will be broken. - //! This function is slightly more efficient than using "insert_before". - //! This is a low-level function to be used only for performance reasons - //! by advanced users. - void push_front(reference value) - { tree_.push_front(value); } - - //! <b>Effects</b>: Erases the element pointed to by pos. - //! - //! <b>Complexity</b>: Average complexity is constant time. - //! - //! <b>Returns</b>: An iterator to the element after the erased element. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - iterator erase(const_iterator i) - { return tree_.erase(i); } - - //! <b>Effects</b>: Erases the range pointed to by b end e. - //! - //! <b>Returns</b>: An iterator to the element after the erased elements. - //! - //! <b>Complexity</b>: Average complexity for erase range is at most - //! O(log(size() + N)), where N is the number of elements in the range. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - iterator erase(const_iterator b, iterator e) - { return tree_.erase(b, e); } - - //! <b>Effects</b>: Erases all the elements with the given value. - //! - //! <b>Returns</b>: The number of erased elements. - //! - //! <b>Complexity</b>: O(log(size() + this->count(value)). - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. Basic guarantee. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - size_type erase(const_reference value) - { return tree_.erase(value); } - - //! <b>Effects</b>: Erases all the elements that compare equal with - //! the given key and the given comparison functor. - //! - //! <b>Returns</b>: The number of erased elements. - //! - //! <b>Complexity</b>: O(log(size() + this->count(key, comp)). - //! - //! <b>Throws</b>: If comp ordering function throws. Basic guarantee. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - template<class KeyType, class KeyValueCompare> - size_type erase(const KeyType& key, KeyValueCompare comp - /// @cond - , typename detail::enable_if_c<!detail::is_convertible<KeyValueCompare, const_iterator>::value >::type * = 0 - /// @endcond - ) - { return tree_.erase(key, comp); } - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! - //! <b>Returns</b>: An iterator to the element after the erased element. - //! - //! <b>Effects</b>: Erases the element pointed to by pos. - //! Disposer::operator()(pointer) is called for the removed element. - //! - //! <b>Complexity</b>: Average complexity for erase element is constant time. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators - //! to the erased elements. - template<class Disposer> - iterator erase_and_dispose(const_iterator i, Disposer disposer) - { return tree_.erase_and_dispose(i, disposer); } - - #if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) - template<class Disposer> - iterator erase_and_dispose(iterator i, Disposer disposer) - { return this->erase_and_dispose(const_iterator(i), disposer); } - #endif - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! - //! <b>Returns</b>: An iterator to the element after the erased elements. - //! - //! <b>Effects</b>: Erases the range pointed to by b end e. - //! Disposer::operator()(pointer) is called for the removed elements. - //! - //! <b>Complexity</b>: Average complexity for erase range is at most - //! O(log(size() + N)), where N is the number of elements in the range. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators - //! to the erased elements. - template<class Disposer> - iterator erase_and_dispose(const_iterator b, const_iterator e, Disposer disposer) - { return tree_.erase_and_dispose(b, e, disposer); } - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! - //! <b>Effects</b>: Erases all the elements with the given value. - //! Disposer::operator()(pointer) is called for the removed elements. - //! - //! <b>Returns</b>: The number of erased elements. - //! - //! <b>Complexity</b>: O(log(size() + this->count(value)). - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. Basic guarantee. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - template<class Disposer> - size_type erase_and_dispose(const_reference value, Disposer disposer) - { return tree_.erase_and_dispose(value, disposer); } - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! - //! <b>Effects</b>: Erases all the elements with the given key. - //! according to the comparison functor "comp". - //! Disposer::operator()(pointer) is called for the removed elements. - //! - //! <b>Returns</b>: The number of erased elements. - //! - //! <b>Complexity</b>: O(log(size() + this->count(key, comp)). - //! - //! <b>Throws</b>: If comp ordering function throws. Basic guarantee. - //! - //! <b>Note</b>: Invalidates the iterators - //! to the erased elements. - template<class KeyType, class KeyValueCompare, class Disposer> - size_type erase_and_dispose(const KeyType& key, KeyValueCompare comp, Disposer disposer - /// @cond - , typename detail::enable_if_c<!detail::is_convertible<KeyValueCompare, const_iterator>::value >::type * = 0 - /// @endcond - ) - { return tree_.erase_and_dispose(key, comp, disposer); } - - //! <b>Effects</b>: Erases all the elements of the container. - //! - //! <b>Complexity</b>: Linear to the number of elements on the container. - //! if it's a safe-mode or auto-unlink value_type. Constant time otherwise. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - void clear() - { return tree_.clear(); } - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! - //! <b>Effects</b>: Erases all the elements of the container. - //! - //! <b>Complexity</b>: Linear to the number of elements on the container. - //! Disposer::operator()(pointer) is called for the removed elements. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - template<class Disposer> - void clear_and_dispose(Disposer disposer) - { return tree_.clear_and_dispose(disposer); } - - //! <b>Effects</b>: Returns the number of contained elements with the given key - //! - //! <b>Complexity</b>: Logarithmic to the number of elements contained plus lineal - //! to number of objects with the given key. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. - size_type count(const_reference value) const - { return tree_.count(value); } - - //! <b>Effects</b>: Returns the number of contained elements with the same key - //! compared with the given comparison functor. - //! - //! <b>Complexity</b>: Logarithmic to the number of elements contained plus lineal - //! to number of objects with the given key. - //! - //! <b>Throws</b>: If comp ordering function throws. - template<class KeyType, class KeyValueCompare> - size_type count(const KeyType& key, KeyValueCompare comp) const - { return tree_.count(key, comp); } - - //! <b>Effects</b>: Returns an iterator to the first element whose - //! key is not less than k or end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. - iterator lower_bound(const_reference value) - { return tree_.lower_bound(value); } - - //! <b>Requires</b>: comp must imply the same element order as - //! value_compare. Usually key is the part of the value_type - //! that is used in the ordering functor. - //! - //! <b>Effects</b>: Returns an iterator to the first element whose - //! key according to the comparison functor is not less than k or - //! end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If comp ordering function throws. - //! - //! <b>Note</b>: This function is used when constructing a value_type - //! is expensive and the value_type can be compared with a cheaper - //! key type. Usually this key is part of the value_type. - template<class KeyType, class KeyValueCompare> - iterator lower_bound(const KeyType& key, KeyValueCompare comp) - { return tree_.lower_bound(key, comp); } - - //! <b>Effects</b>: Returns a const iterator to the first element whose - //! key is not less than k or end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. - const_iterator lower_bound(const_reference value) const - { return tree_.lower_bound(value); } - - //! <b>Requires</b>: comp must imply the same element order as - //! value_compare. Usually key is the part of the value_type - //! that is used in the ordering functor. - //! - //! <b>Effects</b>: Returns a const_iterator to the first element whose - //! key according to the comparison functor is not less than k or - //! end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If comp ordering function throws. - //! - //! <b>Note</b>: This function is used when constructing a value_type - //! is expensive and the value_type can be compared with a cheaper - //! key type. Usually this key is part of the value_type. - template<class KeyType, class KeyValueCompare> - const_iterator lower_bound(const KeyType& key, KeyValueCompare comp) const - { return tree_.lower_bound(key, comp); } - - //! <b>Effects</b>: Returns an iterator to the first element whose - //! key is greater than k or end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. - iterator upper_bound(const_reference value) - { return tree_.upper_bound(value); } - - //! <b>Requires</b>: comp must imply the same element order as - //! value_compare. Usually key is the part of the value_type - //! that is used in the ordering functor. - //! - //! <b>Effects</b>: Returns an iterator to the first element whose - //! key according to the comparison functor is greater than key or - //! end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If comp ordering function throws. - //! - //! <b>Note</b>: This function is used when constructing a value_type - //! is expensive and the value_type can be compared with a cheaper - //! key type. Usually this key is part of the value_type. - template<class KeyType, class KeyValueCompare> - iterator upper_bound(const KeyType& key, KeyValueCompare comp) - { return tree_.upper_bound(key, comp); } - - //! <b>Effects</b>: Returns an iterator to the first element whose - //! key is greater than k or end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. - const_iterator upper_bound(const_reference value) const - { return tree_.upper_bound(value); } - - //! <b>Requires</b>: comp must imply the same element order as - //! value_compare. Usually key is the part of the value_type - //! that is used in the ordering functor. - //! - //! <b>Effects</b>: Returns a const_iterator to the first element whose - //! key according to the comparison functor is greater than key or - //! end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If comp ordering function throws. - //! - //! <b>Note</b>: This function is used when constructing a value_type - //! is expensive and the value_type can be compared with a cheaper - //! key type. Usually this key is part of the value_type. - template<class KeyType, class KeyValueCompare> - const_iterator upper_bound(const KeyType& key, KeyValueCompare comp) const - { return tree_.upper_bound(key, comp); } - - //! <b>Effects</b>: Finds an iterator to the first element whose value is - //! "value" or end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. - iterator find(const_reference value) - { return tree_.find(value); } - - //! <b>Requires</b>: comp must imply the same element order as - //! value_compare. Usually key is the part of the value_type - //! that is used in the ordering functor. - //! - //! <b>Effects</b>: Finds an iterator to the first element whose key is - //! "key" according to the comparison functor or end() if that element - //! does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If comp ordering function throws. - //! - //! <b>Note</b>: This function is used when constructing a value_type - //! is expensive and the value_type can be compared with a cheaper - //! key type. Usually this key is part of the value_type. - template<class KeyType, class KeyValueCompare> - iterator find(const KeyType& key, KeyValueCompare comp) - { return tree_.find(key, comp); } - - //! <b>Effects</b>: Finds a const_iterator to the first element whose value is - //! "value" or end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. - const_iterator find(const_reference value) const - { return tree_.find(value); } - - //! <b>Requires</b>: comp must imply the same element order as - //! value_compare. Usually key is the part of the value_type - //! that is used in the ordering functor. - //! - //! <b>Effects</b>: Finds a const_iterator to the first element whose key is - //! "key" according to the comparison functor or end() if that element - //! does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If comp ordering function throws. - //! - //! <b>Note</b>: This function is used when constructing a value_type - //! is expensive and the value_type can be compared with a cheaper - //! key type. Usually this key is part of the value_type. - template<class KeyType, class KeyValueCompare> - const_iterator find(const KeyType& key, KeyValueCompare comp) const - { return tree_.find(key, comp); } - - //! <b>Effects</b>: Finds a range containing all elements whose key is k or - //! an empty range that indicates the position where those elements would be - //! if they there is no elements with key k. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. - std::pair<iterator,iterator> equal_range(const_reference value) - { return tree_.equal_range(value); } - - //! <b>Requires</b>: comp must imply the same element order as - //! value_compare. Usually key is the part of the value_type - //! that is used in the ordering functor. - //! - //! <b>Effects</b>: Finds a range containing all elements whose key is k - //! according to the comparison functor or an empty range - //! that indicates the position where those elements would be - //! if they there is no elements with key k. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If comp ordering function throws. - //! - //! <b>Note</b>: This function is used when constructing a value_type - //! is expensive and the value_type can be compared with a cheaper - //! key type. Usually this key is part of the value_type. - template<class KeyType, class KeyValueCompare> - std::pair<iterator,iterator> equal_range(const KeyType& key, KeyValueCompare comp) - { return tree_.equal_range(key, comp); } - - //! <b>Effects</b>: Finds a range containing all elements whose key is k or - //! an empty range that indicates the position where those elements would be - //! if they there is no elements with key k. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. - std::pair<const_iterator, const_iterator> - equal_range(const_reference value) const - { return tree_.equal_range(value); } - - //! <b>Requires</b>: comp must imply the same element order as - //! value_compare. Usually key is the part of the value_type - //! that is used in the ordering functor. - //! - //! <b>Effects</b>: Finds a range containing all elements whose key is k - //! according to the comparison functor or an empty range - //! that indicates the position where those elements would be - //! if they there is no elements with key k. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If comp ordering function throws. - //! - //! <b>Note</b>: This function is used when constructing a value_type - //! is expensive and the value_type can be compared with a cheaper - //! key type. Usually this key is part of the value_type. - template<class KeyType, class KeyValueCompare> - std::pair<const_iterator, const_iterator> - equal_range(const KeyType& key, KeyValueCompare comp) const - { return tree_.equal_range(key, comp); } - - //! <b>Requires</b>: value must be an lvalue and shall be in a set of - //! appropriate type. Otherwise the behavior is undefined. - //! - //! <b>Effects</b>: Returns: a valid iterator i belonging to the set - //! that points to the value - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: This static function is available only if the <i>value traits</i> - //! is stateless. - static iterator s_iterator_to(reference value) - { return tree_type::s_iterator_to(value); } - - //! <b>Requires</b>: value must be an lvalue and shall be in a set of - //! appropriate type. Otherwise the behavior is undefined. - //! - //! <b>Effects</b>: Returns: a valid const_iterator i belonging to the - //! set that points to the value - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: This static function is available only if the <i>value traits</i> - //! is stateless. - static const_iterator s_iterator_to(const_reference value) - { return tree_type::s_iterator_to(value); } - - //! <b>Requires</b>: value must be an lvalue and shall be in a set of - //! appropriate type. Otherwise the behavior is undefined. - //! - //! <b>Effects</b>: Returns: a valid iterator i belonging to the set - //! that points to the value - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - iterator iterator_to(reference value) - { return tree_.iterator_to(value); } - - //! <b>Requires</b>: value must be an lvalue and shall be in a set of - //! appropriate type. Otherwise the behavior is undefined. - //! - //! <b>Effects</b>: Returns: a valid const_iterator i belonging to the - //! set that points to the value - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_iterator iterator_to(const_reference value) const - { return tree_.iterator_to(value); } - - //! <b>Requires</b>: value shall not be in a set/multiset. - //! - //! <b>Effects</b>: init_node puts the hook of a value in a well-known default - //! state. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant time. - //! - //! <b>Note</b>: This function puts the hook in the well-known default state - //! used by auto_unlink and safe hooks. - static void init_node(reference value) - { tree_type::init_node(value); } - - //! <b>Effects</b>: Unlinks the leftmost node from the tree. - //! - //! <b>Complexity</b>: Average complexity is constant time. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Notes</b>: This function breaks the tree and the tree can - //! only be used for more unlink_leftmost_without_rebalance calls. - //! This function is normally used to achieve a step by step - //! controlled destruction of the tree. - pointer unlink_leftmost_without_rebalance() - { return tree_.unlink_leftmost_without_rebalance(); } - - //! <b>Requires</b>: replace_this must be a valid iterator of *this - //! and with_this must not be inserted in any tree. - //! - //! <b>Effects</b>: Replaces replace_this in its position in the - //! tree with with_this. The tree does not need to be rebalanced. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: This function will break container ordering invariants if - //! with_this is not equivalent to *replace_this according to the - //! ordering rules. This function is faster than erasing and inserting - //! the node, since no rebalancing or comparison is needed. - void replace_node(iterator replace_this, reference with_this) - { tree_.replace_node(replace_this, with_this); } - - //! <b>Effects</b>: removes "value" from the container. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Logarithmic time. - //! - //! <b>Note</b>: This static function is only usable with non-constant - //! time size containers that have stateless comparison functors. - //! - //! If the user calls - //! this function with a constant time size container or stateful comparison - //! functor a compilation error will be issued. - static void remove_node(reference value) - { tree_type::remove_node(value); } - - /// @cond - friend bool operator==(const multiset_impl &x, const multiset_impl &y) - { return x.tree_ == y.tree_; } - - friend bool operator<(const multiset_impl &x, const multiset_impl &y) - { return x.tree_ < y.tree_; } - /// @endcond -}; - -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -inline bool operator!= -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -(const multiset_impl<T, Options...> &x, const multiset_impl<T, Options...> &y) -#else -(const multiset_impl<Config> &x, const multiset_impl<Config> &y) -#endif -{ return !(x == y); } - -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -inline bool operator> -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -(const multiset_impl<T, Options...> &x, const multiset_impl<T, Options...> &y) -#else -(const multiset_impl<Config> &x, const multiset_impl<Config> &y) -#endif -{ return y < x; } - -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -inline bool operator<= -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -(const multiset_impl<T, Options...> &x, const multiset_impl<T, Options...> &y) -#else -(const multiset_impl<Config> &x, const multiset_impl<Config> &y) -#endif -{ return !(y < x); } - -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -inline bool operator>= -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -(const multiset_impl<T, Options...> &x, const multiset_impl<T, Options...> &y) -#else -(const multiset_impl<Config> &x, const multiset_impl<Config> &y) -#endif -{ return !(x < y); } - -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -inline void swap -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -(multiset_impl<T, Options...> &x, multiset_impl<T, Options...> &y) -#else -(multiset_impl<Config> &x, multiset_impl<Config> &y) -#endif -{ x.swap(y); } - -//! Helper metafunction to define a \c multiset that yields to the same type when the -//! same options (either explicitly or implicitly) are used. -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) || defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template<class T, class ...Options> -#else -template<class T, class O1 = none, class O2 = none - , class O3 = none, class O4 = none> -#endif -struct make_multiset -{ - /// @cond - typedef multiset_impl - < typename make_rbtree_opt<T, - #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) - O1, O2, O3, O4 - #else - Options... - #endif - >::type - > implementation_defined; - /// @endcond - typedef implementation_defined type; -}; - -#ifndef BOOST_INTRUSIVE_DOXYGEN_INVOKED - -#if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template<class T, class O1, class O2, class O3, class O4> -#else -template<class T, class ...Options> -#endif -class multiset - : public make_multiset<T, - #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) - O1, O2, O3, O4 - #else - Options... - #endif - >::type -{ - typedef typename make_multiset<T, - #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) - O1, O2, O3, O4 - #else - Options... - #endif - >::type Base; - - BOOST_MOVABLE_BUT_NOT_COPYABLE(multiset) - - public: - typedef typename Base::value_compare value_compare; - typedef typename Base::value_traits value_traits; - typedef typename Base::iterator iterator; - typedef typename Base::const_iterator const_iterator; - - //Assert if passed value traits are compatible with the type - BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value)); - - multiset( const value_compare &cmp = value_compare() - , const value_traits &v_traits = value_traits()) - : Base(cmp, v_traits) - {} - - template<class Iterator> - multiset( Iterator b, Iterator e - , const value_compare &cmp = value_compare() - , const value_traits &v_traits = value_traits()) - : Base(b, e, cmp, v_traits) - {} - - multiset(BOOST_RV_REF(multiset) x) - : Base(::boost::move(static_cast<Base&>(x))) - {} - - multiset& operator=(BOOST_RV_REF(multiset) x) - { this->Base::operator=(::boost::move(static_cast<Base&>(x))); return *this; } - - static multiset &container_from_end_iterator(iterator end_iterator) - { return static_cast<multiset &>(Base::container_from_end_iterator(end_iterator)); } - - static const multiset &container_from_end_iterator(const_iterator end_iterator) - { return static_cast<const multiset &>(Base::container_from_end_iterator(end_iterator)); } - - static multiset &container_from_iterator(iterator it) - { return static_cast<multiset &>(Base::container_from_iterator(it)); } - - static const multiset &container_from_iterator(const_iterator it) - { return static_cast<const multiset &>(Base::container_from_iterator(it)); } -}; - -#endif - -} //namespace intrusive -} //namespace boost - -#include <boost/intrusive/detail/config_end.hpp> - -#endif //BOOST_INTRUSIVE_SET_HPP diff --git a/src/third_party/boost/boost/intrusive/set_hook.hpp b/src/third_party/boost/boost/intrusive/set_hook.hpp deleted file mode 100644 index 35746a29a58..00000000000 --- a/src/third_party/boost/boost/intrusive/set_hook.hpp +++ /dev/null @@ -1,300 +0,0 @@ -///////////////////////////////////////////////////////////////////////////// -// -// (C) Copyright Olaf Krzikalla 2004-2006. -// (C) Copyright Ion Gaztanaga 2006-2009 -// -// Distributed under the Boost Software License, Version 1.0. -// (See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) -// -// See http://www.boost.org/libs/intrusive for documentation. -// -///////////////////////////////////////////////////////////////////////////// - -#ifndef BOOST_INTRUSIVE_SET_HOOK_HPP -#define BOOST_INTRUSIVE_SET_HOOK_HPP - -#include <boost/intrusive/detail/config_begin.hpp> -#include <boost/intrusive/intrusive_fwd.hpp> -#include <boost/intrusive/detail/utilities.hpp> -#include <boost/intrusive/detail/rbtree_node.hpp> -#include <boost/intrusive/rbtree_algorithms.hpp> -#include <boost/intrusive/options.hpp> -#include <boost/intrusive/detail/generic_hook.hpp> - -namespace boost { -namespace intrusive { - -/// @cond -template<class VoidPointer, bool OptimizeSize = false> -struct get_set_node_algo -{ - typedef rbtree_algorithms<rbtree_node_traits<VoidPointer, OptimizeSize> > type; -}; -/// @endcond - -//! Helper metafunction to define a \c set_base_hook that yields to the same -//! type when the same options (either explicitly or implicitly) are used. -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) || defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template<class ...Options> -#else -template<class O1 = none, class O2 = none, class O3 = none, class O4 = none> -#endif -struct make_set_base_hook -{ - /// @cond - typedef typename pack_options - < hook_defaults, - #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) - O1, O2, O3, O4 - #else - Options... - #endif - >::type packed_options; - - typedef detail::generic_hook - < get_set_node_algo<typename packed_options::void_pointer - ,packed_options::optimize_size> - , typename packed_options::tag - , packed_options::link_mode - , detail::SetBaseHook - > implementation_defined; - /// @endcond - typedef implementation_defined type; -}; - -//! Derive a class from set_base_hook in order to store objects in -//! in a set/multiset. set_base_hook holds the data necessary to maintain -//! the set/multiset and provides an appropriate value_traits class for set/multiset. -//! -//! The hook admits the following options: \c tag<>, \c void_pointer<>, -//! \c link_mode<> and \c optimize_size<>. -//! -//! \c tag<> defines a tag to identify the node. -//! The same tag value can be used in different classes, but if a class is -//! derived from more than one \c list_base_hook, then each \c list_base_hook needs its -//! unique tag. -//! -//! \c void_pointer<> is the pointer type that will be used internally in the hook -//! and the the container configured to use this hook. -//! -//! \c link_mode<> will specify the linking mode of the hook (\c normal_link, -//! \c auto_unlink or \c safe_link). -//! -//! \c optimize_size<> will tell the hook to optimize the hook for size instead -//! of speed. -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) || defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template<class ...Options> -#else -template<class O1, class O2, class O3, class O4> -#endif -class set_base_hook - : public make_set_base_hook< - #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) - O1, O2, O3, O4 - #else - Options... - #endif - >::type -{ - #if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) - public: - //! <b>Effects</b>: If link_mode is \c auto_unlink or \c safe_link - //! initializes the node to an unlinked state. - //! - //! <b>Throws</b>: Nothing. - set_base_hook(); - - //! <b>Effects</b>: If link_mode is \c auto_unlink or \c safe_link - //! initializes the node to an unlinked state. The argument is ignored. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Rationale</b>: Providing a copy-constructor - //! makes classes using the hook STL-compliant without forcing the - //! user to do some additional work. \c swap can be used to emulate - //! move-semantics. - set_base_hook(const set_base_hook& ); - - //! <b>Effects</b>: Empty function. The argument is ignored. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Rationale</b>: Providing an assignment operator - //! makes classes using the hook STL-compliant without forcing the - //! user to do some additional work. \c swap can be used to emulate - //! move-semantics. - set_base_hook& operator=(const set_base_hook& ); - - //! <b>Effects</b>: If link_mode is \c normal_link, the destructor does - //! nothing (ie. no code is generated). If link_mode is \c safe_link and the - //! object is stored in a set an assertion is raised. If link_mode is - //! \c auto_unlink and \c is_linked() is true, the node is unlinked. - //! - //! <b>Throws</b>: Nothing. - ~set_base_hook(); - - //! <b>Effects</b>: Swapping two nodes swaps the position of the elements - //! related to those nodes in one or two containers. That is, if the node - //! this is part of the element e1, the node x is part of the element e2 - //! and both elements are included in the containers s1 and s2, then after - //! the swap-operation e1 is in s2 at the position of e2 and e2 is in s1 - //! at the position of e1. If one element is not in a container, then - //! after the swap-operation the other element is not in a container. - //! Iterators to e1 and e2 related to those nodes are invalidated. - //! - //! <b>Complexity</b>: Constant - //! - //! <b>Throws</b>: Nothing. - void swap_nodes(set_base_hook &other); - - //! <b>Precondition</b>: link_mode must be \c safe_link or \c auto_unlink. - //! - //! <b>Returns</b>: true, if the node belongs to a container, false - //! otherwise. This function can be used to test whether \c set::iterator_to - //! will return a valid iterator. - //! - //! <b>Complexity</b>: Constant - bool is_linked() const; - - //! <b>Effects</b>: Removes the node if it's inserted in a container. - //! This function is only allowed if link_mode is \c auto_unlink. - //! - //! <b>Throws</b>: Nothing. - void unlink(); - #endif -}; - -//! Helper metafunction to define a \c set_member_hook that yields to the same -//! type when the same options (either explicitly or implicitly) are used. -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) || defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template<class ...Options> -#else -template<class O1 = none, class O2 = none, class O3 = none, class O4 = none> -#endif -struct make_set_member_hook -{ - /// @cond - typedef typename pack_options - < hook_defaults, - #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) - O1, O2, O3, O4 - #else - Options... - #endif - >::type packed_options; - - typedef detail::generic_hook - < get_set_node_algo<typename packed_options::void_pointer - ,packed_options::optimize_size> - , member_tag - , packed_options::link_mode - , detail::NoBaseHook - > implementation_defined; - /// @endcond - typedef implementation_defined type; -}; - -//! Put a public data member set_member_hook in order to store objects of this class in -//! a set/multiset. set_member_hook holds the data necessary for maintaining the -//! set/multiset and provides an appropriate value_traits class for set/multiset. -//! -//! The hook admits the following options: \c void_pointer<>, -//! \c link_mode<> and \c optimize_size<>. -//! -//! \c void_pointer<> is the pointer type that will be used internally in the hook -//! and the the container configured to use this hook. -//! -//! \c link_mode<> will specify the linking mode of the hook (\c normal_link, -//! \c auto_unlink or \c safe_link). -//! -//! \c optimize_size<> will tell the hook to optimize the hook for size instead -//! of speed. -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) || defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template<class ...Options> -#else -template<class O1, class O2, class O3, class O4> -#endif -class set_member_hook - : public make_set_member_hook< - #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) - O1, O2, O3, O4 - #else - Options... - #endif - >::type -{ - #if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) - public: - //! <b>Effects</b>: If link_mode is \c auto_unlink or \c safe_link - //! initializes the node to an unlinked state. - //! - //! <b>Throws</b>: Nothing. - set_member_hook(); - - //! <b>Effects</b>: If link_mode is \c auto_unlink or \c safe_link - //! initializes the node to an unlinked state. The argument is ignored. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Rationale</b>: Providing a copy-constructor - //! makes classes using the hook STL-compliant without forcing the - //! user to do some additional work. \c swap can be used to emulate - //! move-semantics. - set_member_hook(const set_member_hook& ); - - //! <b>Effects</b>: Empty function. The argument is ignored. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Rationale</b>: Providing an assignment operator - //! makes classes using the hook STL-compliant without forcing the - //! user to do some additional work. \c swap can be used to emulate - //! move-semantics. - set_member_hook& operator=(const set_member_hook& ); - - //! <b>Effects</b>: If link_mode is \c normal_link, the destructor does - //! nothing (ie. no code is generated). If link_mode is \c safe_link and the - //! object is stored in a set an assertion is raised. If link_mode is - //! \c auto_unlink and \c is_linked() is true, the node is unlinked. - //! - //! <b>Throws</b>: Nothing. - ~set_member_hook(); - - //! <b>Effects</b>: Swapping two nodes swaps the position of the elements - //! related to those nodes in one or two containers. That is, if the node - //! this is part of the element e1, the node x is part of the element e2 - //! and both elements are included in the containers s1 and s2, then after - //! the swap-operation e1 is in s2 at the position of e2 and e2 is in s1 - //! at the position of e1. If one element is not in a container, then - //! after the swap-operation the other element is not in a container. - //! Iterators to e1 and e2 related to those nodes are invalidated. - //! - //! <b>Complexity</b>: Constant - //! - //! <b>Throws</b>: Nothing. - void swap_nodes(set_member_hook &other); - - //! <b>Precondition</b>: link_mode must be \c safe_link or \c auto_unlink. - //! - //! <b>Returns</b>: true, if the node belongs to a container, false - //! otherwise. This function can be used to test whether \c set::iterator_to - //! will return a valid iterator. - //! - //! <b>Complexity</b>: Constant - bool is_linked() const; - - //! <b>Effects</b>: Removes the node if it's inserted in a container. - //! This function is only allowed if link_mode is \c auto_unlink. - //! - //! <b>Throws</b>: Nothing. - void unlink(); - #endif -}; - -} //namespace intrusive -} //namespace boost - -#include <boost/intrusive/detail/config_end.hpp> - -#endif //BOOST_INTRUSIVE_SET_HOOK_HPP diff --git a/src/third_party/boost/boost/intrusive/sg_set.hpp b/src/third_party/boost/boost/intrusive/sg_set.hpp deleted file mode 100644 index fb59496ee13..00000000000 --- a/src/third_party/boost/boost/intrusive/sg_set.hpp +++ /dev/null @@ -1,2431 +0,0 @@ -///////////////////////////////////////////////////////////////////////////// -// -// (C) Copyright Ion Gaztanaga 2007-2009 -// -// Distributed under the Boost Software License, Version 1.0. -// (See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) -// -// See http://www.boost.org/libs/intrusive for documentation. -// -///////////////////////////////////////////////////////////////////////////// -#ifndef BOOST_INTRUSIVE_SG_SET_HPP -#define BOOST_INTRUSIVE_SG_SET_HPP - -#include <boost/intrusive/detail/config_begin.hpp> -#include <boost/intrusive/intrusive_fwd.hpp> -#include <boost/intrusive/sgtree.hpp> -#include <boost/intrusive/detail/mpl.hpp> -#include <boost/move/move.hpp> -#include <iterator> - -namespace boost { -namespace intrusive { - -//! The class template sg_set is an intrusive container, that mimics most of -//! the interface of std::set as described in the C++ standard. -//! -//! The template parameter \c T is the type to be managed by the container. -//! The user can specify additional options and if no options are provided -//! default options are used. -//! -//! The container supports the following options: -//! \c base_hook<>/member_hook<>/value_traits<>, -//! \c constant_time_size<>, \c size_type<> and -//! \c compare<>. -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -class sg_set_impl -{ - /// @cond - typedef sgtree_impl<Config> tree_type; - //! This class is - //! movable - BOOST_MOVABLE_BUT_NOT_COPYABLE(sg_set_impl) - - typedef tree_type implementation_defined; - /// @endcond - - public: - typedef typename implementation_defined::value_type value_type; - typedef typename implementation_defined::value_traits value_traits; - typedef typename implementation_defined::pointer pointer; - typedef typename implementation_defined::const_pointer const_pointer; - typedef typename implementation_defined::reference reference; - typedef typename implementation_defined::const_reference const_reference; - typedef typename implementation_defined::difference_type difference_type; - typedef typename implementation_defined::size_type size_type; - typedef typename implementation_defined::value_compare value_compare; - typedef typename implementation_defined::key_compare key_compare; - typedef typename implementation_defined::iterator iterator; - typedef typename implementation_defined::const_iterator const_iterator; - typedef typename implementation_defined::reverse_iterator reverse_iterator; - typedef typename implementation_defined::const_reverse_iterator const_reverse_iterator; - typedef typename implementation_defined::insert_commit_data insert_commit_data; - typedef typename implementation_defined::node_traits node_traits; - typedef typename implementation_defined::node node; - typedef typename implementation_defined::node_ptr node_ptr; - typedef typename implementation_defined::const_node_ptr const_node_ptr; - typedef typename implementation_defined::node_algorithms node_algorithms; - - /// @cond - private: - tree_type tree_; - /// @endcond - - public: - //! <b>Effects</b>: Constructs an empty sg_set. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: If value_traits::node_traits::node - //! constructor throws (this does not happen with predefined Boost.Intrusive hooks) - //! or the copy constructor of the value_compare object throws. - sg_set_impl( const value_compare &cmp = value_compare() - , const value_traits &v_traits = value_traits()) - : tree_(cmp, v_traits) - {} - - //! <b>Requires</b>: Dereferencing iterator must yield an lvalue of type value_type. - //! cmp must be a comparison function that induces a strict weak ordering. - //! - //! <b>Effects</b>: Constructs an empty sg_set and inserts elements from - //! [b, e). - //! - //! <b>Complexity</b>: Linear in N if [b, e) is already sorted using - //! comp and otherwise N * log N, where N is std::distance(last, first). - //! - //! <b>Throws</b>: If value_traits::node_traits::node - //! constructor throws (this does not happen with predefined Boost.Intrusive hooks) - //! or the copy constructor/operator() of the value_compare object throws. - template<class Iterator> - sg_set_impl( Iterator b, Iterator e - , const value_compare &cmp = value_compare() - , const value_traits &v_traits = value_traits()) - : tree_(true, b, e, cmp, v_traits) - {} - - //! <b>Effects</b>: to-do - //! - sg_set_impl(BOOST_RV_REF(sg_set_impl) x) - : tree_(::boost::move(x.tree_)) - {} - - //! <b>Effects</b>: to-do - //! - sg_set_impl& operator=(BOOST_RV_REF(sg_set_impl) x) - { tree_ = ::boost::move(x.tree_); return *this; } - - //! <b>Effects</b>: Detaches all elements from this. The objects in the sg_set - //! are not deleted (i.e. no destructors are called). - //! - //! <b>Complexity</b>: Linear to the number of elements on the container. - //! if it's a safe-mode or auto-unlink value_type. Constant time otherwise. - //! - //! <b>Throws</b>: Nothing. - ~sg_set_impl() - {} - - //! <b>Effects</b>: Returns an iterator pointing to the beginning of the sg_set. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - iterator begin() - { return tree_.begin(); } - - //! <b>Effects</b>: Returns a const_iterator pointing to the beginning of the sg_set. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_iterator begin() const - { return tree_.begin(); } - - //! <b>Effects</b>: Returns a const_iterator pointing to the beginning of the sg_set. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_iterator cbegin() const - { return tree_.cbegin(); } - - //! <b>Effects</b>: Returns an iterator pointing to the end of the sg_set. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - iterator end() - { return tree_.end(); } - - //! <b>Effects</b>: Returns a const_iterator pointing to the end of the sg_set. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_iterator end() const - { return tree_.end(); } - - //! <b>Effects</b>: Returns a const_iterator pointing to the end of the sg_set. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_iterator cend() const - { return tree_.cend(); } - - //! <b>Effects</b>: Returns a reverse_iterator pointing to the beginning of the - //! reversed sg_set. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - reverse_iterator rbegin() - { return tree_.rbegin(); } - - //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning - //! of the reversed sg_set. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_reverse_iterator rbegin() const - { return tree_.rbegin(); } - - //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning - //! of the reversed sg_set. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_reverse_iterator crbegin() const - { return tree_.crbegin(); } - - //! <b>Effects</b>: Returns a reverse_iterator pointing to the end - //! of the reversed sg_set. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - reverse_iterator rend() - { return tree_.rend(); } - - //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the end - //! of the reversed sg_set. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_reverse_iterator rend() const - { return tree_.rend(); } - - //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the end - //! of the reversed sg_set. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_reverse_iterator crend() const - { return tree_.crend(); } - - //! <b>Precondition</b>: end_iterator must be a valid end iterator - //! of sg_set. - //! - //! <b>Effects</b>: Returns a const reference to the sg_set associated to the end iterator - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - static sg_set_impl &container_from_end_iterator(iterator end_iterator) - { - return *detail::parent_from_member<sg_set_impl, tree_type> - ( &tree_type::container_from_end_iterator(end_iterator) - , &sg_set_impl::tree_); - } - - //! <b>Precondition</b>: end_iterator must be a valid end const_iterator - //! of sg_set. - //! - //! <b>Effects</b>: Returns a const reference to the sg_set associated to the end iterator - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - static const sg_set_impl &container_from_end_iterator(const_iterator end_iterator) - { - return *detail::parent_from_member<sg_set_impl, tree_type> - ( &tree_type::container_from_end_iterator(end_iterator) - , &sg_set_impl::tree_); - } - - //! <b>Precondition</b>: it must be a valid iterator of set. - //! - //! <b>Effects</b>: Returns a reference to the set associated to the iterator - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Logarithmic. - static sg_set_impl &container_from_iterator(iterator it) - { - return *detail::parent_from_member<sg_set_impl, tree_type> - ( &tree_type::container_from_iterator(it) - , &sg_set_impl::tree_); - } - - //! <b>Precondition</b>: it must be a valid const_iterator of set. - //! - //! <b>Effects</b>: Returns a const reference to the set associated to the iterator - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Logarithmic. - static const sg_set_impl &container_from_iterator(const_iterator it) - { - return *detail::parent_from_member<sg_set_impl, tree_type> - ( &tree_type::container_from_iterator(it) - , &sg_set_impl::tree_); - } - - //! <b>Effects</b>: Returns the key_compare object used by the sg_set. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: If key_compare copy-constructor throws. - key_compare key_comp() const - { return tree_.value_comp(); } - - //! <b>Effects</b>: Returns the value_compare object used by the sg_set. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: If value_compare copy-constructor throws. - value_compare value_comp() const - { return tree_.value_comp(); } - - //! <b>Effects</b>: Returns true if the container is empty. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - bool empty() const - { return tree_.empty(); } - - //! <b>Effects</b>: Returns the number of elements stored in the sg_set. - //! - //! <b>Complexity</b>: Linear to elements contained in *this if, - //! constant-time size option is enabled. Constant-time otherwise. - //! - //! <b>Throws</b>: Nothing. - size_type size() const - { return tree_.size(); } - - //! <b>Effects</b>: Swaps the contents of two sets. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: If the swap() call for the comparison functor - //! found using ADL throws. Strong guarantee. - void swap(sg_set_impl& other) - { tree_.swap(other.tree_); } - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! Cloner should yield to nodes equivalent to the original nodes. - //! - //! <b>Effects</b>: Erases all the elements from *this - //! calling Disposer::operator()(pointer), clones all the - //! elements from src calling Cloner::operator()(const_reference ) - //! and inserts them on *this. Copies the predicate from the source container. - //! - //! If cloner throws, all cloned elements are unlinked and disposed - //! calling Disposer::operator()(pointer). - //! - //! <b>Complexity</b>: Linear to erased plus inserted elements. - //! - //! <b>Throws</b>: If cloner throws or predicate copy assignment throws. Basic guarantee. - template <class Cloner, class Disposer> - void clone_from(const sg_set_impl &src, Cloner cloner, Disposer disposer) - { tree_.clone_from(src.tree_, cloner, disposer); } - - //! <b>Requires</b>: value must be an lvalue - //! - //! <b>Effects</b>: Tries to inserts value into the sg_set. - //! - //! <b>Returns</b>: If the value - //! is not already present inserts it and returns a pair containing the - //! iterator to the new value and true. If there is an equivalent value - //! returns a pair containing an iterator to the already present value - //! and false. - //! - //! <b>Complexity</b>: Average complexity for insert element is at - //! most logarithmic. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. Strong guarantee. - //! - //! <b>Note</b>: Does not affect the validity of iterators and references. - //! No copy-constructors are called. - std::pair<iterator, bool> insert(reference value) - { return tree_.insert_unique(value); } - - //! <b>Requires</b>: value must be an lvalue - //! - //! <b>Effects</b>: Tries to to insert x into the sg_set, using "hint" - //! as a hint to where it will be inserted. - //! - //! <b>Returns</b>: An iterator that points to the position where the - //! new element was inserted into the sg_set. - //! - //! <b>Complexity</b>: Logarithmic in general, but it's amortized - //! constant time if t is inserted immediately before hint. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. Strong guarantee. - //! - //! <b>Note</b>: Does not affect the validity of iterators and references. - //! No copy-constructors are called. - iterator insert(const_iterator hint, reference value) - { return tree_.insert_unique(hint, value); } - - //! <b>Requires</b>: key_value_comp must be a comparison function that induces - //! the same strict weak ordering as value_compare. The difference is that - //! key_value_comp compares an arbitrary key with the contained values. - //! - //! <b>Effects</b>: Checks if a value can be inserted in the sg_set, using - //! a user provided key instead of the value itself. - //! - //! <b>Returns</b>: If there is an equivalent value - //! returns a pair containing an iterator to the already present value - //! and false. If the value can be inserted returns true in the returned - //! pair boolean and fills "commit_data" that is meant to be used with - //! the "insert_commit" function. - //! - //! <b>Complexity</b>: Average complexity is at most logarithmic. - //! - //! <b>Throws</b>: If the key_value_comp ordering function throws. Strong guarantee. - //! - //! <b>Notes</b>: This function is used to improve performance when constructing - //! a value_type is expensive: if there is an equivalent value - //! the constructed object must be discarded. Many times, the part of the - //! node that is used to impose the order is much cheaper to construct - //! than the value_type and this function offers the possibility to use that - //! part to check if the insertion will be successful. - //! - //! If the check is successful, the user can construct the value_type and use - //! "insert_commit" to insert the object in constant-time. This gives a total - //! logarithmic complexity to the insertion: check(O(log(N)) + commit(O(1)). - //! - //! "commit_data" remains valid for a subsequent "insert_commit" only if no more - //! objects are inserted or erased from the sg_set. - template<class KeyType, class KeyValueCompare> - std::pair<iterator, bool> insert_check - (const KeyType &key, KeyValueCompare key_value_comp, insert_commit_data &commit_data) - { return tree_.insert_unique_check(key, key_value_comp, commit_data); } - - //! <b>Requires</b>: key_value_comp must be a comparison function that induces - //! the same strict weak ordering as value_compare. The difference is that - //! key_value_comp compares an arbitrary key with the contained values. - //! - //! <b>Effects</b>: Checks if a value can be inserted in the sg_set, using - //! a user provided key instead of the value itself, using "hint" - //! as a hint to where it will be inserted. - //! - //! <b>Returns</b>: If there is an equivalent value - //! returns a pair containing an iterator to the already present value - //! and false. If the value can be inserted returns true in the returned - //! pair boolean and fills "commit_data" that is meant to be used with - //! the "insert_commit" function. - //! - //! <b>Complexity</b>: Logarithmic in general, but it's amortized - //! constant time if t is inserted immediately before hint. - //! - //! <b>Throws</b>: If the key_value_comp ordering function throws. Strong guarantee. - //! - //! <b>Notes</b>: This function is used to improve performance when constructing - //! a value_type is expensive: if there is an equivalent value - //! the constructed object must be discarded. Many times, the part of the - //! constructing that is used to impose the order is much cheaper to construct - //! than the value_type and this function offers the possibility to use that key - //! to check if the insertion will be successful. - //! - //! If the check is successful, the user can construct the value_type and use - //! "insert_commit" to insert the object in constant-time. This can give a total - //! constant-time complexity to the insertion: check(O(1)) + commit(O(1)). - //! - //! "commit_data" remains valid for a subsequent "insert_commit" only if no more - //! objects are inserted or erased from the sg_set. - template<class KeyType, class KeyValueCompare> - std::pair<iterator, bool> insert_check - (const_iterator hint, const KeyType &key - ,KeyValueCompare key_value_comp, insert_commit_data &commit_data) - { return tree_.insert_unique_check(hint, key, key_value_comp, commit_data); } - - //! <b>Requires</b>: value must be an lvalue of type value_type. commit_data - //! must have been obtained from a previous call to "insert_check". - //! No objects should have been inserted or erased from the sg_set between - //! the "insert_check" that filled "commit_data" and the call to "insert_commit". - //! - //! <b>Effects</b>: Inserts the value in the sg_set using the information obtained - //! from the "commit_data" that a previous "insert_check" filled. - //! - //! <b>Returns</b>: An iterator to the newly inserted object. - //! - //! <b>Complexity</b>: Constant time. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Notes</b>: This function has only sense if a "insert_check" has been - //! previously executed to fill "commit_data". No value should be inserted or - //! erased between the "insert_check" and "insert_commit" calls. - iterator insert_commit(reference value, const insert_commit_data &commit_data) - { return tree_.insert_unique_commit(value, commit_data); } - - //! <b>Requires</b>: Dereferencing iterator must yield an lvalue - //! of type value_type. - //! - //! <b>Effects</b>: Inserts a range into the sg_set. - //! - //! <b>Complexity</b>: Insert range is in general O(N * log(N)), where N is the - //! size of the range. However, it is linear in N if the range is already sorted - //! by value_comp(). - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. Basic guarantee. - //! - //! <b>Note</b>: Does not affect the validity of iterators and references. - //! No copy-constructors are called. - template<class Iterator> - void insert(Iterator b, Iterator e) - { tree_.insert_unique(b, e); } - - //! <b>Requires</b>: value must be an lvalue, "pos" must be - //! a valid iterator (or end) and must be the succesor of value - //! once inserted according to the predicate. "value" must not be equal to any - //! inserted key according to the predicate. - //! - //! <b>Effects</b>: Inserts x into the tree before "pos". - //! - //! <b>Complexity</b>: Constant time. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: This function does not check preconditions so if "pos" is not - //! the successor of "value" or "value" is not unique tree ordering and uniqueness - //! invariants will be broken respectively. - //! This is a low-level function to be used only for performance reasons - //! by advanced users. - iterator insert_before(const_iterator pos, reference value) - { return tree_.insert_before(pos, value); } - - //! <b>Requires</b>: value must be an lvalue, and it must be greater than - //! any inserted key according to the predicate. - //! - //! <b>Effects</b>: Inserts x into the tree in the last position. - //! - //! <b>Complexity</b>: Constant time. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: This function does not check preconditions so if value is - //! less than or equal to the greatest inserted key tree ordering invariant will be broken. - //! This function is slightly more efficient than using "insert_before". - //! This is a low-level function to be used only for performance reasons - //! by advanced users. - void push_back(reference value) - { tree_.push_back(value); } - - //! <b>Requires</b>: value must be an lvalue, and it must be less - //! than any inserted key according to the predicate. - //! - //! <b>Effects</b>: Inserts x into the tree in the first position. - //! - //! <b>Complexity</b>: Constant time. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: This function does not check preconditions so if value is - //! greater than or equal to the the mimum inserted key tree ordering or uniqueness - //! invariants will be broken. - //! This function is slightly more efficient than using "insert_before". - //! This is a low-level function to be used only for performance reasons - //! by advanced users. - void push_front(reference value) - { tree_.push_front(value); } - - //! <b>Effects</b>: Erases the element pointed to by pos. - //! - //! <b>Complexity</b>: Average complexity is constant time. - //! - //! <b>Returns</b>: An iterator to the element after the erased element. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - iterator erase(const_iterator i) - { return tree_.erase(i); } - - //! <b>Effects</b>: Erases the range pointed to by b end e. - //! - //! <b>Complexity</b>: Average complexity for erase range is at most - //! O(log(size() + N)), where N is the number of elements in the range. - //! - //! <b>Returns</b>: An iterator to the element after the erased elements. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - iterator erase(const_iterator b, const_iterator e) - { return tree_.erase(b, e); } - - //! <b>Effects</b>: Erases all the elements with the given value. - //! - //! <b>Returns</b>: The number of erased elements. - //! - //! <b>Complexity</b>: O(log(size()) + this->count(value)). - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. Basic guarantee. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - size_type erase(const_reference value) - { return tree_.erase(value); } - - //! <b>Effects</b>: Erases all the elements that compare equal with - //! the given key and the given comparison functor. - //! - //! <b>Returns</b>: The number of erased elements. - //! - //! <b>Complexity</b>: O(log(size() + this->count(key, comp)). - //! - //! <b>Throws</b>: If the comp ordering function throws. Basic guarantee. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - template<class KeyType, class KeyValueCompare> - size_type erase(const KeyType& key, KeyValueCompare comp - /// @cond - , typename detail::enable_if_c<!detail::is_convertible<KeyValueCompare, const_iterator>::value >::type * = 0 - /// @endcond - ) - { return tree_.erase(key, comp); } - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! - //! <b>Effects</b>: Erases the element pointed to by pos. - //! Disposer::operator()(pointer) is called for the removed element. - //! - //! <b>Complexity</b>: Average complexity for erase element is constant time. - //! - //! <b>Returns</b>: An iterator to the element after the erased element. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators - //! to the erased elements. - template<class Disposer> - iterator erase_and_dispose(const_iterator i, Disposer disposer) - { return tree_.erase_and_dispose(i, disposer); } - - #if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) - template<class Disposer> - iterator erase_and_dispose(iterator i, Disposer disposer) - { return this->erase_and_dispose(const_iterator(i), disposer); } - #endif - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! - //! <b>Effects</b>: Erases the range pointed to by b end e. - //! Disposer::operator()(pointer) is called for the removed elements. - //! - //! <b>Complexity</b>: Average complexity for erase range is at most - //! O(log(size() + N)), where N is the number of elements in the range. - //! - //! <b>Returns</b>: An iterator to the element after the erased elements. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators - //! to the erased elements. - template<class Disposer> - iterator erase_and_dispose(const_iterator b, const_iterator e, Disposer disposer) - { return tree_.erase_and_dispose(b, e, disposer); } - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! - //! <b>Effects</b>: Erases all the elements with the given value. - //! Disposer::operator()(pointer) is called for the removed elements. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. - //! - //! <b>Complexity</b>: O(log(size() + this->count(value)). Basic guarantee. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - template<class Disposer> - size_type erase_and_dispose(const_reference value, Disposer disposer) - { return tree_.erase_and_dispose(value, disposer); } - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! - //! <b>Effects</b>: Erases all the elements with the given key. - //! according to the comparison functor "comp". - //! Disposer::operator()(pointer) is called for the removed elements. - //! - //! <b>Returns</b>: The number of erased elements. - //! - //! <b>Complexity</b>: O(log(size() + this->count(key, comp)). - //! - //! <b>Throws</b>: If comp ordering function throws. Basic guarantee. - //! - //! <b>Note</b>: Invalidates the iterators - //! to the erased elements. - template<class KeyType, class KeyValueCompare, class Disposer> - size_type erase_and_dispose(const KeyType& key, KeyValueCompare comp, Disposer disposer - /// @cond - , typename detail::enable_if_c<!detail::is_convertible<KeyValueCompare, const_iterator>::value >::type * = 0 - /// @endcond - ) - { return tree_.erase_and_dispose(key, comp, disposer); } - - //! <b>Effects</b>: Erases all the elements of the container. - //! - //! <b>Complexity</b>: Linear to the number of elements on the container. - //! if it's a safe-mode or auto-unlink value_type. Constant time otherwise. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - void clear() - { return tree_.clear(); } - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! - //! <b>Effects</b>: Erases all the elements of the container. - //! - //! <b>Complexity</b>: Linear to the number of elements on the container. - //! Disposer::operator()(pointer) is called for the removed elements. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - template<class Disposer> - void clear_and_dispose(Disposer disposer) - { return tree_.clear_and_dispose(disposer); } - - //! <b>Effects</b>: Returns the number of contained elements with the given key - //! - //! <b>Complexity</b>: Logarithmic to the number of elements contained plus lineal - //! to number of objects with the given key. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. - size_type count(const_reference value) const - { return tree_.find(value) != end(); } - - //! <b>Effects</b>: Returns the number of contained elements with the same key - //! compared with the given comparison functor. - //! - //! <b>Complexity</b>: Logarithmic to the number of elements contained plus lineal - //! to number of objects with the given key. - //! - //! <b>Throws</b>: If comp ordering function throws. - template<class KeyType, class KeyValueCompare> - size_type count(const KeyType& key, KeyValueCompare comp) const - { return tree_.find(key, comp) != end(); } - - //! <b>Effects</b>: Returns an iterator to the first element whose - //! key is not less than k or end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. - iterator lower_bound(const_reference value) - { return tree_.lower_bound(value); } - - //! <b>Requires</b>: comp must imply the same element order as - //! value_compare. Usually key is the part of the value_type - //! that is used in the ordering functor. - //! - //! <b>Effects</b>: Returns an iterator to the first element whose - //! key according to the comparison functor is not less than k or - //! end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If comp ordering function throws. - //! - //! <b>Note</b>: This function is used when constructing a value_type - //! is expensive and the value_type can be compared with a cheaper - //! key type. Usually this key is part of the value_type. - template<class KeyType, class KeyValueCompare> - iterator lower_bound(const KeyType& key, KeyValueCompare comp) - { return tree_.lower_bound(key, comp); } - - //! <b>Effects</b>: Returns a const iterator to the first element whose - //! key is not less than k or end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. - const_iterator lower_bound(const_reference value) const - { return tree_.lower_bound(value); } - - //! <b>Requires</b>: comp must imply the same element order as - //! value_compare. Usually key is the part of the value_type - //! that is used in the ordering functor. - //! - //! <b>Effects</b>: Returns a const_iterator to the first element whose - //! key according to the comparison functor is not less than k or - //! end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If comp ordering function throws. - //! - //! <b>Note</b>: This function is used when constructing a value_type - //! is expensive and the value_type can be compared with a cheaper - //! key type. Usually this key is part of the value_type. - template<class KeyType, class KeyValueCompare> - const_iterator lower_bound(const KeyType& key, KeyValueCompare comp) const - { return tree_.lower_bound(key, comp); } - - //! <b>Effects</b>: Returns an iterator to the first element whose - //! key is greater than k or end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. - iterator upper_bound(const_reference value) - { return tree_.upper_bound(value); } - - //! <b>Requires</b>: comp must imply the same element order as - //! value_compare. Usually key is the part of the value_type - //! that is used in the ordering functor. - //! - //! <b>Effects</b>: Returns an iterator to the first element whose - //! key according to the comparison functor is greater than key or - //! end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If comp ordering function throws. - //! - //! <b>Note</b>: This function is used when constructing a value_type - //! is expensive and the value_type can be compared with a cheaper - //! key type. Usually this key is part of the value_type. - template<class KeyType, class KeyValueCompare> - iterator upper_bound(const KeyType& key, KeyValueCompare comp) - { return tree_.upper_bound(key, comp); } - - //! <b>Effects</b>: Returns an iterator to the first element whose - //! key is greater than k or end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. - const_iterator upper_bound(const_reference value) const - { return tree_.upper_bound(value); } - - //! <b>Requires</b>: comp must imply the same element order as - //! value_compare. Usually key is the part of the value_type - //! that is used in the ordering functor. - //! - //! <b>Effects</b>: Returns a const_iterator to the first element whose - //! key according to the comparison functor is greater than key or - //! end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If comp ordering function throws. - //! - //! <b>Note</b>: This function is used when constructing a value_type - //! is expensive and the value_type can be compared with a cheaper - //! key type. Usually this key is part of the value_type. - template<class KeyType, class KeyValueCompare> - const_iterator upper_bound(const KeyType& key, KeyValueCompare comp) const - { return tree_.upper_bound(key, comp); } - - //! <b>Effects</b>: Finds an iterator to the first element whose value is - //! "value" or end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. - iterator find(const_reference value) - { return tree_.find(value); } - - //! <b>Requires</b>: comp must imply the same element order as - //! value_compare. Usually key is the part of the value_type - //! that is used in the ordering functor. - //! - //! <b>Effects</b>: Finds an iterator to the first element whose key is - //! "key" according to the comparison functor or end() if that element - //! does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If comp ordering function throws. - //! - //! <b>Note</b>: This function is used when constructing a value_type - //! is expensive and the value_type can be compared with a cheaper - //! key type. Usually this key is part of the value_type. - template<class KeyType, class KeyValueCompare> - iterator find(const KeyType& key, KeyValueCompare comp) - { return tree_.find(key, comp); } - - //! <b>Effects</b>: Finds a const_iterator to the first element whose value is - //! "value" or end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. - const_iterator find(const_reference value) const - { return tree_.find(value); } - - //! <b>Requires</b>: comp must imply the same element order as - //! value_compare. Usually key is the part of the value_type - //! that is used in the ordering functor. - //! - //! <b>Effects</b>: Finds a const_iterator to the first element whose key is - //! "key" according to the comparison functor or end() if that element - //! does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If comp ordering function throws. - //! - //! <b>Note</b>: This function is used when constructing a value_type - //! is expensive and the value_type can be compared with a cheaper - //! key type. Usually this key is part of the value_type. - template<class KeyType, class KeyValueCompare> - const_iterator find(const KeyType& key, KeyValueCompare comp) const - { return tree_.find(key, comp); } - - //! <b>Effects</b>: Finds a range containing all elements whose key is k or - //! an empty range that indicates the position where those elements would be - //! if they there is no elements with key k. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. - std::pair<iterator,iterator> equal_range(const_reference value) - { return tree_.equal_range(value); } - - //! <b>Requires</b>: comp must imply the same element order as - //! value_compare. Usually key is the part of the value_type - //! that is used in the ordering functor. - //! - //! <b>Effects</b>: Finds a range containing all elements whose key is k - //! according to the comparison functor or an empty range - //! that indicates the position where those elements would be - //! if they there is no elements with key k. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If comp ordering function throws. - //! - //! <b>Note</b>: This function is used when constructing a value_type - //! is expensive and the value_type can be compared with a cheaper - //! key type. Usually this key is part of the value_type. - template<class KeyType, class KeyValueCompare> - std::pair<iterator,iterator> equal_range(const KeyType& key, KeyValueCompare comp) - { return tree_.equal_range(key, comp); } - - //! <b>Effects</b>: Finds a range containing all elements whose key is k or - //! an empty range that indicates the position where those elements would be - //! if they there is no elements with key k. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. - std::pair<const_iterator, const_iterator> - equal_range(const_reference value) const - { return tree_.equal_range(value); } - - //! <b>Requires</b>: comp must imply the same element order as - //! value_compare. Usually key is the part of the value_type - //! that is used in the ordering functor. - //! - //! <b>Effects</b>: Finds a range containing all elements whose key is k - //! according to the comparison functor or an empty range - //! that indicates the position where those elements would be - //! if they there is no elements with key k. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If comp ordering function throws. - //! - //! <b>Note</b>: This function is used when constructing a value_type - //! is expensive and the value_type can be compared with a cheaper - //! key type. Usually this key is part of the value_type. - template<class KeyType, class KeyValueCompare> - std::pair<const_iterator, const_iterator> - equal_range(const KeyType& key, KeyValueCompare comp) const - { return tree_.equal_range(key, comp); } - - //! <b>Requires</b>: value must be an lvalue and shall be in a sg_set of - //! appropriate type. Otherwise the behavior is undefined. - //! - //! <b>Effects</b>: Returns: a valid iterator i belonging to the sg_set - //! that points to the value - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: This static function is available only if the <i>value traits</i> - //! is stateless. - static iterator s_iterator_to(reference value) - { return tree_type::s_iterator_to(value); } - - //! <b>Requires</b>: value must be an lvalue and shall be in a sg_set of - //! appropriate type. Otherwise the behavior is undefined. - //! - //! <b>Effects</b>: Returns: a valid const_iterator i belonging to the - //! sg_set that points to the value - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: This static function is available only if the <i>value traits</i> - //! is stateless. - static const_iterator s_iterator_to(const_reference value) - { return tree_type::s_iterator_to(value); } - - //! <b>Requires</b>: value must be an lvalue and shall be in a sg_set of - //! appropriate type. Otherwise the behavior is undefined. - //! - //! <b>Effects</b>: Returns: a valid iterator i belonging to the sg_set - //! that points to the value - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - iterator iterator_to(reference value) - { return tree_.iterator_to(value); } - - //! <b>Requires</b>: value must be an lvalue and shall be in a sg_set of - //! appropriate type. Otherwise the behavior is undefined. - //! - //! <b>Effects</b>: Returns: a valid const_iterator i belonging to the - //! sg_set that points to the value - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_iterator iterator_to(const_reference value) const - { return tree_.iterator_to(value); } - - //! <b>Requires</b>: value shall not be in a sg_set/sg_multiset. - //! - //! <b>Effects</b>: init_node puts the hook of a value in a well-known default - //! state. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant time. - //! - //! <b>Note</b>: This function puts the hook in the well-known default state - //! used by auto_unlink and safe hooks. - static void init_node(reference value) - { tree_type::init_node(value); } - - //! <b>Effects</b>: Unlinks the leftmost node from the tree. - //! - //! <b>Complexity</b>: Average complexity is constant time. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Notes</b>: This function breaks the tree and the tree can - //! only be used for more unlink_leftmost_without_rebalance calls. - //! This function is normally used to achieve a step by step - //! controlled destruction of the tree. - pointer unlink_leftmost_without_rebalance() - { return tree_.unlink_leftmost_without_rebalance(); } - - //! <b>Requires</b>: replace_this must be a valid iterator of *this - //! and with_this must not be inserted in any tree. - //! - //! <b>Effects</b>: Replaces replace_this in its position in the - //! tree with with_this. The tree does not need to be rebalanced. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: This function will break container ordering invariants if - //! with_this is not equivalent to *replace_this according to the - //! ordering rules. This function is faster than erasing and inserting - //! the node, since no rebalancing or comparison is needed. - void replace_node(iterator replace_this, reference with_this) - { tree_.replace_node(replace_this, with_this); } - - //! <b>Effects</b>: Rebalances the tree. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Linear. - void rebalance() - { tree_.rebalance(); } - - //! <b>Requires</b>: old_root is a node of a tree. - //! - //! <b>Effects</b>: Rebalances the subtree rooted at old_root. - //! - //! <b>Returns</b>: The new root of the subtree. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Linear to the elements in the subtree. - iterator rebalance_subtree(iterator root) - { return tree_.rebalance_subtree(root); } - - //! <b>Returns</b>: The balance factor (alpha) used in this tree - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - float balance_factor() const - { return tree_.balance_factor(); } - - //! <b>Requires</b>: new_alpha must be a value between 0.5 and 1.0 - //! - //! <b>Effects</b>: Establishes a new balance factor (alpha) and rebalances - //! the tree if the new balance factor is stricter (less) than the old factor. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Linear to the elements in the subtree. - void balance_factor(float new_alpha) - { tree_.balance_factor(new_alpha); } - - /// @cond - friend bool operator==(const sg_set_impl &x, const sg_set_impl &y) - { return x.tree_ == y.tree_; } - - friend bool operator<(const sg_set_impl &x, const sg_set_impl &y) - { return x.tree_ < y.tree_; } - /// @endcond -}; - -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -inline bool operator!= -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -(const sg_set_impl<T, Options...> &x, const sg_set_impl<T, Options...> &y) -#else -(const sg_set_impl<Config> &x, const sg_set_impl<Config> &y) -#endif -{ return !(x == y); } - -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -inline bool operator> -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -(const sg_set_impl<T, Options...> &x, const sg_set_impl<T, Options...> &y) -#else -(const sg_set_impl<Config> &x, const sg_set_impl<Config> &y) -#endif -{ return y < x; } - -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -inline bool operator<= -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -(const sg_set_impl<T, Options...> &x, const sg_set_impl<T, Options...> &y) -#else -(const sg_set_impl<Config> &x, const sg_set_impl<Config> &y) -#endif -{ return !(y < x); } - -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -inline bool operator>= -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -(const sg_set_impl<T, Options...> &x, const sg_set_impl<T, Options...> &y) -#else -(const sg_set_impl<Config> &x, const sg_set_impl<Config> &y) -#endif -{ return !(x < y); } - -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -inline void swap -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -(sg_set_impl<T, Options...> &x, sg_set_impl<T, Options...> &y) -#else -(sg_set_impl<Config> &x, sg_set_impl<Config> &y) -#endif -{ x.swap(y); } - -//! Helper metafunction to define a \c sg_set that yields to the same type when the -//! same options (either explicitly or implicitly) are used. -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) || defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template<class T, class ...Options> -#else -template<class T, class O1 = none, class O2 = none - , class O3 = none, class O4 = none> -#endif -struct make_sg_set -{ - /// @cond - typedef sg_set_impl - < typename make_sgtree_opt<T, - #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) - O1, O2, O3, O4 - #else - Options... - #endif - >::type - > implementation_defined; - /// @endcond - typedef implementation_defined type; -}; - -#ifndef BOOST_INTRUSIVE_DOXYGEN_INVOKED - -#if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template<class T, class O1, class O2, class O3, class O4> -#else -template<class T, class ...Options> -#endif -class sg_set - : public make_sg_set<T, - #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) - O1, O2, O3, O4 - #else - Options... - #endif - >::type -{ - typedef typename make_sg_set - <T, - #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) - O1, O2, O3, O4 - #else - Options... - #endif - >::type Base; - BOOST_MOVABLE_BUT_NOT_COPYABLE(sg_set) - - public: - typedef typename Base::value_compare value_compare; - typedef typename Base::value_traits value_traits; - typedef typename Base::iterator iterator; - typedef typename Base::const_iterator const_iterator; - - //Assert if passed value traits are compatible with the type - BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value)); - - sg_set( const value_compare &cmp = value_compare() - , const value_traits &v_traits = value_traits()) - : Base(cmp, v_traits) - {} - - template<class Iterator> - sg_set( Iterator b, Iterator e - , const value_compare &cmp = value_compare() - , const value_traits &v_traits = value_traits()) - : Base(b, e, cmp, v_traits) - {} - - sg_set(BOOST_RV_REF(sg_set) x) - : Base(::boost::move(static_cast<Base&>(x))) - {} - - sg_set& operator=(BOOST_RV_REF(sg_set) x) - { this->Base::operator=(::boost::move(static_cast<Base&>(x))); return *this; } - - static sg_set &container_from_end_iterator(iterator end_iterator) - { return static_cast<sg_set &>(Base::container_from_end_iterator(end_iterator)); } - - static const sg_set &container_from_end_iterator(const_iterator end_iterator) - { return static_cast<const sg_set &>(Base::container_from_end_iterator(end_iterator)); } - - static sg_set &container_from_iterator(iterator it) - { return static_cast<sg_set &>(Base::container_from_iterator(it)); } - - static const sg_set &container_from_iterator(const_iterator it) - { return static_cast<const sg_set &>(Base::container_from_iterator(it)); } -}; - -#endif - -//! The class template sg_multiset is an intrusive container, that mimics most of -//! the interface of std::sg_multiset as described in the C++ standard. -//! -//! The template parameter \c T is the type to be managed by the container. -//! The user can specify additional options and if no options are provided -//! default options are used. -//! -//! The container supports the following options: -//! \c base_hook<>/member_hook<>/value_traits<>, -//! \c constant_time_size<>, \c size_type<> and -//! \c compare<>. -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -class sg_multiset_impl -{ - /// @cond - typedef sgtree_impl<Config> tree_type; - - //Non-copyable and non-assignable - BOOST_MOVABLE_BUT_NOT_COPYABLE(sg_multiset_impl) - typedef tree_type implementation_defined; - /// @endcond - - public: - typedef typename implementation_defined::value_type value_type; - typedef typename implementation_defined::value_traits value_traits; - typedef typename implementation_defined::pointer pointer; - typedef typename implementation_defined::const_pointer const_pointer; - typedef typename implementation_defined::reference reference; - typedef typename implementation_defined::const_reference const_reference; - typedef typename implementation_defined::difference_type difference_type; - typedef typename implementation_defined::size_type size_type; - typedef typename implementation_defined::value_compare value_compare; - typedef typename implementation_defined::key_compare key_compare; - typedef typename implementation_defined::iterator iterator; - typedef typename implementation_defined::const_iterator const_iterator; - typedef typename implementation_defined::reverse_iterator reverse_iterator; - typedef typename implementation_defined::const_reverse_iterator const_reverse_iterator; - typedef typename implementation_defined::insert_commit_data insert_commit_data; - typedef typename implementation_defined::node_traits node_traits; - typedef typename implementation_defined::node node; - typedef typename implementation_defined::node_ptr node_ptr; - typedef typename implementation_defined::const_node_ptr const_node_ptr; - typedef typename implementation_defined::node_algorithms node_algorithms; - - /// @cond - private: - tree_type tree_; - /// @endcond - - public: - //! <b>Effects</b>: Constructs an empty sg_multiset. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: If value_traits::node_traits::node - //! constructor throws (this does not happen with predefined Boost.Intrusive hooks) - //! or the copy constructor/operator() of the value_compare object throws. - sg_multiset_impl( const value_compare &cmp = value_compare() - , const value_traits &v_traits = value_traits()) - : tree_(cmp, v_traits) - {} - - //! <b>Requires</b>: Dereferencing iterator must yield an lvalue of type value_type. - //! cmp must be a comparison function that induces a strict weak ordering. - //! - //! <b>Effects</b>: Constructs an empty sg_multiset and inserts elements from - //! [b, e). - //! - //! <b>Complexity</b>: Linear in N if [b, e) is already sorted using - //! comp and otherwise N * log N, where N is the distance between first and last - //! - //! <b>Throws</b>: If value_traits::node_traits::node - //! constructor throws (this does not happen with predefined Boost.Intrusive hooks) - //! or the copy constructor/operator() of the value_compare object throws. - template<class Iterator> - sg_multiset_impl( Iterator b, Iterator e - , const value_compare &cmp = value_compare() - , const value_traits &v_traits = value_traits()) - : tree_(false, b, e, cmp, v_traits) - {} - - //! <b>Effects</b>: to-do - //! - sg_multiset_impl(BOOST_RV_REF(sg_multiset_impl) x) - : tree_(::boost::move(x.tree_)) - {} - - //! <b>Effects</b>: to-do - //! - sg_multiset_impl& operator=(BOOST_RV_REF(sg_multiset_impl) x) - { tree_ = ::boost::move(x.tree_); return *this; } - - //! <b>Effects</b>: Detaches all elements from this. The objects in the sg_multiset - //! are not deleted (i.e. no destructors are called). - //! - //! <b>Complexity</b>: Linear to the number of elements on the container. - //! if it's a safe-mode or auto-unlink value_type. Constant time otherwise. - //! - //! <b>Throws</b>: Nothing. - ~sg_multiset_impl() - {} - - //! <b>Effects</b>: Returns an iterator pointing to the beginning of the sg_multiset. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - iterator begin() - { return tree_.begin(); } - - //! <b>Effects</b>: Returns a const_iterator pointing to the beginning of the sg_multiset. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_iterator begin() const - { return tree_.begin(); } - - //! <b>Effects</b>: Returns a const_iterator pointing to the beginning of the sg_multiset. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_iterator cbegin() const - { return tree_.cbegin(); } - - //! <b>Effects</b>: Returns an iterator pointing to the end of the sg_multiset. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - iterator end() - { return tree_.end(); } - - //! <b>Effects</b>: Returns a const_iterator pointing to the end of the sg_multiset. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_iterator end() const - { return tree_.end(); } - - //! <b>Effects</b>: Returns a const_iterator pointing to the end of the sg_multiset. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_iterator cend() const - { return tree_.cend(); } - - //! <b>Effects</b>: Returns a reverse_iterator pointing to the beginning of the - //! reversed sg_multiset. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - reverse_iterator rbegin() - { return tree_.rbegin(); } - - //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning - //! of the reversed sg_multiset. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_reverse_iterator rbegin() const - { return tree_.rbegin(); } - - //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning - //! of the reversed sg_multiset. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_reverse_iterator crbegin() const - { return tree_.crbegin(); } - - //! <b>Effects</b>: Returns a reverse_iterator pointing to the end - //! of the reversed sg_multiset. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - reverse_iterator rend() - { return tree_.rend(); } - - //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the end - //! of the reversed sg_multiset. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_reverse_iterator rend() const - { return tree_.rend(); } - - //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the end - //! of the reversed sg_multiset. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_reverse_iterator crend() const - { return tree_.crend(); } - - //! <b>Precondition</b>: end_iterator must be a valid end iterator - //! of sg_multiset. - //! - //! <b>Effects</b>: Returns a const reference to the sg_multiset associated to the end iterator - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - static sg_multiset_impl &container_from_end_iterator(iterator end_iterator) - { - return *detail::parent_from_member<sg_multiset_impl, tree_type> - ( &tree_type::container_from_end_iterator(end_iterator) - , &sg_multiset_impl::tree_); - } - - //! <b>Precondition</b>: end_iterator must be a valid end const_iterator - //! of sg_multiset. - //! - //! <b>Effects</b>: Returns a const reference to the sg_multiset associated to the end iterator - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - static const sg_multiset_impl &container_from_end_iterator(const_iterator end_iterator) - { - return *detail::parent_from_member<sg_multiset_impl, tree_type> - ( &tree_type::container_from_end_iterator(end_iterator) - , &sg_multiset_impl::tree_); - } - - //! <b>Precondition</b>: it must be a valid iterator of multiset. - //! - //! <b>Effects</b>: Returns a const reference to the multiset associated to the iterator - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - static sg_multiset_impl &container_from_iterator(iterator it) - { - return *detail::parent_from_member<sg_multiset_impl, tree_type> - ( &tree_type::container_from_iterator(it) - , &sg_multiset_impl::tree_); - } - - //! <b>Precondition</b>: it must be a valid const_iterator of multiset. - //! - //! <b>Effects</b>: Returns a const reference to the multiset associated to the iterator - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - static const sg_multiset_impl &container_from_iterator(const_iterator it) - { - return *detail::parent_from_member<sg_multiset_impl, tree_type> - ( &tree_type::container_from_iterator(it) - , &sg_multiset_impl::tree_); - } - - //! <b>Effects</b>: Returns the key_compare object used by the sg_multiset. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: If key_compare copy-constructor throws. - key_compare key_comp() const - { return tree_.value_comp(); } - - //! <b>Effects</b>: Returns the value_compare object used by the sg_multiset. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: If value_compare copy-constructor throws. - value_compare value_comp() const - { return tree_.value_comp(); } - - //! <b>Effects</b>: Returns true if the container is empty. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - bool empty() const - { return tree_.empty(); } - - //! <b>Effects</b>: Returns the number of elements stored in the sg_multiset. - //! - //! <b>Complexity</b>: Linear to elements contained in *this if, - //! constant-time size option is enabled. Constant-time otherwise. - //! - //! <b>Throws</b>: Nothing. - size_type size() const - { return tree_.size(); } - - //! <b>Effects</b>: Swaps the contents of two sg_multisets. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: If the swap() call for the comparison functor - //! found using ADL throws. Strong guarantee. - void swap(sg_multiset_impl& other) - { tree_.swap(other.tree_); } - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! Cloner should yield to nodes equivalent to the original nodes. - //! - //! <b>Effects</b>: Erases all the elements from *this - //! calling Disposer::operator()(pointer), clones all the - //! elements from src calling Cloner::operator()(const_reference ) - //! and inserts them on *this. Copies the predicate from the source container. - //! - //! If cloner throws, all cloned elements are unlinked and disposed - //! calling Disposer::operator()(pointer). - //! - //! <b>Complexity</b>: Linear to erased plus inserted elements. - //! - //! <b>Throws</b>: If cloner throws or predicate copy assignment throws. Basic guarantee. - template <class Cloner, class Disposer> - void clone_from(const sg_multiset_impl &src, Cloner cloner, Disposer disposer) - { tree_.clone_from(src.tree_, cloner, disposer); } - - //! <b>Requires</b>: value must be an lvalue - //! - //! <b>Effects</b>: Inserts value into the sg_multiset. - //! - //! <b>Returns</b>: An iterator that points to the position where the new - //! element was inserted. - //! - //! <b>Complexity</b>: Average complexity for insert element is at - //! most logarithmic. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. Strong guarantee. - //! - //! <b>Note</b>: Does not affect the validity of iterators and references. - //! No copy-constructors are called. - iterator insert(reference value) - { return tree_.insert_equal(value); } - - //! <b>Requires</b>: value must be an lvalue - //! - //! <b>Effects</b>: Inserts x into the sg_multiset, using pos as a hint to - //! where it will be inserted. - //! - //! <b>Returns</b>: An iterator that points to the position where the new - //! element was inserted. - //! - //! <b>Complexity</b>: Logarithmic in general, but it is amortized - //! constant time if t is inserted immediately before hint. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. Strong guarantee. - //! - //! <b>Note</b>: Does not affect the validity of iterators and references. - //! No copy-constructors are called. - iterator insert(const_iterator hint, reference value) - { return tree_.insert_equal(hint, value); } - - //! <b>Requires</b>: Dereferencing iterator must yield an lvalue - //! of type value_type. - //! - //! <b>Effects</b>: Inserts a range into the sg_multiset. - //! - //! <b>Returns</b>: An iterator that points to the position where the new - //! element was inserted. - //! - //! <b>Complexity</b>: Insert range is in general O(N * log(N)), where N is the - //! size of the range. However, it is linear in N if the range is already sorted - //! by value_comp(). - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. Basic guarantee. - //! - //! <b>Note</b>: Does not affect the validity of iterators and references. - //! No copy-constructors are called. - template<class Iterator> - void insert(Iterator b, Iterator e) - { tree_.insert_equal(b, e); } - - //! <b>Requires</b>: value must be an lvalue, "pos" must be - //! a valid iterator (or end) and must be the succesor of value - //! once inserted according to the predicate - //! - //! <b>Effects</b>: Inserts x into the tree before "pos". - //! - //! <b>Complexity</b>: Constant time. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: This function does not check preconditions so if "pos" is not - //! the successor of "value" tree ordering invariant will be broken. - //! This is a low-level function to be used only for performance reasons - //! by advanced users. - iterator insert_before(const_iterator pos, reference value) - { return tree_.insert_before(pos, value); } - - //! <b>Requires</b>: value must be an lvalue, and it must be no less - //! than the greatest inserted key - //! - //! <b>Effects</b>: Inserts x into the tree in the last position. - //! - //! <b>Complexity</b>: Constant time. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: This function does not check preconditions so if value is - //! less than the greatest inserted key tree ordering invariant will be broken. - //! This function is slightly more efficient than using "insert_before". - //! This is a low-level function to be used only for performance reasons - //! by advanced users. - void push_back(reference value) - { tree_.push_back(value); } - - //! <b>Requires</b>: value must be an lvalue, and it must be no greater - //! than the minimum inserted key - //! - //! <b>Effects</b>: Inserts x into the tree in the first position. - //! - //! <b>Complexity</b>: Constant time. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: This function does not check preconditions so if value is - //! greater than the minimum inserted key tree ordering invariant will be broken. - //! This function is slightly more efficient than using "insert_before". - //! This is a low-level function to be used only for performance reasons - //! by advanced users. - void push_front(reference value) - { tree_.push_front(value); } - - //! <b>Effects</b>: Erases the element pointed to by pos. - //! - //! <b>Complexity</b>: Average complexity is constant time. - //! - //! <b>Returns</b>: An iterator to the element after the erased element. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - iterator erase(const_iterator i) - { return tree_.erase(i); } - - //! <b>Effects</b>: Erases the range pointed to by b end e. - //! - //! <b>Returns</b>: An iterator to the element after the erased elements. - //! - //! <b>Complexity</b>: Average complexity for erase range is at most - //! O(log(size() + N)), where N is the number of elements in the range. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - iterator erase(const_iterator b, const_iterator e) - { return tree_.erase(b, e); } - - //! <b>Effects</b>: Erases all the elements with the given value. - //! - //! <b>Returns</b>: The number of erased elements. - //! - //! <b>Complexity</b>: O(log(size() + this->count(value)). - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. Basic guarantee. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - size_type erase(const_reference value) - { return tree_.erase(value); } - - //! <b>Effects</b>: Erases all the elements that compare equal with - //! the given key and the given comparison functor. - //! - //! <b>Returns</b>: The number of erased elements. - //! - //! <b>Complexity</b>: O(log(size() + this->count(key, comp)). - //! - //! <b>Throws</b>: If comp ordering function throws. Basic guarantee. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - template<class KeyType, class KeyValueCompare> - size_type erase(const KeyType& key, KeyValueCompare comp - /// @cond - , typename detail::enable_if_c<!detail::is_convertible<KeyValueCompare, const_iterator>::value >::type * = 0 - /// @endcond - ) - { return tree_.erase(key, comp); } - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! - //! <b>Returns</b>: An iterator to the element after the erased element. - //! - //! <b>Effects</b>: Erases the element pointed to by pos. - //! Disposer::operator()(pointer) is called for the removed element. - //! - //! <b>Complexity</b>: Average complexity for erase element is constant time. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators - //! to the erased elements. - template<class Disposer> - iterator erase_and_dispose(const_iterator i, Disposer disposer) - { return tree_.erase_and_dispose(i, disposer); } - - #if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) - template<class Disposer> - iterator erase_and_dispose(iterator i, Disposer disposer) - { return this->erase_and_dispose(const_iterator(i), disposer); } - #endif - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! - //! <b>Returns</b>: An iterator to the element after the erased elements. - //! - //! <b>Effects</b>: Erases the range pointed to by b end e. - //! Disposer::operator()(pointer) is called for the removed elements. - //! - //! <b>Complexity</b>: Average complexity for erase range is at most - //! O(log(size() + N)), where N is the number of elements in the range. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators - //! to the erased elements. - template<class Disposer> - iterator erase_and_dispose(const_iterator b, const_iterator e, Disposer disposer) - { return tree_.erase_and_dispose(b, e, disposer); } - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! - //! <b>Effects</b>: Erases all the elements with the given value. - //! Disposer::operator()(pointer) is called for the removed elements. - //! - //! <b>Returns</b>: The number of erased elements. - //! - //! <b>Complexity</b>: O(log(size() + this->count(value)). - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. Basic guarantee. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - template<class Disposer> - size_type erase_and_dispose(const_reference value, Disposer disposer) - { return tree_.erase_and_dispose(value, disposer); } - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! - //! <b>Effects</b>: Erases all the elements with the given key. - //! according to the comparison functor "comp". - //! Disposer::operator()(pointer) is called for the removed elements. - //! - //! <b>Returns</b>: The number of erased elements. - //! - //! <b>Complexity</b>: O(log(size() + this->count(key, comp)). - //! - //! <b>Throws</b>: If comp ordering function throws. Basic guarantee. - //! - //! <b>Note</b>: Invalidates the iterators - //! to the erased elements. - template<class KeyType, class KeyValueCompare, class Disposer> - size_type erase_and_dispose(const KeyType& key, KeyValueCompare comp, Disposer disposer - /// @cond - , typename detail::enable_if_c<!detail::is_convertible<KeyValueCompare, const_iterator>::value >::type * = 0 - /// @endcond - ) - { return tree_.erase_and_dispose(key, comp, disposer); } - - //! <b>Effects</b>: Erases all the elements of the container. - //! - //! <b>Complexity</b>: Linear to the number of elements on the container. - //! if it's a safe-mode or auto-unlink value_type. Constant time otherwise. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - void clear() - { return tree_.clear(); } - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! - //! <b>Effects</b>: Erases all the elements of the container. - //! - //! <b>Complexity</b>: Linear to the number of elements on the container. - //! Disposer::operator()(pointer) is called for the removed elements. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - template<class Disposer> - void clear_and_dispose(Disposer disposer) - { return tree_.clear_and_dispose(disposer); } - - //! <b>Effects</b>: Returns the number of contained elements with the given key - //! - //! <b>Complexity</b>: Logarithmic to the number of elements contained plus lineal - //! to number of objects with the given key. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. - size_type count(const_reference value) const - { return tree_.count(value); } - - //! <b>Effects</b>: Returns the number of contained elements with the same key - //! compared with the given comparison functor. - //! - //! <b>Complexity</b>: Logarithmic to the number of elements contained plus lineal - //! to number of objects with the given key. - //! - //! <b>Throws</b>: If comp ordering function throws. - template<class KeyType, class KeyValueCompare> - size_type count(const KeyType& key, KeyValueCompare comp) const - { return tree_.count(key, comp); } - - //! <b>Effects</b>: Returns an iterator to the first element whose - //! key is not less than k or end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. - iterator lower_bound(const_reference value) - { return tree_.lower_bound(value); } - - //! <b>Requires</b>: comp must imply the same element order as - //! value_compare. Usually key is the part of the value_type - //! that is used in the ordering functor. - //! - //! <b>Effects</b>: Returns an iterator to the first element whose - //! key according to the comparison functor is not less than k or - //! end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If comp ordering function throws. - //! - //! <b>Note</b>: This function is used when constructing a value_type - //! is expensive and the value_type can be compared with a cheaper - //! key type. Usually this key is part of the value_type. - template<class KeyType, class KeyValueCompare> - iterator lower_bound(const KeyType& key, KeyValueCompare comp) - { return tree_.lower_bound(key, comp); } - - //! <b>Effects</b>: Returns a const iterator to the first element whose - //! key is not less than k or end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. - const_iterator lower_bound(const_reference value) const - { return tree_.lower_bound(value); } - - //! <b>Requires</b>: comp must imply the same element order as - //! value_compare. Usually key is the part of the value_type - //! that is used in the ordering functor. - //! - //! <b>Effects</b>: Returns a const_iterator to the first element whose - //! key according to the comparison functor is not less than k or - //! end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If comp ordering function throws. - //! - //! <b>Note</b>: This function is used when constructing a value_type - //! is expensive and the value_type can be compared with a cheaper - //! key type. Usually this key is part of the value_type. - template<class KeyType, class KeyValueCompare> - const_iterator lower_bound(const KeyType& key, KeyValueCompare comp) const - { return tree_.lower_bound(key, comp); } - - //! <b>Effects</b>: Returns an iterator to the first element whose - //! key is greater than k or end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. - iterator upper_bound(const_reference value) - { return tree_.upper_bound(value); } - - //! <b>Requires</b>: comp must imply the same element order as - //! value_compare. Usually key is the part of the value_type - //! that is used in the ordering functor. - //! - //! <b>Effects</b>: Returns an iterator to the first element whose - //! key according to the comparison functor is greater than key or - //! end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If comp ordering function throws. - //! - //! <b>Note</b>: This function is used when constructing a value_type - //! is expensive and the value_type can be compared with a cheaper - //! key type. Usually this key is part of the value_type. - template<class KeyType, class KeyValueCompare> - iterator upper_bound(const KeyType& key, KeyValueCompare comp) - { return tree_.upper_bound(key, comp); } - - //! <b>Effects</b>: Returns an iterator to the first element whose - //! key is greater than k or end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. - const_iterator upper_bound(const_reference value) const - { return tree_.upper_bound(value); } - - //! <b>Requires</b>: comp must imply the same element order as - //! value_compare. Usually key is the part of the value_type - //! that is used in the ordering functor. - //! - //! <b>Effects</b>: Returns a const_iterator to the first element whose - //! key according to the comparison functor is greater than key or - //! end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If comp ordering function throws. - //! - //! <b>Note</b>: This function is used when constructing a value_type - //! is expensive and the value_type can be compared with a cheaper - //! key type. Usually this key is part of the value_type. - template<class KeyType, class KeyValueCompare> - const_iterator upper_bound(const KeyType& key, KeyValueCompare comp) const - { return tree_.upper_bound(key, comp); } - - //! <b>Effects</b>: Finds an iterator to the first element whose value is - //! "value" or end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. - iterator find(const_reference value) - { return tree_.find(value); } - - //! <b>Requires</b>: comp must imply the same element order as - //! value_compare. Usually key is the part of the value_type - //! that is used in the ordering functor. - //! - //! <b>Effects</b>: Finds an iterator to the first element whose key is - //! "key" according to the comparison functor or end() if that element - //! does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If comp ordering function throws. - //! - //! <b>Note</b>: This function is used when constructing a value_type - //! is expensive and the value_type can be compared with a cheaper - //! key type. Usually this key is part of the value_type. - template<class KeyType, class KeyValueCompare> - iterator find(const KeyType& key, KeyValueCompare comp) - { return tree_.find(key, comp); } - - //! <b>Effects</b>: Finds a const_iterator to the first element whose value is - //! "value" or end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. - const_iterator find(const_reference value) const - { return tree_.find(value); } - - //! <b>Requires</b>: comp must imply the same element order as - //! value_compare. Usually key is the part of the value_type - //! that is used in the ordering functor. - //! - //! <b>Effects</b>: Finds a const_iterator to the first element whose key is - //! "key" according to the comparison functor or end() if that element - //! does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If comp ordering function throws. - //! - //! <b>Note</b>: This function is used when constructing a value_type - //! is expensive and the value_type can be compared with a cheaper - //! key type. Usually this key is part of the value_type. - template<class KeyType, class KeyValueCompare> - const_iterator find(const KeyType& key, KeyValueCompare comp) const - { return tree_.find(key, comp); } - - //! <b>Effects</b>: Finds a range containing all elements whose key is k or - //! an empty range that indicates the position where those elements would be - //! if they there is no elements with key k. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. - std::pair<iterator,iterator> equal_range(const_reference value) - { return tree_.equal_range(value); } - - //! <b>Requires</b>: comp must imply the same element order as - //! value_compare. Usually key is the part of the value_type - //! that is used in the ordering functor. - //! - //! <b>Effects</b>: Finds a range containing all elements whose key is k - //! according to the comparison functor or an empty range - //! that indicates the position where those elements would be - //! if they there is no elements with key k. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If comp ordering function throws. - //! - //! <b>Note</b>: This function is used when constructing a value_type - //! is expensive and the value_type can be compared with a cheaper - //! key type. Usually this key is part of the value_type. - template<class KeyType, class KeyValueCompare> - std::pair<iterator,iterator> equal_range(const KeyType& key, KeyValueCompare comp) - { return tree_.equal_range(key, comp); } - - //! <b>Effects</b>: Finds a range containing all elements whose key is k or - //! an empty range that indicates the position where those elements would be - //! if they there is no elements with key k. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. - std::pair<const_iterator, const_iterator> - equal_range(const_reference value) const - { return tree_.equal_range(value); } - - //! <b>Requires</b>: comp must imply the same element order as - //! value_compare. Usually key is the part of the value_type - //! that is used in the ordering functor. - //! - //! <b>Effects</b>: Finds a range containing all elements whose key is k - //! according to the comparison functor or an empty range - //! that indicates the position where those elements would be - //! if they there is no elements with key k. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If comp ordering function throws. - //! - //! <b>Note</b>: This function is used when constructing a value_type - //! is expensive and the value_type can be compared with a cheaper - //! key type. Usually this key is part of the value_type. - template<class KeyType, class KeyValueCompare> - std::pair<const_iterator, const_iterator> - equal_range(const KeyType& key, KeyValueCompare comp) const - { return tree_.equal_range(key, comp); } - - //! <b>Requires</b>: value must be an lvalue and shall be in a sg_multiset of - //! appropriate type. Otherwise the behavior is undefined. - //! - //! <b>Effects</b>: Returns: a valid iterator i belonging to the sg_multiset - //! that points to the value - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: This static function is available only if the <i>value traits</i> - //! is stateless. - static iterator s_iterator_to(reference value) - { return tree_type::s_iterator_to(value); } - - //! <b>Requires</b>: value must be an lvalue and shall be in a sg_multiset of - //! appropriate type. Otherwise the behavior is undefined. - //! - //! <b>Effects</b>: Returns: a valid const_iterator i belonging to the - //! sg_multiset that points to the value - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: This static function is available only if the <i>value traits</i> - //! is stateless. - static const_iterator s_iterator_to(const_reference value) - { return tree_type::s_iterator_to(value); } - - //! <b>Requires</b>: value must be an lvalue and shall be in a sg_multiset of - //! appropriate type. Otherwise the behavior is undefined. - //! - //! <b>Effects</b>: Returns: a valid iterator i belonging to the sg_multiset - //! that points to the value - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - iterator iterator_to(reference value) - { return tree_.iterator_to(value); } - - //! <b>Requires</b>: value must be an lvalue and shall be in a sg_multiset of - //! appropriate type. Otherwise the behavior is undefined. - //! - //! <b>Effects</b>: Returns: a valid const_iterator i belonging to the - //! sg_multiset that points to the value - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_iterator iterator_to(const_reference value) const - { return tree_.iterator_to(value); } - - //! <b>Requires</b>: value shall not be in a sg_multiset/sg_multiset. - //! - //! <b>Effects</b>: init_node puts the hook of a value in a well-known default - //! state. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant time. - //! - //! <b>Note</b>: This function puts the hook in the well-known default state - //! used by auto_unlink and safe hooks. - static void init_node(reference value) - { tree_type::init_node(value); } - - //! <b>Effects</b>: Unlinks the leftmost node from the tree. - //! - //! <b>Complexity</b>: Average complexity is constant time. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Notes</b>: This function breaks the tree and the tree can - //! only be used for more unlink_leftmost_without_rebalance calls. - //! This function is normally used to achieve a step by step - //! controlled destruction of the tree. - pointer unlink_leftmost_without_rebalance() - { return tree_.unlink_leftmost_without_rebalance(); } - - //! <b>Requires</b>: replace_this must be a valid iterator of *this - //! and with_this must not be inserted in any tree. - //! - //! <b>Effects</b>: Replaces replace_this in its position in the - //! tree with with_this. The tree does not need to be rebalanced. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: This function will break container ordering invariants if - //! with_this is not equivalent to *replace_this according to the - //! ordering rules. This function is faster than erasing and inserting - //! the node, since no rebalancing or comparison is needed. - void replace_node(iterator replace_this, reference with_this) - { tree_.replace_node(replace_this, with_this); } - - //! <b>Effects</b>: Rebalances the tree. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Linear. - void rebalance() - { tree_.rebalance(); } - - //! <b>Requires</b>: old_root is a node of a tree. - //! - //! <b>Effects</b>: Rebalances the subtree rooted at old_root. - //! - //! <b>Returns</b>: The new root of the subtree. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Linear to the elements in the subtree. - iterator rebalance_subtree(iterator root) - { return tree_.rebalance_subtree(root); } - - //! <b>Returns</b>: The balance factor (alpha) used in this tree - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - float balance_factor() const - { return tree_.balance_factor(); } - - //! <b>Requires</b>: new_alpha must be a value between 0.5 and 1.0 - //! - //! <b>Effects</b>: Establishes a new balance factor (alpha) and rebalances - //! the tree if the new balance factor is stricter (less) than the old factor. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Linear to the elements in the subtree. - void balance_factor(float new_alpha) - { tree_.balance_factor(new_alpha); } - - /// @cond - friend bool operator==(const sg_multiset_impl &x, const sg_multiset_impl &y) - { return x.tree_ == y.tree_; } - - friend bool operator<(const sg_multiset_impl &x, const sg_multiset_impl &y) - { return x.tree_ < y.tree_; } - /// @endcond -}; - -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -inline bool operator!= -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -(const sg_multiset_impl<T, Options...> &x, const sg_multiset_impl<T, Options...> &y) -#else -(const sg_multiset_impl<Config> &x, const sg_multiset_impl<Config> &y) -#endif -{ return !(x == y); } - -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -inline bool operator> -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -(const sg_multiset_impl<T, Options...> &x, const sg_multiset_impl<T, Options...> &y) -#else -(const sg_multiset_impl<Config> &x, const sg_multiset_impl<Config> &y) -#endif -{ return y < x; } - -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -inline bool operator<= -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -(const sg_multiset_impl<T, Options...> &x, const sg_multiset_impl<T, Options...> &y) -#else -(const sg_multiset_impl<Config> &x, const sg_multiset_impl<Config> &y) -#endif -{ return !(y < x); } - -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -inline bool operator>= -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -(const sg_multiset_impl<T, Options...> &x, const sg_multiset_impl<T, Options...> &y) -#else -(const sg_multiset_impl<Config> &x, const sg_multiset_impl<Config> &y) -#endif -{ return !(x < y); } - -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -inline void swap -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -(sg_multiset_impl<T, Options...> &x, sg_multiset_impl<T, Options...> &y) -#else -(sg_multiset_impl<Config> &x, sg_multiset_impl<Config> &y) -#endif -{ x.swap(y); } - -//! Helper metafunction to define a \c sg_multiset that yields to the same type when the -//! same options (either explicitly or implicitly) are used. -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) || defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template<class T, class ...Options> -#else -template<class T, class O1 = none, class O2 = none - , class O3 = none, class O4 = none> -#endif -struct make_sg_multiset -{ - /// @cond - typedef sg_multiset_impl - < typename make_sgtree_opt<T, - #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) - O1, O2, O3, O4 - #else - Options... - #endif - >::type - > implementation_defined; - /// @endcond - typedef implementation_defined type; -}; - -#ifndef BOOST_INTRUSIVE_DOXYGEN_INVOKED - -#if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template<class T, class O1, class O2, class O3, class O4> -#else -template<class T, class ...Options> -#endif -class sg_multiset - : public make_sg_multiset<T, - #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) - O1, O2, O3, O4 - #else - Options... - #endif - >::type -{ - typedef typename make_sg_multiset - <T, - #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) - O1, O2, O3, O4 - #else - Options... - #endif - >::type Base; - BOOST_MOVABLE_BUT_NOT_COPYABLE(sg_multiset) - - public: - typedef typename Base::value_compare value_compare; - typedef typename Base::value_traits value_traits; - typedef typename Base::iterator iterator; - typedef typename Base::const_iterator const_iterator; - - //Assert if passed value traits are compatible with the type - BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value)); - - sg_multiset( const value_compare &cmp = value_compare() - , const value_traits &v_traits = value_traits()) - : Base(cmp, v_traits) - {} - - template<class Iterator> - sg_multiset( Iterator b, Iterator e - , const value_compare &cmp = value_compare() - , const value_traits &v_traits = value_traits()) - : Base(b, e, cmp, v_traits) - {} - - sg_multiset(BOOST_RV_REF(sg_multiset) x) - : Base(::boost::move(static_cast<Base&>(x))) - {} - - sg_multiset& operator=(BOOST_RV_REF(sg_multiset) x) - { this->Base::operator=(::boost::move(static_cast<Base&>(x))); return *this; } - - static sg_multiset &container_from_end_iterator(iterator end_iterator) - { return static_cast<sg_multiset &>(Base::container_from_end_iterator(end_iterator)); } - - static const sg_multiset &container_from_end_iterator(const_iterator end_iterator) - { return static_cast<const sg_multiset &>(Base::container_from_end_iterator(end_iterator)); } - - static sg_multiset &container_from_iterator(iterator it) - { return static_cast<sg_multiset &>(Base::container_from_iterator(it)); } - - static const sg_multiset &container_from_iterator(const_iterator it) - { return static_cast<const sg_multiset &>(Base::container_from_iterator(it)); } -}; - -#endif - -} //namespace intrusive -} //namespace boost - -#include <boost/intrusive/detail/config_end.hpp> - -#endif //BOOST_INTRUSIVE_SG_SET_HPP diff --git a/src/third_party/boost/boost/intrusive/sgtree.hpp b/src/third_party/boost/boost/intrusive/sgtree.hpp deleted file mode 100644 index 0c4177ba423..00000000000 --- a/src/third_party/boost/boost/intrusive/sgtree.hpp +++ /dev/null @@ -1,1911 +0,0 @@ -///////////////////////////////////////////////////////////////////////////// -// -// (C) Copyright Ion Gaztanaga 2007-2009 -// -// Distributed under the Boost Software License, Version 1.0. -// (See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) -// -// See http://www.boost.org/libs/intrusive for documentation. -// -///////////////////////////////////////////////////////////////////////////// -// -// The option that yields to non-floating point 1/sqrt(2) alpha is taken -// from the scapegoat tree implementation of the PSPP library. -// -///////////////////////////////////////////////////////////////////////////// - -#ifndef BOOST_INTRUSIVE_SGTREE_HPP -#define BOOST_INTRUSIVE_SGTREE_HPP - -#include <boost/intrusive/detail/config_begin.hpp> -#include <algorithm> -#include <cstddef> -#include <functional> -#include <iterator> -#include <utility> -#include <cmath> -#include <cstddef> -#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> -#include <boost/intrusive/detail/ebo_functor_holder.hpp> -#include <boost/intrusive/pointer_traits.hpp> -#include <boost/intrusive/detail/clear_on_destructor_base.hpp> -#include <boost/intrusive/detail/mpl.hpp> -#include <boost/intrusive/detail/utilities.hpp> -#include <boost/intrusive/options.hpp> -#include <boost/intrusive/sgtree_algorithms.hpp> -#include <boost/intrusive/link_mode.hpp> -#include <boost/move/move.hpp> - -namespace boost { -namespace intrusive { - -/// @cond - -namespace detail{ - -//! Returns floor(log(n)/log(sqrt(2))) -> floor(2*log2(n)) -//! Undefined if N is 0. -//! -//! This function does not use float point operations. -inline std::size_t calculate_h_sqrt2 (std::size_t n) -{ - std::size_t f_log2 = detail::floor_log2(n); - return (2*f_log2) + (n >= detail::sqrt2_pow_2xplus1 (f_log2)); -} - -struct h_alpha_sqrt2_t -{ - h_alpha_sqrt2_t(void){} - std::size_t operator()(std::size_t n) const - { return calculate_h_sqrt2(n); } -}; - -struct alpha_0_75_by_max_size_t -{ - alpha_0_75_by_max_size_t(void){} - std::size_t operator()(std::size_t max_tree_size) const - { - const std::size_t max_tree_size_limit = ((~std::size_t(0))/std::size_t(3)); - return max_tree_size > max_tree_size_limit ? max_tree_size/4*3 : max_tree_size*3/4; - } -}; - -struct h_alpha_t -{ - h_alpha_t(float inv_minus_logalpha) - : inv_minus_logalpha_(inv_minus_logalpha) - {} - - std::size_t operator()(std::size_t n) const - { - //Returns floor(log1/alpha(n)) -> - // floor(log(n)/log(1/alpha)) -> - // floor(log(n)/(-log(alpha))) - //return static_cast<std::size_t>(std::log(float(n))*inv_minus_logalpha_); - return static_cast<std::size_t>(detail::fast_log2(float(n))*inv_minus_logalpha_); - } - - private: - //Since the function will be repeatedly called - //precalculate constant data to avoid repeated - //calls to log and division. - //This will store 1/(-std::log(alpha_)) - float inv_minus_logalpha_; -}; - -struct alpha_by_max_size_t -{ - alpha_by_max_size_t(float alpha) - : alpha_(alpha) - {} - - float operator()(std::size_t max_tree_size) const - { return float(max_tree_size)*alpha_; } - - private: - float alpha_; - float inv_minus_logalpha_; -}; - -template<bool Activate> -struct alpha_holder -{ - typedef boost::intrusive::detail::h_alpha_t h_alpha_t; - typedef boost::intrusive::detail::alpha_by_max_size_t multiply_by_alpha_t; - - alpha_holder() - { set_alpha(0.7f); } - - float get_alpha() const - { return alpha_; } - - void set_alpha(float alpha) - { - alpha_ = alpha; - inv_minus_logalpha_ = 1/(-detail::fast_log2(alpha)); - } - - h_alpha_t get_h_alpha_t() const - { return h_alpha_t(inv_minus_logalpha_); } - - multiply_by_alpha_t get_multiply_by_alpha_t() const - { return multiply_by_alpha_t(alpha_); } - - private: - float alpha_; - float inv_minus_logalpha_; -}; - -template<> -struct alpha_holder<false> -{ - //This specialization uses alpha = 1/sqrt(2) - //without using floating point operations - //Downside: alpha CAN't be changed. - typedef boost::intrusive::detail::h_alpha_sqrt2_t h_alpha_t; - typedef boost::intrusive::detail::alpha_0_75_by_max_size_t multiply_by_alpha_t; - - float get_alpha() const - { return 0.70710677f; } - - void set_alpha(float) - { //alpha CAN't be changed. - BOOST_INTRUSIVE_INVARIANT_ASSERT(0); - } - - h_alpha_t get_h_alpha_t() const - { return h_alpha_t(); } - - multiply_by_alpha_t get_multiply_by_alpha_t() const - { return multiply_by_alpha_t(); } -}; - -} //namespace detail{ - -template <class ValueTraits, class Compare, class SizeType, bool FloatingPoint> -struct sg_setopt -{ - typedef ValueTraits value_traits; - typedef Compare compare; - typedef SizeType size_type; - static const bool floating_point = FloatingPoint; -}; - -template <class T> -struct sg_set_defaults - : pack_options - < none - , base_hook<detail::default_bs_set_hook> - , floating_point<true> - , size_type<std::size_t> - , compare<std::less<T> > - >::type -{}; - -/// @endcond - -//! The class template sgtree is an intrusive scapegoat tree container, that -//! is used to construct intrusive sg_set and sg_multiset containers. -//! The no-throw guarantee holds only, if the value_compare object -//! doesn't throw. -//! -//! The template parameter \c T is the type to be managed by the container. -//! The user can specify additional options and if no options are provided -//! default options are used. -//! -//! The container supports the following options: -//! \c base_hook<>/member_hook<>/value_traits<>, -//! \c floating_point<>, \c size_type<> and -//! \c compare<>. -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -class sgtree_impl - : private detail::clear_on_destructor_base<sgtree_impl<Config> > -{ - template<class C> friend class detail::clear_on_destructor_base; - public: - typedef typename Config::value_traits value_traits; - /// @cond - static const bool external_value_traits = - detail::external_value_traits_is_true<value_traits>::value; - typedef typename detail::eval_if_c - < external_value_traits - , detail::eval_value_traits<value_traits> - , detail::identity<value_traits> - >::type real_value_traits; - /// @endcond - typedef typename real_value_traits::pointer pointer; - typedef typename real_value_traits::const_pointer const_pointer; - typedef typename pointer_traits<pointer>::element_type value_type; - typedef value_type key_type; - typedef typename pointer_traits<pointer>::reference reference; - typedef typename pointer_traits<const_pointer>::reference const_reference; - typedef typename pointer_traits<const_pointer>::difference_type difference_type; - typedef typename Config::size_type size_type; - typedef typename Config::compare value_compare; - typedef value_compare key_compare; - typedef tree_iterator<sgtree_impl, false> iterator; - typedef tree_iterator<sgtree_impl, true> const_iterator; - typedef boost::intrusive::detail::reverse_iterator<iterator> reverse_iterator; - typedef boost::intrusive::detail::reverse_iterator<const_iterator>const_reverse_iterator; - typedef typename real_value_traits::node_traits node_traits; - typedef typename node_traits::node node; - typedef typename pointer_traits - <pointer>::template rebind_pointer - <node>::type node_ptr; - typedef typename pointer_traits - <pointer>::template rebind_pointer - <const node>::type const_node_ptr; - typedef sgtree_algorithms<node_traits> node_algorithms; - - static const bool floating_point = Config::floating_point; - static const bool constant_time_size = true; - static const bool stateful_value_traits = detail::is_stateful_value_traits<real_value_traits>::value; - - /// @cond - private: - typedef detail::size_holder<true, size_type> size_traits; - typedef detail::alpha_holder<floating_point> alpha_traits; - typedef typename alpha_traits::h_alpha_t h_alpha_t; - typedef typename alpha_traits::multiply_by_alpha_t multiply_by_alpha_t; - - //noncopyable - BOOST_MOVABLE_BUT_NOT_COPYABLE(sgtree_impl) - - enum { safemode_or_autounlink = - (int)real_value_traits::link_mode == (int)auto_unlink || - (int)real_value_traits::link_mode == (int)safe_link }; - - BOOST_STATIC_ASSERT(((int)real_value_traits::link_mode != (int)auto_unlink)); - - //BOOST_STATIC_ASSERT(( - // (int)real_value_traits::link_mode != (int)auto_unlink || - // !floating_point - // )); - - struct header_plus_alpha : public alpha_traits - { node header_; }; - - struct node_plus_pred_t : public detail::ebo_functor_holder<value_compare> - { - node_plus_pred_t(const value_compare &comp) - : detail::ebo_functor_holder<value_compare>(comp) - {} - header_plus_alpha header_plus_alpha_; - size_traits size_traits_; - }; - - struct data_t : public sgtree_impl::value_traits - { - typedef typename sgtree_impl::value_traits value_traits; - data_t(const value_compare & comp, const value_traits &val_traits) - : value_traits(val_traits), node_plus_pred_(comp) - , max_tree_size_(0) - {} - node_plus_pred_t node_plus_pred_; - size_type max_tree_size_; - } data_; - - float priv_alpha() const - { return this->priv_alpha_traits().get_alpha(); } - - void priv_alpha(float alpha) - { return this->priv_alpha_traits().set_alpha(alpha); } - - const value_compare &priv_comp() const - { return data_.node_plus_pred_.get(); } - - value_compare &priv_comp() - { return data_.node_plus_pred_.get(); } - - const value_traits &priv_value_traits() const - { return data_; } - - value_traits &priv_value_traits() - { return data_; } - - node_ptr priv_header_ptr() - { return pointer_traits<node_ptr>::pointer_to(data_.node_plus_pred_.header_plus_alpha_.header_); } - - const_node_ptr priv_header_ptr() const - { return pointer_traits<const_node_ptr>::pointer_to(data_.node_plus_pred_.header_plus_alpha_.header_); } - - static node_ptr uncast(const const_node_ptr & ptr) - { return pointer_traits<node_ptr>::const_cast_from(ptr); } - - size_traits &priv_size_traits() - { return data_.node_plus_pred_.size_traits_; } - - const size_traits &priv_size_traits() const - { return data_.node_plus_pred_.size_traits_; } - - alpha_traits &priv_alpha_traits() - { return data_.node_plus_pred_.header_plus_alpha_; } - - const alpha_traits &priv_alpha_traits() const - { return data_.node_plus_pred_.header_plus_alpha_; } - - const real_value_traits &get_real_value_traits(detail::bool_<false>) const - { return data_; } - - const real_value_traits &get_real_value_traits(detail::bool_<true>) const - { return data_.get_value_traits(*this); } - - real_value_traits &get_real_value_traits(detail::bool_<false>) - { return data_; } - - real_value_traits &get_real_value_traits(detail::bool_<true>) - { return data_.get_value_traits(*this); } - - h_alpha_t get_h_alpha_func() const - { return priv_alpha_traits().get_h_alpha_t(); } - - multiply_by_alpha_t get_alpha_by_max_size_func() const - { return priv_alpha_traits().get_multiply_by_alpha_t(); } - - /// @endcond - - public: - - const real_value_traits &get_real_value_traits() const - { return this->get_real_value_traits(detail::bool_<external_value_traits>()); } - - real_value_traits &get_real_value_traits() - { return this->get_real_value_traits(detail::bool_<external_value_traits>()); } - - typedef typename node_algorithms::insert_commit_data insert_commit_data; - - //! <b>Effects</b>: Constructs an empty tree. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: If value_traits::node_traits::node - //! constructor throws (this does not happen with predefined Boost.Intrusive hooks) - //! or the copy constructorof the value_compare object throws. Basic guarantee. - sgtree_impl( const value_compare &cmp = value_compare() - , const value_traits &v_traits = value_traits()) - : data_(cmp, v_traits) - { - node_algorithms::init_header(this->priv_header_ptr()); - this->priv_size_traits().set_size(size_type(0)); - } - - //! <b>Requires</b>: Dereferencing iterator must yield an lvalue of type value_type. - //! cmp must be a comparison function that induces a strict weak ordering. - //! - //! <b>Effects</b>: Constructs an empty tree and inserts elements from - //! [b, e). - //! - //! <b>Complexity</b>: Linear in N if [b, e) is already sorted using - //! comp and otherwise N * log N, where N is the distance between first and last. - //! - //! <b>Throws</b>: If value_traits::node_traits::node - //! constructor throws (this does not happen with predefined Boost.Intrusive hooks) - //! or the copy constructor/operator() of the value_compare object throws. Basic guarantee. - template<class Iterator> - sgtree_impl( bool unique, Iterator b, Iterator e - , const value_compare &cmp = value_compare() - , const value_traits &v_traits = value_traits()) - : data_(cmp, v_traits) - { - node_algorithms::init_header(this->priv_header_ptr()); - this->priv_size_traits().set_size(size_type(0)); - if(unique) - this->insert_unique(b, e); - else - this->insert_equal(b, e); - } - - //! <b>Effects</b>: to-do - //! - sgtree_impl(BOOST_RV_REF(sgtree_impl) x) - : data_(::boost::move(x.priv_comp()), ::boost::move(x.priv_value_traits())) - { - node_algorithms::init_header(this->priv_header_ptr()); - this->priv_size_traits().set_size(size_type(0)); - this->swap(x); - } - - //! <b>Effects</b>: to-do - //! - sgtree_impl& operator=(BOOST_RV_REF(sgtree_impl) x) - { this->swap(x); return *this; } - - //! <b>Effects</b>: Detaches all elements from this. The objects in the set - //! are not deleted (i.e. no destructors are called), but the nodes according to - //! the value_traits template parameter are reinitialized and thus can be reused. - //! - //! <b>Complexity</b>: Linear to elements contained in *this. - //! - //! <b>Throws</b>: Nothing. - ~sgtree_impl() - {} - - //! <b>Effects</b>: Returns an iterator pointing to the beginning of the tree. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - iterator begin() - { return iterator (node_traits::get_left(this->priv_header_ptr()), this); } - - //! <b>Effects</b>: Returns a const_iterator pointing to the beginning of the tree. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_iterator begin() const - { return cbegin(); } - - //! <b>Effects</b>: Returns a const_iterator pointing to the beginning of the tree. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_iterator cbegin() const - { return const_iterator (node_traits::get_left(this->priv_header_ptr()), this); } - - //! <b>Effects</b>: Returns an iterator pointing to the end of the tree. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - iterator end() - { return iterator (this->priv_header_ptr(), this); } - - //! <b>Effects</b>: Returns a const_iterator pointing to the end of the tree. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_iterator end() const - { return cend(); } - - //! <b>Effects</b>: Returns a const_iterator pointing to the end of the tree. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_iterator cend() const - { return const_iterator (uncast(this->priv_header_ptr()), this); } - - //! <b>Effects</b>: Returns a reverse_iterator pointing to the beginning of the - //! reversed tree. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - reverse_iterator rbegin() - { return reverse_iterator(end()); } - - //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning - //! of the reversed tree. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_reverse_iterator rbegin() const - { return const_reverse_iterator(end()); } - - //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning - //! of the reversed tree. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_reverse_iterator crbegin() const - { return const_reverse_iterator(end()); } - - //! <b>Effects</b>: Returns a reverse_iterator pointing to the end - //! of the reversed tree. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - reverse_iterator rend() - { return reverse_iterator(begin()); } - - //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the end - //! of the reversed tree. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_reverse_iterator rend() const - { return const_reverse_iterator(begin()); } - - //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the end - //! of the reversed tree. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_reverse_iterator crend() const - { return const_reverse_iterator(begin()); } - - //! <b>Precondition</b>: end_iterator must be a valid end iterator - //! of sgtree. - //! - //! <b>Effects</b>: Returns a const reference to the sgtree associated to the end iterator - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - static sgtree_impl &container_from_end_iterator(iterator end_iterator) - { return priv_container_from_end_iterator(end_iterator); } - - //! <b>Precondition</b>: end_iterator must be a valid end const_iterator - //! of sgtree. - //! - //! <b>Effects</b>: Returns a const reference to the sgtree associated to the end iterator - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - static const sgtree_impl &container_from_end_iterator(const_iterator end_iterator) - { return priv_container_from_end_iterator(end_iterator); } - - //! <b>Precondition</b>: it must be a valid iterator - //! of rbtree. - //! - //! <b>Effects</b>: Returns a const reference to the tree associated to the iterator - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Logarithmic. - static sgtree_impl &container_from_iterator(iterator it) - { return priv_container_from_iterator(it); } - - //! <b>Precondition</b>: it must be a valid end const_iterator - //! of rbtree. - //! - //! <b>Effects</b>: Returns a const reference to the tree associated to the iterator - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Logarithmic. - static const sgtree_impl &container_from_iterator(const_iterator it) - { return priv_container_from_iterator(it); } - - //! <b>Effects</b>: Returns the value_compare object used by the tree. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: If value_compare copy-constructor throws. - value_compare value_comp() const - { return priv_comp(); } - - //! <b>Effects</b>: Returns true if the container is empty. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - bool empty() const - { return node_algorithms::unique(this->priv_header_ptr()); } - - //! <b>Effects</b>: Returns the number of elements stored in the tree. - //! - //! <b>Complexity</b>: Linear to elements contained in *this - //! if constant-time size option is disabled. Constant time otherwise. - //! - //! <b>Throws</b>: Nothing. - size_type size() const - { - if(constant_time_size) - return this->priv_size_traits().get_size(); - else{ - return (size_type)node_algorithms::size(this->priv_header_ptr()); - } - } - - //! <b>Effects</b>: Swaps the contents of two sgtrees. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: If the comparison functor's swap call throws. - void swap(sgtree_impl& other) - { - //This can throw - using std::swap; - swap(priv_comp(), priv_comp()); - swap(priv_alpha_traits(), priv_alpha_traits()); - swap(data_.max_tree_size_, other.data_.max_tree_size_); - //These can't throw - node_algorithms::swap_tree(this->priv_header_ptr(), other.priv_header_ptr()); - if(constant_time_size){ - size_type backup = this->priv_size_traits().get_size(); - this->priv_size_traits().set_size(other.priv_size_traits().get_size()); - other.priv_size_traits().set_size(backup); - } - } - - //! <b>Requires</b>: value must be an lvalue - //! - //! <b>Effects</b>: Inserts value into the tree before the upper bound. - //! - //! <b>Complexity</b>: Average complexity for insert element is at - //! most logarithmic. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. Strong guarantee. - //! - //! <b>Note</b>: Does not affect the validity of iterators and references. - //! No copy-constructors are called. - iterator insert_equal(reference value) - { - detail::key_nodeptr_comp<value_compare, sgtree_impl> - key_node_comp(priv_comp(), this); - node_ptr to_insert(get_real_value_traits().to_node_ptr(value)); - if(safemode_or_autounlink) - BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert)); - std::size_t max_tree_size = (std::size_t)data_.max_tree_size_; - node_ptr p = node_algorithms::insert_equal_upper_bound - (this->priv_header_ptr(), to_insert, key_node_comp - , (size_type)this->size(), this->get_h_alpha_func(), max_tree_size); - this->priv_size_traits().increment(); - data_.max_tree_size_ = (size_type)max_tree_size; - return iterator(p, this); - } - - //! <b>Requires</b>: value must be an lvalue, and "hint" must be - //! a valid iterator. - //! - //! <b>Effects</b>: Inserts x into the tree, using "hint" as a hint to - //! where it will be inserted. If "hint" is the upper_bound - //! the insertion takes constant time (two comparisons in the worst case) - //! - //! <b>Complexity</b>: Logarithmic in general, but it is amortized - //! constant time if t is inserted immediately before hint. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Does not affect the validity of iterators and references. - //! No copy-constructors are called. - iterator insert_equal(const_iterator hint, reference value) - { - detail::key_nodeptr_comp<value_compare, sgtree_impl> - key_node_comp(priv_comp(), this); - node_ptr to_insert(get_real_value_traits().to_node_ptr(value)); - if(safemode_or_autounlink) - BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert)); - std::size_t max_tree_size = (std::size_t)data_.max_tree_size_; - node_ptr p = node_algorithms::insert_equal - (this->priv_header_ptr(), hint.pointed_node(), to_insert, key_node_comp - , (std::size_t)this->size(), this->get_h_alpha_func(), max_tree_size); - this->priv_size_traits().increment(); - data_.max_tree_size_ = (size_type)max_tree_size; - return iterator(p, this); - } - - //! <b>Requires</b>: Dereferencing iterator must yield an lvalue - //! of type value_type. - //! - //! <b>Effects</b>: Inserts a each element of a range into the tree - //! before the upper bound of the key of each element. - //! - //! <b>Complexity</b>: Insert range is in general O(N * log(N)), where N is the - //! size of the range. However, it is linear in N if the range is already sorted - //! by value_comp(). - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Does not affect the validity of iterators and references. - //! No copy-constructors are called. - template<class Iterator> - void insert_equal(Iterator b, Iterator e) - { - iterator end(this->end()); - for (; b != e; ++b) - this->insert_equal(end, *b); - } - - //! <b>Requires</b>: value must be an lvalue - //! - //! <b>Effects</b>: Inserts value into the tree if the value - //! is not already present. - //! - //! <b>Complexity</b>: Average complexity for insert element is at - //! most logarithmic. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Does not affect the validity of iterators and references. - //! No copy-constructors are called. - std::pair<iterator, bool> insert_unique(reference value) - { - insert_commit_data commit_data; - std::pair<iterator, bool> ret = insert_unique_check(value, priv_comp(), commit_data); - if(!ret.second) - return ret; - return std::pair<iterator, bool> (insert_unique_commit(value, commit_data), true); - } - - //! <b>Requires</b>: value must be an lvalue, and "hint" must be - //! a valid iterator - //! - //! <b>Effects</b>: Tries to insert x into the tree, using "hint" as a hint - //! to where it will be inserted. - //! - //! <b>Complexity</b>: Logarithmic in general, but it is amortized - //! constant time (two comparisons in the worst case) - //! if t is inserted immediately before hint. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Does not affect the validity of iterators and references. - //! No copy-constructors are called. - iterator insert_unique(const_iterator hint, reference value) - { - insert_commit_data commit_data; - std::pair<iterator, bool> ret = insert_unique_check(hint, value, priv_comp(), commit_data); - if(!ret.second) - return ret.first; - return insert_unique_commit(value, commit_data); - } - - //! <b>Requires</b>: Dereferencing iterator must yield an lvalue - //! of type value_type. - //! - //! <b>Effects</b>: Tries to insert each element of a range into the tree. - //! - //! <b>Complexity</b>: Insert range is in general O(N * log(N)), where N is the - //! size of the range. However, it is linear in N if the range is already sorted - //! by value_comp(). - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Does not affect the validity of iterators and references. - //! No copy-constructors are called. - template<class Iterator> - void insert_unique(Iterator b, Iterator e) - { - if(this->empty()){ - iterator end(this->end()); - for (; b != e; ++b) - this->insert_unique(end, *b); - } - else{ - for (; b != e; ++b) - this->insert_unique(*b); - } - } - - //! <b>Requires</b>: key_value_comp must be a comparison function that induces - //! the same strict weak ordering as value_compare. The difference is that - //! key_value_comp compares an arbitrary key with the contained values. - //! - //! <b>Effects</b>: Checks if a value can be inserted in the container, using - //! a user provided key instead of the value itself. - //! - //! <b>Returns</b>: If there is an equivalent value - //! returns a pair containing an iterator to the already present value - //! and false. If the value can be inserted returns true in the returned - //! pair boolean and fills "commit_data" that is meant to be used with - //! the "insert_commit" function. - //! - //! <b>Complexity</b>: Average complexity is at most logarithmic. - //! - //! <b>Throws</b>: If the key_value_comp ordering function throws. Strong guarantee. - //! - //! <b>Notes</b>: This function is used to improve performance when constructing - //! a value_type is expensive: if there is an equivalent value - //! the constructed object must be discarded. Many times, the part of the - //! node that is used to impose the order is much cheaper to construct - //! than the value_type and this function offers the possibility to use that - //! part to check if the insertion will be successful. - //! - //! If the check is successful, the user can construct the value_type and use - //! "insert_commit" to insert the object in constant-time. This gives a total - //! logarithmic complexity to the insertion: check(O(log(N)) + commit(O(1)). - //! - //! "commit_data" remains valid for a subsequent "insert_commit" only if no more - //! objects are inserted or erased from the container. - template<class KeyType, class KeyValueCompare> - std::pair<iterator, bool> insert_unique_check - (const KeyType &key, KeyValueCompare key_value_comp, insert_commit_data &commit_data) - { - detail::key_nodeptr_comp<KeyValueCompare, sgtree_impl> - comp(key_value_comp, this); - std::pair<node_ptr, bool> ret = - (node_algorithms::insert_unique_check - (this->priv_header_ptr(), key, comp, commit_data)); - return std::pair<iterator, bool>(iterator(ret.first, this), ret.second); - } - - //! <b>Requires</b>: key_value_comp must be a comparison function that induces - //! the same strict weak ordering as value_compare. The difference is that - //! key_value_comp compares an arbitrary key with the contained values. - //! - //! <b>Effects</b>: Checks if a value can be inserted in the container, using - //! a user provided key instead of the value itself, using "hint" - //! as a hint to where it will be inserted. - //! - //! <b>Returns</b>: If there is an equivalent value - //! returns a pair containing an iterator to the already present value - //! and false. If the value can be inserted returns true in the returned - //! pair boolean and fills "commit_data" that is meant to be used with - //! the "insert_commit" function. - //! - //! <b>Complexity</b>: Logarithmic in general, but it's amortized - //! constant time if t is inserted immediately before hint. - //! - //! <b>Throws</b>: If the key_value_comp ordering function throws. Strong guarantee. - //! - //! <b>Notes</b>: This function is used to improve performance when constructing - //! a value_type is expensive: if there is an equivalent value - //! the constructed object must be discarded. Many times, the part of the - //! constructing that is used to impose the order is much cheaper to construct - //! than the value_type and this function offers the possibility to use that key - //! to check if the insertion will be successful. - //! - //! If the check is successful, the user can construct the value_type and use - //! "insert_commit" to insert the object in constant-time. This can give a total - //! constant-time complexity to the insertion: check(O(1)) + commit(O(1)). - //! - //! "commit_data" remains valid for a subsequent "insert_commit" only if no more - //! objects are inserted or erased from the container. - template<class KeyType, class KeyValueCompare> - std::pair<iterator, bool> insert_unique_check - (const_iterator hint, const KeyType &key - ,KeyValueCompare key_value_comp, insert_commit_data &commit_data) - { - detail::key_nodeptr_comp<KeyValueCompare, sgtree_impl> - comp(key_value_comp, this); - std::pair<node_ptr, bool> ret = - (node_algorithms::insert_unique_check - (this->priv_header_ptr(), hint.pointed_node(), key, comp, commit_data)); - return std::pair<iterator, bool>(iterator(ret.first, this), ret.second); - } - - //! <b>Requires</b>: value must be an lvalue of type value_type. commit_data - //! must have been obtained from a previous call to "insert_check". - //! No objects should have been inserted or erased from the container between - //! the "insert_check" that filled "commit_data" and the call to "insert_commit". - //! - //! <b>Effects</b>: Inserts the value in the avl_set using the information obtained - //! from the "commit_data" that a previous "insert_check" filled. - //! - //! <b>Returns</b>: An iterator to the newly inserted object. - //! - //! <b>Complexity</b>: Constant time. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Notes</b>: This function has only sense if a "insert_check" has been - //! previously executed to fill "commit_data". No value should be inserted or - //! erased between the "insert_check" and "insert_commit" calls. - iterator insert_unique_commit(reference value, const insert_commit_data &commit_data) - { - node_ptr to_insert(get_real_value_traits().to_node_ptr(value)); - if(safemode_or_autounlink) - BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert)); - std::size_t max_tree_size = (std::size_t)data_.max_tree_size_; - node_algorithms::insert_unique_commit - ( this->priv_header_ptr(), to_insert, commit_data - , (std::size_t)this->size(), this->get_h_alpha_func(), max_tree_size); - this->priv_size_traits().increment(); - data_.max_tree_size_ = (size_type)max_tree_size; - return iterator(to_insert, this); - } - - //! <b>Requires</b>: value must be an lvalue, "pos" must be - //! a valid iterator (or end) and must be the succesor of value - //! once inserted according to the predicate - //! - //! <b>Effects</b>: Inserts x into the tree before "pos". - //! - //! <b>Complexity</b>: Constant time. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: This function does not check preconditions so if "pos" is not - //! the successor of "value" tree ordering invariant will be broken. - //! This is a low-level function to be used only for performance reasons - //! by advanced users. - iterator insert_before(const_iterator pos, reference value) - { - node_ptr to_insert(get_real_value_traits().to_node_ptr(value)); - if(safemode_or_autounlink) - BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert)); - std::size_t max_tree_size = (std::size_t)data_.max_tree_size_; - node_ptr p = node_algorithms::insert_before - ( this->priv_header_ptr(), pos.pointed_node(), to_insert - , (size_type)this->size(), this->get_h_alpha_func(), max_tree_size); - this->priv_size_traits().increment(); - data_.max_tree_size_ = (size_type)max_tree_size; - return iterator(p, this); - } - - //! <b>Requires</b>: value must be an lvalue, and it must be no less - //! than the greatest inserted key - //! - //! <b>Effects</b>: Inserts x into the tree in the last position. - //! - //! <b>Complexity</b>: Constant time. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: This function does not check preconditions so if value is - //! less than the greatest inserted key tree ordering invariant will be broken. - //! This function is slightly more efficient than using "insert_before". - //! This is a low-level function to be used only for performance reasons - //! by advanced users. - void push_back(reference value) - { - node_ptr to_insert(get_real_value_traits().to_node_ptr(value)); - if(safemode_or_autounlink) - BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert)); - std::size_t max_tree_size = (std::size_t)data_.max_tree_size_; - node_algorithms::push_back - ( this->priv_header_ptr(), to_insert - , (size_type)this->size(), this->get_h_alpha_func(), max_tree_size); - this->priv_size_traits().increment(); - data_.max_tree_size_ = (size_type)max_tree_size; - } - - //! <b>Requires</b>: value must be an lvalue, and it must be no greater - //! than the minimum inserted key - //! - //! <b>Effects</b>: Inserts x into the tree in the first position. - //! - //! <b>Complexity</b>: Constant time. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: This function does not check preconditions so if value is - //! greater than the minimum inserted key tree ordering invariant will be broken. - //! This function is slightly more efficient than using "insert_before". - //! This is a low-level function to be used only for performance reasons - //! by advanced users. - void push_front(reference value) - { - node_ptr to_insert(get_real_value_traits().to_node_ptr(value)); - if(safemode_or_autounlink) - BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert)); - std::size_t max_tree_size = (std::size_t)data_.max_tree_size_; - node_algorithms::push_front - ( this->priv_header_ptr(), to_insert - , (size_type)this->size(), this->get_h_alpha_func(), max_tree_size); - this->priv_size_traits().increment(); - data_.max_tree_size_ = (size_type)max_tree_size; - } - - //! <b>Effects</b>: Erases the element pointed to by pos. - //! - //! <b>Complexity</b>: Average complexity for erase element is constant time. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - iterator erase(const_iterator i) - { - const_iterator ret(i); - ++ret; - node_ptr to_erase(i.pointed_node()); - if(safemode_or_autounlink) - BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(!node_algorithms::unique(to_erase)); - std::size_t max_tree_size = data_.max_tree_size_; - node_algorithms::erase - ( this->priv_header_ptr(), to_erase, (std::size_t)this->size() - , max_tree_size, this->get_alpha_by_max_size_func()); - data_.max_tree_size_ = (size_type)max_tree_size; - this->priv_size_traits().decrement(); - if(safemode_or_autounlink) - node_algorithms::init(to_erase); - return ret.unconst(); - } - - //! <b>Effects</b>: Erases the range pointed to by b end e. - //! - //! <b>Complexity</b>: Average complexity for erase range is at most - //! O(log(size() + N)), where N is the number of elements in the range. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - iterator erase(const_iterator b, const_iterator e) - { size_type n; return private_erase(b, e, n); } - - //! <b>Effects</b>: Erases all the elements with the given value. - //! - //! <b>Returns</b>: The number of erased elements. - //! - //! <b>Complexity</b>: O(log(size() + N). - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - size_type erase(const_reference value) - { return this->erase(value, priv_comp()); } - - //! <b>Effects</b>: Erases all the elements with the given key. - //! according to the comparison functor "comp". - //! - //! <b>Returns</b>: The number of erased elements. - //! - //! <b>Complexity</b>: O(log(size() + N). - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - template<class KeyType, class KeyValueCompare> - size_type erase(const KeyType& key, KeyValueCompare comp - /// @cond - , typename detail::enable_if_c<!detail::is_convertible<KeyValueCompare, const_iterator>::value >::type * = 0 - /// @endcond - ) - { - std::pair<iterator,iterator> p = this->equal_range(key, comp); - size_type n; - private_erase(p.first, p.second, n); - return n; - } - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! - //! <b>Effects</b>: Erases the element pointed to by pos. - //! Disposer::operator()(pointer) is called for the removed element. - //! - //! <b>Complexity</b>: Average complexity for erase element is constant time. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators - //! to the erased elements. - template<class Disposer> - iterator erase_and_dispose(const_iterator i, Disposer disposer) - { - node_ptr to_erase(i.pointed_node()); - iterator ret(this->erase(i)); - disposer(get_real_value_traits().to_value_ptr(to_erase)); - return ret; - } - - #if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) - template<class Disposer> - iterator erase_and_dispose(iterator i, Disposer disposer) - { return this->erase_and_dispose(const_iterator(i), disposer); } - #endif - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! - //! <b>Effects</b>: Erases the range pointed to by b end e. - //! Disposer::operator()(pointer) is called for the removed elements. - //! - //! <b>Complexity</b>: Average complexity for erase range is at most - //! O(log(size() + N)), where N is the number of elements in the range. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators - //! to the erased elements. - template<class Disposer> - iterator erase_and_dispose(const_iterator b, const_iterator e, Disposer disposer) - { size_type n; return private_erase(b, e, n, disposer); } - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! - //! <b>Effects</b>: Erases all the elements with the given value. - //! Disposer::operator()(pointer) is called for the removed elements. - //! - //! <b>Returns</b>: The number of erased elements. - //! - //! <b>Complexity</b>: O(log(size() + N). - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - template<class Disposer> - size_type erase_and_dispose(const_reference value, Disposer disposer) - { - std::pair<iterator,iterator> p = this->equal_range(value); - size_type n; - private_erase(p.first, p.second, n, disposer); - return n; - } - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! - //! <b>Effects</b>: Erases all the elements with the given key. - //! according to the comparison functor "comp". - //! Disposer::operator()(pointer) is called for the removed elements. - //! - //! <b>Returns</b>: The number of erased elements. - //! - //! <b>Complexity</b>: O(log(size() + N). - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators - //! to the erased elements. - template<class KeyType, class KeyValueCompare, class Disposer> - size_type erase_and_dispose(const KeyType& key, KeyValueCompare comp, Disposer disposer - /// @cond - , typename detail::enable_if_c<!detail::is_convertible<KeyValueCompare, const_iterator>::value >::type * = 0 - /// @endcond - ) - { - std::pair<iterator,iterator> p = this->equal_range(key, comp); - size_type n; - private_erase(p.first, p.second, n, disposer); - return n; - } - - //! <b>Effects</b>: Erases all of the elements. - //! - //! <b>Complexity</b>: Linear to the number of elements on the container. - //! if it's a safe-mode or auto-unlink value_type. Constant time otherwise. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - void clear() - { - if(safemode_or_autounlink){ - this->clear_and_dispose(detail::null_disposer()); - } - else{ - node_algorithms::init_header(this->priv_header_ptr()); - this->priv_size_traits().set_size(0); - } - } - - //! <b>Effects</b>: Erases all of the elements calling disposer(p) for - //! each node to be erased. - //! <b>Complexity</b>: Average complexity for is at most O(log(size() + N)), - //! where N is the number of elements in the container. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. Calls N times to disposer functor. - template<class Disposer> - void clear_and_dispose(Disposer disposer) - { - node_algorithms::clear_and_dispose(this->priv_header_ptr() - , detail::node_disposer<Disposer, sgtree_impl>(disposer, this)); - this->priv_size_traits().set_size(0); - } - - //! <b>Effects</b>: Returns the number of contained elements with the given value - //! - //! <b>Complexity</b>: Logarithmic to the number of elements contained plus lineal - //! to number of objects with the given value. - //! - //! <b>Throws</b>: Nothing. - size_type count(const_reference value) const - { return this->count(value, priv_comp()); } - - //! <b>Effects</b>: Returns the number of contained elements with the given key - //! - //! <b>Complexity</b>: Logarithmic to the number of elements contained plus lineal - //! to number of objects with the given key. - //! - //! <b>Throws</b>: Nothing. - template<class KeyType, class KeyValueCompare> - size_type count(const KeyType &key, KeyValueCompare comp) const - { - std::pair<const_iterator, const_iterator> ret = this->equal_range(key, comp); - return std::distance(ret.first, ret.second); - } - - //! <b>Effects</b>: Returns an iterator to the first element whose - //! key is not less than k or end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: Nothing. - iterator lower_bound(const_reference value) - { return this->lower_bound(value, priv_comp()); } - - //! <b>Effects</b>: Returns an iterator to the first element whose - //! key is not less than k or end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: Nothing. - const_iterator lower_bound(const_reference value) const - { return this->lower_bound(value, priv_comp()); } - - //! <b>Effects</b>: Returns an iterator to the first element whose - //! key is not less than k or end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: Nothing. - template<class KeyType, class KeyValueCompare> - iterator lower_bound(const KeyType &key, KeyValueCompare comp) - { - detail::key_nodeptr_comp<KeyValueCompare, sgtree_impl> - key_node_comp(comp, this); - return iterator(node_algorithms::lower_bound - (this->priv_header_ptr(), key, key_node_comp), this); - } - - //! <b>Effects</b>: Returns a const iterator to the first element whose - //! key is not less than k or end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: Nothing. - template<class KeyType, class KeyValueCompare> - const_iterator lower_bound(const KeyType &key, KeyValueCompare comp) const - { - detail::key_nodeptr_comp<KeyValueCompare, sgtree_impl> - key_node_comp(comp, this); - return const_iterator(node_algorithms::lower_bound - (this->priv_header_ptr(), key, key_node_comp), this); - } - - //! <b>Effects</b>: Returns an iterator to the first element whose - //! key is greater than k or end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: Nothing. - iterator upper_bound(const_reference value) - { return this->upper_bound(value, priv_comp()); } - - //! <b>Effects</b>: Returns an iterator to the first element whose - //! key is greater than k according to comp or end() if that element - //! does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: Nothing. - template<class KeyType, class KeyValueCompare> - iterator upper_bound(const KeyType &key, KeyValueCompare comp) - { - detail::key_nodeptr_comp<KeyValueCompare, sgtree_impl> - key_node_comp(comp, this); - return iterator(node_algorithms::upper_bound - (this->priv_header_ptr(), key, key_node_comp), this); - } - - //! <b>Effects</b>: Returns an iterator to the first element whose - //! key is greater than k or end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: Nothing. - const_iterator upper_bound(const_reference value) const - { return this->upper_bound(value, priv_comp()); } - - //! <b>Effects</b>: Returns an iterator to the first element whose - //! key is greater than k according to comp or end() if that element - //! does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: Nothing. - template<class KeyType, class KeyValueCompare> - const_iterator upper_bound(const KeyType &key, KeyValueCompare comp) const - { - detail::key_nodeptr_comp<KeyValueCompare, sgtree_impl> - key_node_comp(comp, this); - return const_iterator(node_algorithms::upper_bound - (this->priv_header_ptr(), key, key_node_comp), this); - } - - //! <b>Effects</b>: Finds an iterator to the first element whose key is - //! k or end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: Nothing. - iterator find(const_reference value) - { return this->find(value, priv_comp()); } - - //! <b>Effects</b>: Finds an iterator to the first element whose key is - //! k or end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: Nothing. - template<class KeyType, class KeyValueCompare> - iterator find(const KeyType &key, KeyValueCompare comp) - { - detail::key_nodeptr_comp<KeyValueCompare, sgtree_impl> - key_node_comp(comp, this); - return iterator - (node_algorithms::find(this->priv_header_ptr(), key, key_node_comp), this); - } - - //! <b>Effects</b>: Finds a const_iterator to the first element whose key is - //! k or end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: Nothing. - const_iterator find(const_reference value) const - { return this->find(value, priv_comp()); } - - //! <b>Effects</b>: Finds a const_iterator to the first element whose key is - //! k or end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: Nothing. - template<class KeyType, class KeyValueCompare> - const_iterator find(const KeyType &key, KeyValueCompare comp) const - { - detail::key_nodeptr_comp<KeyValueCompare, sgtree_impl> - key_node_comp(comp, this); - return const_iterator - (node_algorithms::find(this->priv_header_ptr(), key, key_node_comp), this); - } - - //! <b>Effects</b>: Finds a range containing all elements whose key is k or - //! an empty range that indicates the position where those elements would be - //! if they there is no elements with key k. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: Nothing. - std::pair<iterator,iterator> equal_range(const_reference value) - { return this->equal_range(value, priv_comp()); } - - //! <b>Effects</b>: Finds a range containing all elements whose key is k or - //! an empty range that indicates the position where those elements would be - //! if they there is no elements with key k. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: Nothing. - template<class KeyType, class KeyValueCompare> - std::pair<iterator,iterator> equal_range(const KeyType &key, KeyValueCompare comp) - { - detail::key_nodeptr_comp<KeyValueCompare, sgtree_impl> - key_node_comp(comp, this); - std::pair<node_ptr, node_ptr> ret - (node_algorithms::equal_range(this->priv_header_ptr(), key, key_node_comp)); - return std::pair<iterator, iterator>(iterator(ret.first, this), iterator(ret.second, this)); - } - - //! <b>Effects</b>: Finds a range containing all elements whose key is k or - //! an empty range that indicates the position where those elements would be - //! if they there is no elements with key k. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: Nothing. - std::pair<const_iterator, const_iterator> - equal_range(const_reference value) const - { return this->equal_range(value, priv_comp()); } - - //! <b>Effects</b>: Finds a range containing all elements whose key is k or - //! an empty range that indicates the position where those elements would be - //! if they there is no elements with key k. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: Nothing. - template<class KeyType, class KeyValueCompare> - std::pair<const_iterator, const_iterator> - equal_range(const KeyType &key, KeyValueCompare comp) const - { - detail::key_nodeptr_comp<KeyValueCompare, sgtree_impl> - key_node_comp(comp, this); - std::pair<node_ptr, node_ptr> ret - (node_algorithms::equal_range(this->priv_header_ptr(), key, key_node_comp)); - return std::pair<const_iterator, const_iterator>(const_iterator(ret.first, this), const_iterator(ret.second, this)); - } - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! Cloner should yield to nodes equivalent to the original nodes. - //! - //! <b>Effects</b>: Erases all the elements from *this - //! calling Disposer::operator()(pointer), clones all the - //! elements from src calling Cloner::operator()(const_reference ) - //! and inserts them on *this. Copies the predicate from the source container. - //! - //! If cloner throws, all cloned elements are unlinked and disposed - //! calling Disposer::operator()(pointer). - //! - //! <b>Complexity</b>: Linear to erased plus inserted elements. - //! - //! <b>Throws</b>: If cloner throws or predicate copy assignment throws. Basic guarantee. - template <class Cloner, class Disposer> - void clone_from(const sgtree_impl &src, Cloner cloner, Disposer disposer) - { - this->clear_and_dispose(disposer); - if(!src.empty()){ - detail::exception_disposer<sgtree_impl, Disposer> - rollback(*this, disposer); - node_algorithms::clone - (src.priv_header_ptr() - ,this->priv_header_ptr() - ,detail::node_cloner<Cloner, sgtree_impl>(cloner, this) - ,detail::node_disposer<Disposer, sgtree_impl>(disposer, this)); - this->priv_size_traits().set_size(src.priv_size_traits().get_size()); - this->priv_comp() = src.priv_comp(); - rollback.release(); - } - } - - //! <b>Effects</b>: Unlinks the leftmost node from the tree. - //! - //! <b>Complexity</b>: Average complexity is constant time. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Notes</b>: This function breaks the tree and the tree can - //! only be used for more unlink_leftmost_without_rebalance calls. - //! This function is normally used to achieve a step by step - //! controlled destruction of the tree. - pointer unlink_leftmost_without_rebalance() - { - node_ptr to_be_disposed(node_algorithms::unlink_leftmost_without_rebalance - (this->priv_header_ptr())); - if(!to_be_disposed) - return 0; - this->priv_size_traits().decrement(); - if(safemode_or_autounlink)//If this is commented does not work with normal_link - node_algorithms::init(to_be_disposed); - return get_real_value_traits().to_value_ptr(to_be_disposed); - } - - //! <b>Requires</b>: replace_this must be a valid iterator of *this - //! and with_this must not be inserted in any tree. - //! - //! <b>Effects</b>: Replaces replace_this in its position in the - //! tree with with_this. The tree does not need to be rebalanced. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: This function will break container ordering invariants if - //! with_this is not equivalent to *replace_this according to the - //! ordering rules. This function is faster than erasing and inserting - //! the node, since no rebalancing or comparison is needed. - void replace_node(iterator replace_this, reference with_this) - { - node_algorithms::replace_node( get_real_value_traits().to_node_ptr(*replace_this) - , this->priv_header_ptr() - , get_real_value_traits().to_node_ptr(with_this)); - if(safemode_or_autounlink) - node_algorithms::init(replace_this.pointed_node()); - } - - //! <b>Requires</b>: value must be an lvalue and shall be in a set of - //! appropriate type. Otherwise the behavior is undefined. - //! - //! <b>Effects</b>: Returns: a valid iterator i belonging to the set - //! that points to the value - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: This static function is available only if the <i>value traits</i> - //! is stateless. - static iterator s_iterator_to(reference value) - { - BOOST_STATIC_ASSERT((!stateful_value_traits)); - return iterator (value_traits::to_node_ptr(value), 0); - } - - //! <b>Requires</b>: value must be an lvalue and shall be in a set of - //! appropriate type. Otherwise the behavior is undefined. - //! - //! <b>Effects</b>: Returns: a valid const_iterator i belonging to the - //! set that points to the value - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: This static function is available only if the <i>value traits</i> - //! is stateless. - static const_iterator s_iterator_to(const_reference value) - { - BOOST_STATIC_ASSERT((!stateful_value_traits)); - return const_iterator (value_traits::to_node_ptr(const_cast<reference> (value)), 0); - } - - //! <b>Requires</b>: value must be an lvalue and shall be in a set of - //! appropriate type. Otherwise the behavior is undefined. - //! - //! <b>Effects</b>: Returns: a valid iterator i belonging to the set - //! that points to the value - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - iterator iterator_to(reference value) - { return iterator (value_traits::to_node_ptr(value), this); } - - //! <b>Requires</b>: value must be an lvalue and shall be in a set of - //! appropriate type. Otherwise the behavior is undefined. - //! - //! <b>Effects</b>: Returns: a valid const_iterator i belonging to the - //! set that points to the value - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_iterator iterator_to(const_reference value) const - { return const_iterator (value_traits::to_node_ptr(const_cast<reference> (value)), this); } - - //! <b>Requires</b>: value shall not be in a tree. - //! - //! <b>Effects</b>: init_node puts the hook of a value in a well-known default - //! state. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant time. - //! - //! <b>Note</b>: This function puts the hook in the well-known default state - //! used by auto_unlink and safe hooks. - static void init_node(reference value) - { node_algorithms::init(value_traits::to_node_ptr(value)); } - - //! <b>Effects</b>: Rebalances the tree. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Linear. - void rebalance() - { node_algorithms::rebalance(this->priv_header_ptr()); } - - //! <b>Requires</b>: old_root is a node of a tree. - //! - //! <b>Effects</b>: Rebalances the subtree rooted at old_root. - //! - //! <b>Returns</b>: The new root of the subtree. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Linear to the elements in the subtree. - iterator rebalance_subtree(iterator root) - { return iterator(node_algorithms::rebalance_subtree(root.pointed_node()), this); } - - //! <b>Returns</b>: The balance factor (alpha) used in this tree - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - float balance_factor() const - { return this->priv_alpha(); } - - //! <b>Requires</b>: new_alpha must be a value between 0.5 and 1.0 - //! - //! <b>Effects</b>: Establishes a new balance factor (alpha) and rebalances - //! the tree if the new balance factor is stricter (less) than the old factor. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Linear to the elements in the subtree. - void balance_factor(float new_alpha) - { - BOOST_INTRUSIVE_INVARIANT_ASSERT((new_alpha > 0.5f && new_alpha < 1.0f)); - if(new_alpha < 0.5f && new_alpha >= 1.0f) return; - - //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)); - float old_alpha = this->priv_alpha(); - this->priv_alpha(new_alpha); - - if(new_alpha < old_alpha){ - data_.max_tree_size_ = this->size(); - this->rebalance(); - } - } -/* - //! <b>Effects</b>: removes x from a tree of the appropriate type. It has no effect, - //! if x is not in such a tree. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant time. - //! - //! <b>Note</b>: This static function is only usable with the "safe mode" - //! hook and non-constant time size lists. Otherwise, the user must use - //! the non-static "erase(reference )" member. If the user calls - //! this function with a non "safe mode" or constant time size list - //! a compilation error will be issued. - template<class T> - static void remove_node(T& value) - { - //This function is only usable for safe mode hooks and non-constant - //time lists. - //BOOST_STATIC_ASSERT((!(safemode_or_autounlink && constant_time_size))); - BOOST_STATIC_ASSERT((!constant_time_size)); - BOOST_STATIC_ASSERT((boost::is_convertible<T, value_type>::value)); - node_ptr to_remove(value_traits::to_node_ptr(value)); - node_algorithms::unlink_and_rebalance(to_remove); - if(safemode_or_autounlink) - node_algorithms::init(to_remove); - } -*/ - - /// @cond - private: - template<class Disposer> - iterator private_erase(const_iterator b, const_iterator e, size_type &n, Disposer disposer) - { - for(n = 0; b != e; ++n) - this->erase_and_dispose(b++, disposer); - return b.unconst(); - } - - iterator private_erase(const_iterator b, const_iterator e, size_type &n) - { - for(n = 0; b != e; ++n) - this->erase(b++); - return b.unconst(); - } - /// @endcond - - private: - static sgtree_impl &priv_container_from_end_iterator(const const_iterator &end_iterator) - { - header_plus_alpha *r = detail::parent_from_member<header_plus_alpha, node> - ( boost::intrusive::detail::to_raw_pointer(end_iterator.pointed_node()), &header_plus_alpha::header_); - node_plus_pred_t *n = detail::parent_from_member - <node_plus_pred_t, header_plus_alpha>(r, &node_plus_pred_t::header_plus_alpha_); - data_t *d = detail::parent_from_member<data_t, node_plus_pred_t>(n, &data_t::node_plus_pred_); - sgtree_impl *scapegoat = detail::parent_from_member<sgtree_impl, data_t>(d, &sgtree_impl::data_); - return *scapegoat; - } - - static sgtree_impl &priv_container_from_iterator(const const_iterator &it) - { return priv_container_from_end_iterator(it.end_iterator_from_it()); } -}; - -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -inline bool operator< -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -(const sgtree_impl<T, Options...> &x, const sgtree_impl<T, Options...> &y) -#else -(const sgtree_impl<Config> &x, const sgtree_impl<Config> &y) -#endif -{ return std::lexicographical_compare(x.begin(), x.end(), y.begin(), y.end()); } - -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -bool operator== -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -(const sgtree_impl<T, Options...> &x, const sgtree_impl<T, Options...> &y) -#else -(const sgtree_impl<Config> &x, const sgtree_impl<Config> &y) -#endif -{ - typedef sgtree_impl<Config> tree_type; - typedef typename tree_type::const_iterator const_iterator; - - if(tree_type::constant_time_size && x.size() != y.size()){ - return false; - } - const_iterator end1 = x.end(); - const_iterator i1 = x.begin(); - const_iterator i2 = y.begin(); - if(tree_type::constant_time_size){ - while (i1 != end1 && *i1 == *i2) { - ++i1; - ++i2; - } - return i1 == end1; - } - else{ - const_iterator end2 = y.end(); - while (i1 != end1 && i2 != end2 && *i1 == *i2) { - ++i1; - ++i2; - } - return i1 == end1 && i2 == end2; - } -} - -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -inline bool operator!= -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -(const sgtree_impl<T, Options...> &x, const sgtree_impl<T, Options...> &y) -#else -(const sgtree_impl<Config> &x, const sgtree_impl<Config> &y) -#endif -{ return !(x == y); } - -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -inline bool operator> -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -(const sgtree_impl<T, Options...> &x, const sgtree_impl<T, Options...> &y) -#else -(const sgtree_impl<Config> &x, const sgtree_impl<Config> &y) -#endif -{ return y < x; } - -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -inline bool operator<= -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -(const sgtree_impl<T, Options...> &x, const sgtree_impl<T, Options...> &y) -#else -(const sgtree_impl<Config> &x, const sgtree_impl<Config> &y) -#endif -{ return !(y < x); } - -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -inline bool operator>= -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -(const sgtree_impl<T, Options...> &x, const sgtree_impl<T, Options...> &y) -#else -(const sgtree_impl<Config> &x, const sgtree_impl<Config> &y) -#endif -{ return !(x < y); } - -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -inline void swap -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -(sgtree_impl<T, Options...> &x, sgtree_impl<T, Options...> &y) -#else -(sgtree_impl<Config> &x, sgtree_impl<Config> &y) -#endif -{ x.swap(y); } - -/// @cond -#if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template<class T, class O1 = none, class O2 = none - , class O3 = none, class O4 = none> -#else -template<class T, class ...Options> -#endif -struct make_sgtree_opt -{ - typedef typename pack_options - < sg_set_defaults<T>, - #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) - O1, O2, O3, O4 - #else - Options... - #endif - >::type packed_options; - typedef typename detail::get_value_traits - <T, typename packed_options::value_traits>::type value_traits; - - typedef sg_setopt - < value_traits - , typename packed_options::compare - , typename packed_options::size_type - , packed_options::floating_point - > type; -}; -/// @endcond - -//! Helper metafunction to define a \c sgtree that yields to the same type when the -//! same options (either explicitly or implicitly) are used. -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) || defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template<class T, class ...Options> -#else -template<class T, class O1 = none, class O2 = none - , class O3 = none, class O4 = none> -#endif -struct make_sgtree -{ - /// @cond - typedef sgtree_impl - < typename make_sgtree_opt<T, - #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) - O1, O2, O3, O4 - #else - Options... - #endif - >::type - > implementation_defined; - /// @endcond - typedef implementation_defined type; -}; - -#ifndef BOOST_INTRUSIVE_DOXYGEN_INVOKED -#if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template<class T, class O1, class O2, class O3, class O4> -#else -template<class T, class ...Options> -#endif -class sgtree - : public make_sgtree<T, - #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) - O1, O2, O3, O4 - #else - Options... - #endif - >::type -{ - typedef typename make_sgtree - <T, - #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) - O1, O2, O3, O4 - #else - Options... - #endif - >::type Base; - - BOOST_MOVABLE_BUT_NOT_COPYABLE(sgtree) - - public: - typedef typename Base::value_compare value_compare; - typedef typename Base::value_traits value_traits; - typedef typename Base::real_value_traits real_value_traits; - typedef typename Base::iterator iterator; - typedef typename Base::const_iterator const_iterator; - - //Assert if passed value traits are compatible with the type - BOOST_STATIC_ASSERT((detail::is_same<typename real_value_traits::value_type, T>::value)); - - sgtree( const value_compare &cmp = value_compare() - , const value_traits &v_traits = value_traits()) - : Base(cmp, v_traits) - {} - - template<class Iterator> - sgtree( bool unique, Iterator b, Iterator e - , const value_compare &cmp = value_compare() - , const value_traits &v_traits = value_traits()) - : Base(unique, b, e, cmp, v_traits) - {} - - sgtree(BOOST_RV_REF(sgtree) x) - : Base(::boost::move(static_cast<Base&>(x))) - {} - - sgtree& operator=(BOOST_RV_REF(sgtree) x) - { this->Base::operator=(::boost::move(static_cast<Base&>(x))); return *this; } - - static sgtree &container_from_end_iterator(iterator end_iterator) - { return static_cast<sgtree &>(Base::container_from_end_iterator(end_iterator)); } - - static const sgtree &container_from_end_iterator(const_iterator end_iterator) - { return static_cast<const sgtree &>(Base::container_from_end_iterator(end_iterator)); } -}; - -#endif - - -} //namespace intrusive -} //namespace boost - -#include <boost/intrusive/detail/config_end.hpp> - -#endif //BOOST_INTRUSIVE_SGTREE_HPP diff --git a/src/third_party/boost/boost/intrusive/sgtree_algorithms.hpp b/src/third_party/boost/boost/intrusive/sgtree_algorithms.hpp deleted file mode 100644 index f3c433225e7..00000000000 --- a/src/third_party/boost/boost/intrusive/sgtree_algorithms.hpp +++ /dev/null @@ -1,782 +0,0 @@ -///////////////////////////////////////////////////////////////////////////// -// -// (C) Copyright Ion Gaztanaga 2007. -// -// Distributed under the Boost Software License, Version 1.0. -// (See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) -// -// See http://www.boost.org/libs/intrusive for documentation. -// -///////////////////////////////////////////////////////////////////////////// -// -// Scapegoat tree algorithms are taken from the paper titled: -// "Scapegoat Trees" by Igal Galperin Ronald L. Rivest. -// -///////////////////////////////////////////////////////////////////////////// -#ifndef BOOST_INTRUSIVE_SGTREE_ALGORITHMS_HPP -#define BOOST_INTRUSIVE_SGTREE_ALGORITHMS_HPP - -#include <boost/intrusive/detail/config_begin.hpp> - -#include <cstddef> -#include <boost/intrusive/intrusive_fwd.hpp> -#include <boost/intrusive/detail/assert.hpp> -#include <boost/intrusive/detail/utilities.hpp> -#include <boost/intrusive/detail/tree_algorithms.hpp> -#include <boost/intrusive/pointer_traits.hpp> - - -namespace boost { -namespace intrusive { - -//! sgtree_algorithms is configured with a NodeTraits class, which encapsulates the -//! information about the node to be manipulated. NodeTraits must support the -//! following interface: -//! -//! <b>Typedefs</b>: -//! -//! <tt>node</tt>: The type of the node that forms the circular list -//! -//! <tt>node_ptr</tt>: A pointer to a node -//! -//! <tt>const_node_ptr</tt>: A pointer to a const node -//! -//! <b>Static functions</b>: -//! -//! <tt>static node_ptr get_parent(const_node_ptr n);</tt> -//! -//! <tt>static void set_parent(node_ptr n, node_ptr parent);</tt> -//! -//! <tt>static node_ptr get_left(const_node_ptr n);</tt> -//! -//! <tt>static void set_left(node_ptr n, node_ptr left);</tt> -//! -//! <tt>static node_ptr get_right(const_node_ptr n);</tt> -//! -//! <tt>static void set_right(node_ptr n, node_ptr right);</tt> -template<class NodeTraits> -class sgtree_algorithms -{ - public: - typedef typename NodeTraits::node node; - typedef NodeTraits node_traits; - typedef typename NodeTraits::node_ptr node_ptr; - typedef typename NodeTraits::const_node_ptr const_node_ptr; - - /// @cond - private: - - typedef detail::tree_algorithms<NodeTraits> tree_algorithms; - - static node_ptr uncast(const const_node_ptr & ptr) - { return pointer_traits<node_ptr>::const_cast_from(ptr); } - /// @endcond - - public: - static node_ptr begin_node(const const_node_ptr & header) - { return tree_algorithms::begin_node(header); } - - static node_ptr end_node(const const_node_ptr & header) - { return tree_algorithms::end_node(header); } - - //! This type is the information that will be - //! filled by insert_unique_check - struct insert_commit_data - : tree_algorithms::insert_commit_data - { - std::size_t depth; - }; - - //! <b>Requires</b>: header1 and header2 must be the header nodes - //! of two trees. - //! - //! <b>Effects</b>: Swaps two trees. After the function header1 will contain - //! links to the second tree and header2 will have links to the first tree. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - static void swap_tree(const node_ptr & header1, const node_ptr & header2) - { return tree_algorithms::swap_tree(header1, header2); } - - //! <b>Requires</b>: node1 and node2 can't be header nodes - //! of two trees. - //! - //! <b>Effects</b>: Swaps two nodes. After the function node1 will be inserted - //! in the position node2 before the function. node2 will be inserted in the - //! position node1 had before the function. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: This function will break container ordering invariants if - //! node1 and node2 are not equivalent according to the ordering rules. - //! - //!Experimental function - static void swap_nodes(const node_ptr & node1, const node_ptr & node2) - { - if(node1 == node2) - return; - - node_ptr header1(tree_algorithms::get_header(node1)), header2(tree_algorithms::get_header(node2)); - swap_nodes(node1, header1, node2, header2); - } - - //! <b>Requires</b>: node1 and node2 can't be header nodes - //! of two trees with header header1 and header2. - //! - //! <b>Effects</b>: Swaps two nodes. After the function node1 will be inserted - //! in the position node2 before the function. node2 will be inserted in the - //! position node1 had before the function. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: This function will break container ordering invariants if - //! node1 and node2 are not equivalent according to the ordering rules. - //! - //!Experimental function - static void swap_nodes(const node_ptr & node1, const node_ptr & header1, const node_ptr & node2, const node_ptr & header2) - { tree_algorithms::swap_nodes(node1, header1, node2, header2); } - - //! <b>Requires</b>: node_to_be_replaced must be inserted in a tree - //! and new_node must not be inserted in a tree. - //! - //! <b>Effects</b>: Replaces node_to_be_replaced in its position in the - //! tree with new_node. The tree does not need to be rebalanced - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: This function will break container ordering invariants if - //! 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 - static void replace_node(const node_ptr & node_to_be_replaced, const node_ptr & new_node) - { - if(node_to_be_replaced == new_node) - return; - replace_node(node_to_be_replaced, tree_algorithms::get_header(node_to_be_replaced), new_node); - } - - //! <b>Requires</b>: node_to_be_replaced must be inserted in a tree - //! with header "header" and new_node must not be inserted in a tree. - //! - //! <b>Effects</b>: Replaces node_to_be_replaced in its position in the - //! tree with new_node. The tree does not need to be rebalanced - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: This function will break container ordering invariants if - //! 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 or comparison is needed. - //! - //!Experimental function - static void replace_node(const node_ptr & node_to_be_replaced, const node_ptr & header, const node_ptr & new_node) - { tree_algorithms::replace_node(node_to_be_replaced, header, new_node); } - - //! <b>Requires</b>: node is a tree node but not the header. - //! - //! <b>Effects</b>: Unlinks the node and rebalances the tree. - //! - //! <b>Complexity</b>: Average complexity is constant time. - //! - //! <b>Throws</b>: Nothing. - static void unlink(const node_ptr & node) - { - node_ptr x = NodeTraits::get_parent(node); - if(x){ - while(!is_header(x)) - x = NodeTraits::get_parent(x); - tree_algorithms::erase(x, node); - } - } - - //! <b>Requires</b>: header is the header of a tree. - //! - //! <b>Effects</b>: Unlinks the leftmost node from the tree, and - //! updates the header link to the new leftmost node. - //! - //! <b>Complexity</b>: Average complexity is constant time. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Notes</b>: This function breaks the tree and the tree can - //! only be used for more unlink_leftmost_without_rebalance calls. - //! This function is normally used to achieve a step by step - //! controlled destruction of the tree. - static node_ptr unlink_leftmost_without_rebalance(const node_ptr & header) - { return tree_algorithms::unlink_leftmost_without_rebalance(header); } - - //! <b>Requires</b>: node is a node of the tree or an node initialized - //! by init(...). - //! - //! <b>Effects</b>: Returns true if the node is initialized by init(). - //! - //! <b>Complexity</b>: Constant time. - //! - //! <b>Throws</b>: Nothing. - static bool unique(const const_node_ptr & node) - { return tree_algorithms::unique(node); } - - //! <b>Requires</b>: node is a node of the tree but it's not the header. - //! - //! <b>Effects</b>: Returns the number of nodes of the subtree. - //! - //! <b>Complexity</b>: Linear time. - //! - //! <b>Throws</b>: Nothing. - static std::size_t count(const const_node_ptr & node) - { return tree_algorithms::count(node); } - - //! <b>Requires</b>: header is the header node of the tree. - //! - //! <b>Effects</b>: Returns the number of nodes above the header. - //! - //! <b>Complexity</b>: Linear time. - //! - //! <b>Throws</b>: Nothing. - static std::size_t size(const const_node_ptr & header) - { return tree_algorithms::size(header); } - - //! <b>Requires</b>: p is a node from the tree except the header. - //! - //! <b>Effects</b>: Returns the next node of the tree. - //! - //! <b>Complexity</b>: Average constant time. - //! - //! <b>Throws</b>: Nothing. - static node_ptr next_node(const node_ptr & p) - { return tree_algorithms::next_node(p); } - - //! <b>Requires</b>: p is a node from the tree except the leftmost node. - //! - //! <b>Effects</b>: Returns the previous node of the tree. - //! - //! <b>Complexity</b>: Average constant time. - //! - //! <b>Throws</b>: Nothing. - static node_ptr prev_node(const node_ptr & p) - { return tree_algorithms::prev_node(p); } - - //! <b>Requires</b>: node must not be part of any tree. - //! - //! <b>Effects</b>: After the function unique(node) == true. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Nodes</b>: If node is inserted in a tree, this function corrupts the tree. - static void init(const node_ptr & node) - { tree_algorithms::init(node); } - - //! <b>Requires</b>: node must not be part of any tree. - //! - //! <b>Effects</b>: Initializes the header to represent an empty tree. - //! unique(header) == true. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Nodes</b>: If node is inserted in a tree, this function corrupts the tree. - static void init_header(const node_ptr & header) - { tree_algorithms::init_header(header); } - - //! <b>Requires</b>: header must be the header of a tree, z a node - //! of that tree and z != header. - //! - //! <b>Effects</b>: Erases node "z" from the tree with header "header". - //! - //! <b>Complexity</b>: Amortized constant time. - //! - //! <b>Throws</b>: Nothing. - template<class AlphaByMaxSize> - static node_ptr erase(const node_ptr & header, const node_ptr & z, std::size_t tree_size, std::size_t &max_tree_size, AlphaByMaxSize alpha_by_maxsize) - { - //typename tree_algorithms::data_for_rebalance info; - tree_algorithms::erase(header, z); - --tree_size; - if (tree_size > 0 && - tree_size < alpha_by_maxsize(max_tree_size)){ - tree_algorithms::rebalance(header); - max_tree_size = tree_size; - } - return z; - } - - //! <b>Requires</b>: "cloner" must be a function - //! object taking a node_ptr and returning a new cloned node of it. "disposer" must - //! take a node_ptr and shouldn't throw. - //! - //! <b>Effects</b>: First empties target tree calling - //! <tt>void disposer::operator()(const node_ptr &)</tt> for every node of the tree - //! except the header. - //! - //! Then, duplicates the entire tree pointed by "source_header" cloning each - //! source node with <tt>node_ptr Cloner::operator()(const node_ptr &)</tt> to obtain - //! the nodes of the target tree. If "cloner" throws, the cloned target nodes - //! are disposed using <tt>void disposer(const node_ptr &)</tt>. - //! - //! <b>Complexity</b>: Linear to the number of element of the source tree plus the. - //! number of elements of tree target tree when calling this function. - //! - //! <b>Throws</b>: If cloner functor throws. If this happens target nodes are disposed. - template <class Cloner, class Disposer> - static void clone - (const const_node_ptr & source_header, const node_ptr & target_header, Cloner cloner, Disposer disposer) - { - tree_algorithms::clone(source_header, target_header, cloner, disposer); - } - - //! <b>Requires</b>: "disposer" must be an object function - //! taking a node_ptr parameter and shouldn't throw. - //! - //! <b>Effects</b>: Empties the target tree calling - //! <tt>void disposer::operator()(const node_ptr &)</tt> for every node of the tree - //! except the header. - //! - //! <b>Complexity</b>: Linear to the number of element of the source tree plus the. - //! number of elements of tree target tree when calling this function. - //! - //! <b>Throws</b>: If cloner functor throws. If this happens target nodes are disposed. - template<class Disposer> - static void clear_and_dispose(const node_ptr & header, Disposer disposer) - { tree_algorithms::clear_and_dispose(header, disposer); } - - //! <b>Requires</b>: "header" must be the header node of a tree. - //! KeyNodePtrCompare is a function object that induces a strict weak - //! ordering compatible with the strict weak ordering used to create the - //! the tree. KeyNodePtrCompare can compare KeyType with tree's node_ptrs. - //! - //! <b>Effects</b>: Returns an node_ptr to the first element that is - //! not less than "key" according to "comp" or "header" if that element does - //! not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If "comp" throws. - template<class KeyType, class KeyNodePtrCompare> - static node_ptr lower_bound - (const const_node_ptr & header, const KeyType &key, KeyNodePtrCompare comp) - { return tree_algorithms::lower_bound(header, key, comp); } - - //! <b>Requires</b>: "header" must be the header node of a tree. - //! KeyNodePtrCompare is a function object that induces a strict weak - //! ordering compatible with the strict weak ordering used to create the - //! the tree. KeyNodePtrCompare can compare KeyType with tree's node_ptrs. - //! - //! <b>Effects</b>: Returns an node_ptr to the first element that is greater - //! than "key" according to "comp" or "header" if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If "comp" throws. - template<class KeyType, class KeyNodePtrCompare> - static node_ptr upper_bound - (const const_node_ptr & header, const KeyType &key, KeyNodePtrCompare comp) - { return tree_algorithms::upper_bound(header, key, comp); } - - //! <b>Requires</b>: "header" must be the header node of a tree. - //! KeyNodePtrCompare is a function object that induces a strict weak - //! ordering compatible with the strict weak ordering used to create the - //! the tree. KeyNodePtrCompare can compare KeyType with tree's node_ptrs. - //! - //! <b>Effects</b>: Returns an node_ptr to the element that is equivalent to - //! "key" according to "comp" or "header" if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If "comp" throws. - template<class KeyType, class KeyNodePtrCompare> - static node_ptr find - (const const_node_ptr & header, const KeyType &key, KeyNodePtrCompare comp) - { return tree_algorithms::find(header, key, comp); } - - //! <b>Requires</b>: "header" must be the header node of a tree. - //! KeyNodePtrCompare is a function object that induces a strict weak - //! ordering compatible with the strict weak ordering used to create the - //! the tree. KeyNodePtrCompare can compare KeyType with tree's node_ptrs. - //! - //! <b>Effects</b>: Returns an a pair of node_ptr delimiting a range containing - //! all elements that are equivalent to "key" according to "comp" or an - //! empty range that indicates the position where those elements would be - //! if they there are no equivalent elements. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If "comp" throws. - template<class KeyType, class KeyNodePtrCompare> - static std::pair<node_ptr, node_ptr> equal_range - (const const_node_ptr & header, const KeyType &key, KeyNodePtrCompare comp) - { return tree_algorithms::equal_range(header, key, comp); } - - //! <b>Requires</b>: "h" must be the header node of a tree. - //! NodePtrCompare is a function object that induces a strict weak - //! ordering compatible with the strict weak ordering used to create the - //! the tree. NodePtrCompare compares two node_ptrs. - //! - //! <b>Effects</b>: Inserts new_node into the tree before the upper bound - //! according to "comp". - //! - //! <b>Complexity</b>: Average complexity for insert element is at - //! most logarithmic. - //! - //! <b>Throws</b>: If "comp" throws. - template<class NodePtrCompare, class H_Alpha> - static node_ptr insert_equal_upper_bound - (const node_ptr & h, const node_ptr & new_node, NodePtrCompare comp - ,std::size_t tree_size, H_Alpha h_alpha, std::size_t &max_tree_size) - { - std::size_t depth; - tree_algorithms::insert_equal_upper_bound(h, new_node, comp, &depth); - rebalance_after_insertion(new_node, depth, tree_size+1, h_alpha, max_tree_size); - return new_node; - } - - //! <b>Requires</b>: "h" must be the header node of a tree. - //! NodePtrCompare is a function object that induces a strict weak - //! ordering compatible with the strict weak ordering used to create the - //! the tree. NodePtrCompare compares two node_ptrs. - //! - //! <b>Effects</b>: Inserts new_node into the tree before the lower bound - //! according to "comp". - //! - //! <b>Complexity</b>: Average complexity for insert element is at - //! most logarithmic. - //! - //! <b>Throws</b>: If "comp" throws. - template<class NodePtrCompare, class H_Alpha> - static node_ptr insert_equal_lower_bound - (const node_ptr & h, const node_ptr & new_node, NodePtrCompare comp - ,std::size_t tree_size, H_Alpha h_alpha, std::size_t &max_tree_size) - { - std::size_t depth; - tree_algorithms::insert_equal_lower_bound(h, new_node, comp, &depth); - rebalance_after_insertion(new_node, depth, tree_size+1, h_alpha, max_tree_size); - return new_node; - } - - //! <b>Requires</b>: "header" must be the header node of a tree. - //! NodePtrCompare is a function object that induces a strict weak - //! ordering compatible with the strict weak ordering used to create the - //! the tree. NodePtrCompare compares two node_ptrs. "hint" is node from - //! the "header"'s tree. - //! - //! <b>Effects</b>: Inserts new_node into the tree, using "hint" as a hint to - //! where it will be inserted. If "hint" is the upper_bound - //! the insertion takes constant time (two comparisons in the worst case). - //! - //! <b>Complexity</b>: Logarithmic in general, but it is amortized - //! constant time if new_node is inserted immediately before "hint". - //! - //! <b>Throws</b>: If "comp" throws. - template<class NodePtrCompare, class H_Alpha> - static node_ptr insert_equal - (const node_ptr & header, const node_ptr & hint, const node_ptr & new_node, NodePtrCompare comp - ,std::size_t tree_size, H_Alpha h_alpha, std::size_t &max_tree_size) - { - std::size_t depth; - tree_algorithms::insert_equal(header, hint, new_node, comp, &depth); - rebalance_after_insertion(new_node, depth, tree_size+1, h_alpha, max_tree_size); - return new_node; - } - - //! <b>Requires</b>: "header" must be the header node of a tree. - //! KeyNodePtrCompare is a function object that induces a strict weak - //! ordering compatible with the strict weak ordering used to create the - //! the tree. NodePtrCompare compares KeyType with a node_ptr. - //! - //! <b>Effects</b>: Checks if there is an equivalent node to "key" in the - //! tree according to "comp" and obtains the needed information to realize - //! a constant-time node insertion if there is no equivalent node. - //! - //! <b>Returns</b>: If there is an equivalent value - //! returns a pair containing a node_ptr to the already present node - //! and false. If there is not equivalent key can be inserted returns true - //! in the returned pair's boolean and fills "commit_data" that is meant to - //! be used with the "insert_commit" function to achieve a constant-time - //! insertion function. - //! - //! <b>Complexity</b>: Average complexity is at most logarithmic. - //! - //! <b>Throws</b>: If "comp" throws. - //! - //! <b>Notes</b>: This function is used to improve performance when constructing - //! a node is expensive and the user does not want to have two equivalent nodes - //! in the tree: if there is an equivalent value - //! the constructed object must be discarded. Many times, the part of the - //! node that is used to impose the order is much cheaper to construct - //! than the node and this function offers the possibility to use that part - //! to check if the insertion will be successful. - //! - //! If the check is successful, the user can construct the node and use - //! "insert_commit" to insert the node in constant-time. This gives a total - //! logarithmic complexity to the insertion: check(O(log(N)) + commit(O(1)). - //! - //! "commit_data" remains valid for a subsequent "insert_unique_commit" only - //! if no more objects are inserted or erased from the set. - template<class KeyType, class KeyNodePtrCompare> - static std::pair<node_ptr, bool> insert_unique_check - (const const_node_ptr & header, const KeyType &key - ,KeyNodePtrCompare comp, insert_commit_data &commit_data) - { - std::size_t depth; - std::pair<node_ptr, bool> ret = - tree_algorithms::insert_unique_check(header, key, comp, commit_data, &depth); - commit_data.depth = depth; - return ret; - } - - - //! <b>Requires</b>: "header" must be the header node of a tree. - //! "pos" must be a valid iterator or header (end) node. - //! "pos" must be an iterator pointing to the successor to "new_node" - //! once inserted according to the order of already inserted nodes. This function does not - //! check "pos" and this precondition must be guaranteed by the caller. - //! - //! <b>Effects</b>: Inserts new_node into the tree before "pos". - //! - //! <b>Complexity</b>: Constant-time. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: If "pos" is not the successor of the newly inserted "new_node" - //! tree invariants might be broken. - template<class H_Alpha> - static node_ptr insert_before - (const node_ptr & header, const node_ptr & pos, const node_ptr & new_node - ,std::size_t tree_size, H_Alpha h_alpha, std::size_t &max_tree_size) - { - std::size_t depth; - tree_algorithms::insert_before(header, pos, new_node, &depth); - rebalance_after_insertion(new_node, depth, tree_size+1, h_alpha, max_tree_size); - return new_node; - } - - //! <b>Requires</b>: "header" must be the header node of a tree. - //! "new_node" must be, according to the used ordering no less than the - //! greatest inserted key. - //! - //! <b>Effects</b>: Inserts new_node into the tree before "pos". - //! - //! <b>Complexity</b>: Constant-time. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: If "new_node" is less than the greatest inserted key - //! tree invariants are broken. This function is slightly faster than - //! using "insert_before". - template<class H_Alpha> - static void push_back(const node_ptr & header, const node_ptr & new_node - ,std::size_t tree_size, H_Alpha h_alpha, std::size_t &max_tree_size) - { - std::size_t depth; - tree_algorithms::push_back(header, new_node, &depth); - rebalance_after_insertion(new_node, depth, tree_size+1, h_alpha, max_tree_size); - } - - //! <b>Requires</b>: "header" must be the header node of a tree. - //! "new_node" must be, according to the used ordering, no greater than the - //! lowest inserted key. - //! - //! <b>Effects</b>: Inserts new_node into the tree before "pos". - //! - //! <b>Complexity</b>: Constant-time. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: If "new_node" is greater than the lowest inserted key - //! tree invariants are broken. This function is slightly faster than - //! using "insert_before". - template<class H_Alpha> - static void push_front(const node_ptr & header, const node_ptr & new_node - ,std::size_t tree_size, H_Alpha h_alpha, std::size_t &max_tree_size) - { - std::size_t depth; - tree_algorithms::push_front(header, new_node, &depth); - rebalance_after_insertion(new_node, depth, tree_size+1, h_alpha, max_tree_size); - } - - //! <b>Requires</b>: "header" must be the header node of a tree. - //! KeyNodePtrCompare is a function object that induces a strict weak - //! ordering compatible with the strict weak ordering used to create the - //! the tree. NodePtrCompare compares KeyType with a node_ptr. - //! "hint" is node from the "header"'s tree. - //! - //! <b>Effects</b>: Checks if there is an equivalent node to "key" in the - //! tree according to "comp" using "hint" as a hint to where it should be - //! inserted and obtains the needed information to realize - //! a constant-time node insertion if there is no equivalent node. - //! If "hint" is the upper_bound the function has constant time - //! complexity (two comparisons in the worst case). - //! - //! <b>Returns</b>: If there is an equivalent value - //! returns a pair containing a node_ptr to the already present node - //! and false. If there is not equivalent key can be inserted returns true - //! in the returned pair's boolean and fills "commit_data" that is meant to - //! be used with the "insert_commit" function to achieve a constant-time - //! insertion function. - //! - //! <b>Complexity</b>: Average complexity is at most logarithmic, but it is - //! amortized constant time if new_node should be inserted immediately before "hint". - //! - //! <b>Throws</b>: If "comp" throws. - //! - //! <b>Notes</b>: This function is used to improve performance when constructing - //! a node is expensive and the user does not want to have two equivalent nodes - //! in the tree: if there is an equivalent value - //! the constructed object must be discarded. Many times, the part of the - //! node that is used to impose the order is much cheaper to construct - //! than the node and this function offers the possibility to use that part - //! to check if the insertion will be successful. - //! - //! If the check is successful, the user can construct the node and use - //! "insert_commit" to insert the node in constant-time. This gives a total - //! logarithmic complexity to the insertion: check(O(log(N)) + commit(O(1)). - //! - //! "commit_data" remains valid for a subsequent "insert_unique_commit" only - //! if no more objects are inserted or erased from the set. - template<class KeyType, class KeyNodePtrCompare> - static std::pair<node_ptr, bool> insert_unique_check - (const const_node_ptr & header, const node_ptr &hint, const KeyType &key - ,KeyNodePtrCompare comp, insert_commit_data &commit_data) - { - std::size_t depth; - std::pair<node_ptr, bool> ret = - tree_algorithms::insert_unique_check - (header, hint, key, comp, commit_data, &depth); - commit_data.depth = depth; - return ret; - } - - //! <b>Requires</b>: "header" must be the header node of a tree. - //! "commit_data" must have been obtained from a previous call to - //! "insert_unique_check". No objects should have been inserted or erased - //! from the set between the "insert_unique_check" that filled "commit_data" - //! and the call to "insert_commit". - //! - //! - //! <b>Effects</b>: Inserts new_node in the set using the information obtained - //! from the "commit_data" that a previous "insert_check" filled. - //! - //! <b>Complexity</b>: Constant time. - //! - //! <b>Throws</b>: Nothing. - //! - //! <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. - template<class H_Alpha> - static void insert_unique_commit - (const node_ptr & header, const 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) - { - tree_algorithms::insert_unique_commit(header, new_value, commit_data); - rebalance_after_insertion(new_value, commit_data.depth, tree_size+1, h_alpha, max_tree_size); - } - - //! <b>Requires</b>: header must be the header of a tree. - //! - //! <b>Effects</b>: Rebalances the tree. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Linear. - static void rebalance(const node_ptr & header) - { tree_algorithms::rebalance(header); } - - //! <b>Requires</b>: old_root is a node of a tree. - //! - //! <b>Effects</b>: Rebalances the subtree rooted at old_root. - //! - //! <b>Returns</b>: The new root of the subtree. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Linear. - static node_ptr rebalance_subtree(const node_ptr & old_root) - { return tree_algorithms::rebalance_subtree(old_root); } - - //! <b>Requires</b>: "n" must be a node inserted in a tree. - //! - //! <b>Effects</b>: Returns a pointer to the header node of the tree. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: Nothing. - static node_ptr get_header(const node_ptr & n) - { return tree_algorithms::get_header(n); } - - /// @cond - private: - - //! <b>Requires</b>: p is a node of a tree. - //! - //! <b>Effects</b>: Returns true if p is the header of the tree. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - static bool is_header(const const_node_ptr & p) - { return tree_algorithms::is_header(p); } - - template<class H_Alpha> - static void rebalance_after_insertion - (const node_ptr &x, std::size_t depth - , std::size_t tree_size, H_Alpha h_alpha, std::size_t &max_tree_size) - { - if(tree_size > max_tree_size) - max_tree_size = tree_size; - - if(tree_size != 1 && depth > h_alpha(tree_size)){ - //Find the first non height-balanced node - //as described in the section 4.2 of the paper. - //This method is the alternative method described - //in the paper. Authors claim that this method - //may tend to yield more balanced trees on the average - //than the weight balanced method. - node_ptr s = x; - std::size_t size = 1; - - for(std::size_t i = 1; true; ++i){ - bool rebalance = false; - if(i == depth){ - BOOST_INTRUSIVE_INVARIANT_ASSERT(tree_size == count(s)); - rebalance = true; - } - else if(i > h_alpha(size)){ - node_ptr s_parent = NodeTraits::get_parent(s); - node_ptr s_parent_left = NodeTraits::get_left(s_parent); - size += 1 + tree_algorithms::count - ( s_parent_left == s ? NodeTraits::get_right(s_parent) : s_parent_left ); - s = s_parent; - rebalance = true; - } - if(rebalance){ - rebalance_subtree(s); - break; - } - } - } - } - - /// @endcond -}; - -} //namespace intrusive -} //namespace boost - -#include <boost/intrusive/detail/config_end.hpp> - -#endif //BOOST_INTRUSIVE_SGTREE_ALGORITHMS_HPP diff --git a/src/third_party/boost/boost/intrusive/slist.hpp b/src/third_party/boost/boost/intrusive/slist.hpp deleted file mode 100644 index 505343869ac..00000000000 --- a/src/third_party/boost/boost/intrusive/slist.hpp +++ /dev/null @@ -1,2134 +0,0 @@ -///////////////////////////////////////////////////////////////////////////// -// -// (C) Copyright Olaf Krzikalla 2004-2006. -// (C) Copyright Ion Gaztanaga 2006-2009 -// -// Distributed under the Boost Software License, Version 1.0. -// (See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) -// -// See http://www.boost.org/libs/intrusive for documentation. -// -///////////////////////////////////////////////////////////////////////////// - -#ifndef BOOST_INTRUSIVE_SLIST_HPP -#define BOOST_INTRUSIVE_SLIST_HPP - -#include <boost/intrusive/detail/config_begin.hpp> -#include <boost/static_assert.hpp> -#include <boost/intrusive/detail/assert.hpp> -#include <boost/intrusive/intrusive_fwd.hpp> -#include <boost/intrusive/slist_hook.hpp> -#include <boost/intrusive/circular_slist_algorithms.hpp> -#include <boost/intrusive/linear_slist_algorithms.hpp> -#include <boost/intrusive/pointer_traits.hpp> -#include <boost/intrusive/detail/clear_on_destructor_base.hpp> -#include <boost/intrusive/link_mode.hpp> -#include <boost/intrusive/options.hpp> -#include <boost/intrusive/detail/utilities.hpp> -#include <iterator> -#include <functional> -#include <algorithm> -#include <cstddef> //std::size_t -#include <utility> //std::pair -#include <boost/move/move.hpp> - -namespace boost { -namespace intrusive { - -/// @cond - -template <class ValueTraits, class SizeType, bool ConstantTimeSize, bool Linear, bool CacheLast> -struct slistopt -{ - typedef ValueTraits value_traits; - typedef SizeType size_type; - static const bool constant_time_size = ConstantTimeSize; - static const bool linear = Linear; - static const bool cache_last = CacheLast; -}; - -template<class Node, class NodePtr, bool> -struct root_plus_last -{ - Node root_; - NodePtr last_; -}; - -template<class Node, class NodePtr> -struct root_plus_last<Node, NodePtr, false> -{ - Node root_; -}; - -template <class T> -struct slist_defaults - : pack_options - < none - , base_hook<detail::default_slist_hook> - , constant_time_size<true> - , linear<false> - , size_type<std::size_t> - , cache_last<false> - >::type -{}; - -/// @endcond - -//! The class template slist is an intrusive container, that encapsulates -//! a singly-linked list. You can use such a list to squeeze the last bit -//! of performance from your application. Unfortunately, the little gains -//! come with some huge drawbacks. A lot of member functions can't be -//! implemented as efficiently as for standard containers. To overcome -//! this limitation some other member functions with rather unusual semantics -//! have to be introduced. -//! -//! The template parameter \c T is the type to be managed by the container. -//! The user can specify additional options and if no options are provided -//! default options are used. -//! -//! The container supports the following options: -//! \c base_hook<>/member_hook<>/value_traits<>, -//! \c constant_time_size<>, \c size_type<>, -//! \c linear<> and \c cache_last<>. -//! -//! The iterators of slist are forward iterators. slist provides a static -//! function called "previous" to compute the previous iterator of a given iterator. -//! This function has linear complexity. To improve the usability esp. with -//! the '*_after' functions, ++end() == begin() and previous(begin()) == end() -//! are defined. An new special function "before_begin()" is defined, which returns -//! an iterator that points one less the beginning of the list: ++before_begin() == begin() -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -class slist_impl - : private detail::clear_on_destructor_base<slist_impl<Config> > -{ - template<class C> friend class detail::clear_on_destructor_base; - //Public typedefs - public: - typedef typename Config::value_traits value_traits; - /// @cond - static const bool external_value_traits = - detail::external_value_traits_is_true<value_traits>::value; - typedef typename detail::eval_if_c - < external_value_traits - , detail::eval_value_traits<value_traits> - , detail::identity<value_traits> - >::type real_value_traits; - /// @endcond - typedef typename real_value_traits::pointer pointer; - typedef typename real_value_traits::const_pointer const_pointer; - typedef typename pointer_traits<pointer>::element_type value_type; - typedef typename pointer_traits<pointer>::reference reference; - typedef typename pointer_traits<const_pointer>::reference const_reference; - typedef typename pointer_traits<pointer>::difference_type difference_type; - typedef typename Config::size_type size_type; - typedef slist_iterator<slist_impl, false> iterator; - typedef slist_iterator<slist_impl, true> const_iterator; - typedef typename real_value_traits::node_traits node_traits; - typedef typename node_traits::node node; - typedef typename node_traits::node_ptr node_ptr; - typedef typename node_traits::const_node_ptr const_node_ptr; - - typedef typename detail::if_c - < Config::linear - , linear_slist_algorithms<node_traits> - , circular_slist_algorithms<node_traits> - >::type node_algorithms; - - static const bool constant_time_size = Config::constant_time_size; - static const bool stateful_value_traits = detail::is_stateful_value_traits<real_value_traits>::value; - static const bool linear = Config::linear; - static const bool cache_last = Config::cache_last; - - /// @cond - private: - typedef detail::size_holder<constant_time_size, size_type> size_traits; - - //noncopyable - BOOST_MOVABLE_BUT_NOT_COPYABLE(slist_impl) - - enum { safemode_or_autounlink = - (int)real_value_traits::link_mode == (int)auto_unlink || - (int)real_value_traits::link_mode == (int)safe_link }; - - //Constant-time size is incompatible with auto-unlink hooks! - BOOST_STATIC_ASSERT(!(constant_time_size && ((int)real_value_traits::link_mode == (int)auto_unlink))); - //Linear singly linked lists are incompatible with auto-unlink hooks! - BOOST_STATIC_ASSERT(!(linear && ((int)real_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)real_value_traits::link_mode == (int)auto_unlink))); - - node_ptr get_end_node() - { return node_ptr(linear ? node_ptr() : this->get_root_node()); } - - const_node_ptr get_end_node() const - { - return const_node_ptr - (linear ? const_node_ptr() : this->get_root_node()); } - - node_ptr get_root_node() - { return pointer_traits<node_ptr>::pointer_to(data_.root_plus_size_.root_); } - - const_node_ptr get_root_node() const - { return pointer_traits<const_node_ptr>::pointer_to(data_.root_plus_size_.root_); } - - node_ptr get_last_node() - { return this->get_last_node(detail::bool_<cache_last>()); } - - const_node_ptr get_last_node() const - { return this->get_last_node(detail::bool_<cache_last>()); } - - void set_last_node(const node_ptr &n) - { return this->set_last_node(n, detail::bool_<cache_last>()); } - - static node_ptr get_last_node(detail::bool_<false>) - { return node_ptr(); } - - static void set_last_node(const node_ptr &, detail::bool_<false>) - {} - - node_ptr get_last_node(detail::bool_<true>) - { return node_ptr(data_.root_plus_size_.last_); } - - const_node_ptr get_last_node(detail::bool_<true>) const - { return const_node_ptr(data_.root_plus_size_.last_); } - - void set_last_node(const node_ptr & n, detail::bool_<true>) - { data_.root_plus_size_.last_ = n; } - - static node_ptr uncast(const const_node_ptr & ptr) - { return pointer_traits<node_ptr>::const_cast_from(ptr); } - - void set_default_constructed_state() - { - node_algorithms::init_header(this->get_root_node()); - this->priv_size_traits().set_size(size_type(0)); - if(cache_last){ - this->set_last_node(this->get_root_node()); - } - } - - struct root_plus_size - : public size_traits - , public root_plus_last<node, node_ptr, cache_last> - {}; - - struct data_t - : public slist_impl::value_traits - { - typedef typename slist_impl::value_traits value_traits; - data_t(const value_traits &val_traits) - : value_traits(val_traits) - {} - - root_plus_size root_plus_size_; - } data_; - - size_traits &priv_size_traits() - { return data_.root_plus_size_; } - - const size_traits &priv_size_traits() const - { return data_.root_plus_size_; } - - const real_value_traits &get_real_value_traits(detail::bool_<false>) const - { return data_; } - - const real_value_traits &get_real_value_traits(detail::bool_<true>) const - { return data_.get_value_traits(*this); } - - real_value_traits &get_real_value_traits(detail::bool_<false>) - { return data_; } - - real_value_traits &get_real_value_traits(detail::bool_<true>) - { return data_.get_value_traits(*this); } - - const value_traits &priv_value_traits() const - { return data_; } - - value_traits &priv_value_traits() - { return data_; } - - protected: - node &prot_root_node() - { return data_.root_plus_size_.root_; } - - node const &prot_root_node() const - { return data_.root_plus_size_.root_; } - - void prot_set_size(size_type s) - { data_.root_plus_size_.set_size(s); } - - /// @endcond - - public: - - const real_value_traits &get_real_value_traits() const - { return this->get_real_value_traits(detail::bool_<external_value_traits>()); } - - real_value_traits &get_real_value_traits() - { return this->get_real_value_traits(detail::bool_<external_value_traits>()); } - - public: - //! <b>Effects</b>: constructs an empty list. - //! - //! <b>Complexity</b>: Constant - //! - //! <b>Throws</b>: If value_traits::node_traits::node - //! constructor throws (this does not happen with predefined Boost.Intrusive hooks). - slist_impl(const value_traits &v_traits = value_traits()) - : data_(v_traits) - { this->set_default_constructed_state(); } - - //! <b>Requires</b>: Dereferencing iterator must yield an lvalue of type value_type. - //! - //! <b>Effects</b>: Constructs a list equal to [first,last). - //! - //! <b>Complexity</b>: Linear in std::distance(b, e). No copy constructors are called. - //! - //! <b>Throws</b>: If value_traits::node_traits::node - //! constructor throws (this does not happen with predefined Boost.Intrusive hooks). - template<class Iterator> - slist_impl(Iterator b, Iterator e, const value_traits &v_traits = value_traits()) - : data_(v_traits) - { - this->set_default_constructed_state(); - this->insert_after(this->cbefore_begin(), b, e); - } - - //! <b>Effects</b>: to-do - //! - slist_impl(BOOST_RV_REF(slist_impl) x) - : data_(::boost::move(x.priv_value_traits())) - { - this->priv_size_traits().set_size(size_type(0)); - node_algorithms::init_header(this->get_root_node()); - this->swap(x); - } - - //! <b>Effects</b>: to-do - //! - slist_impl& operator=(BOOST_RV_REF(slist_impl) x) - { this->swap(x); return *this; } - - //! <b>Effects</b>: If it's a safe-mode - //! or auto-unlink value, the destructor does nothing - //! (ie. no code is generated). Otherwise it detaches all elements from this. - //! In this case the objects in the list are not deleted (i.e. no destructors - //! are called), but the hooks according to the value_traits template parameter - //! are set to their default value. - //! - //! <b>Complexity</b>: Linear to the number of elements in the list, if - //! it's a safe-mode or auto-unlink value. Otherwise constant. - ~slist_impl() - {} - - //! <b>Effects</b>: Erases all the elements of the container. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Linear to the number of elements of the list. - //! if it's a safe-mode or auto-unlink value_type. Constant time otherwise. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) to the erased elements. - void clear() - { - if(safemode_or_autounlink){ - this->clear_and_dispose(detail::null_disposer()); - } - else{ - this->set_default_constructed_state(); - } - } - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! - //! <b>Effects</b>: Erases all the elements of the container - //! Disposer::operator()(pointer) is called for the removed elements. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Linear to the number of elements of the list. - //! - //! <b>Note</b>: Invalidates the iterators to the erased elements. - template <class Disposer> - void clear_and_dispose(Disposer disposer) - { - const_iterator it(this->begin()), itend(this->end()); - while(it != itend){ - node_ptr to_erase(it.pointed_node()); - ++it; - if(safemode_or_autounlink) - node_algorithms::init(to_erase); - disposer(get_real_value_traits().to_value_ptr(to_erase)); - } - this->set_default_constructed_state(); - } - - //! <b>Requires</b>: value must be an lvalue. - //! - //! <b>Effects</b>: Inserts the value in the front of the list. - //! No copy constructors are called. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Note</b>: Does not affect the validity of iterators and references. - void push_front(reference value) - { - node_ptr to_insert = get_real_value_traits().to_node_ptr(value); - if(safemode_or_autounlink) - BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::inited(to_insert)); - if(cache_last){ - if(this->empty()){ - this->set_last_node(to_insert); - } - } - node_algorithms::link_after(this->get_root_node(), to_insert); - this->priv_size_traits().increment(); - } - - //! <b>Requires</b>: value must be an lvalue. - //! - //! <b>Effects</b>: Inserts the value in the back of the list. - //! No copy constructors are called. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Note</b>: Does not affect the validity of iterators and references. - //! This function is only available is cache_last<> is true. - void push_back(reference value) - { - BOOST_STATIC_ASSERT((cache_last)); - this->insert_after(const_iterator(this->get_last_node(), this), value); - } - - //! <b>Effects</b>: Erases the first element of the list. - //! No destructors are called. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) to the erased element. - void pop_front() - { return this->pop_front_and_dispose(detail::null_disposer()); } - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! - //! <b>Effects</b>: Erases the first element of the list. - //! Disposer::operator()(pointer) is called for the removed element. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Note</b>: Invalidates the iterators to the erased element. - template<class Disposer> - void pop_front_and_dispose(Disposer disposer) - { - node_ptr to_erase = node_traits::get_next(this->get_root_node()); - node_algorithms::unlink_after(this->get_root_node()); - this->priv_size_traits().decrement(); - if(safemode_or_autounlink) - node_algorithms::init(to_erase); - disposer(get_real_value_traits().to_value_ptr(to_erase)); - if(cache_last){ - if(this->empty()){ - this->set_last_node(this->get_root_node()); - } - } - } - - //! <b>Effects</b>: Returns a reference to the first element of the list. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - reference front() - { return *this->get_real_value_traits().to_value_ptr(node_traits::get_next(this->get_root_node())); } - - //! <b>Effects</b>: Returns a const_reference to the first element of the list. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - const_reference front() const - { return *this->get_real_value_traits().to_value_ptr(uncast(node_traits::get_next(this->get_root_node()))); } - - //! <b>Effects</b>: Returns a reference to the last element of the list. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Note</b>: Does not affect the validity of iterators and references. - //! This function is only available is cache_last<> is true. - reference back() - { - BOOST_STATIC_ASSERT((cache_last)); - return *this->get_real_value_traits().to_value_ptr(this->get_last_node()); - } - - //! <b>Effects</b>: Returns a const_reference to the last element of the list. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Note</b>: Does not affect the validity of iterators and references. - //! This function is only available is cache_last<> is true. - const_reference back() const - { - BOOST_STATIC_ASSERT((cache_last)); - return *this->get_real_value_traits().to_value_ptr(this->get_last_node()); - } - - //! <b>Effects</b>: Returns an iterator to the first element contained in the list. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - iterator begin() - { return iterator (node_traits::get_next(this->get_root_node()), this); } - - //! <b>Effects</b>: Returns a const_iterator to the first element contained in the list. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - const_iterator begin() const - { return const_iterator (node_traits::get_next(this->get_root_node()), this); } - - //! <b>Effects</b>: Returns a const_iterator to the first element contained in the list. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - const_iterator cbegin() const - { return const_iterator(node_traits::get_next(this->get_root_node()), this); } - - //! <b>Effects</b>: Returns an iterator to the end of the list. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - iterator end() - { return iterator(this->get_end_node(), this); } - - //! <b>Effects</b>: Returns a const_iterator to the end of the list. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - const_iterator end() const - { return const_iterator(uncast(this->get_end_node()), this); } - - //! <b>Effects</b>: Returns a const_iterator to the end of the list. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - const_iterator cend() const - { return this->end(); } - - //! <b>Effects</b>: Returns an iterator that points to a position - //! before the first element. Equivalent to "end()" - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - iterator before_begin() - { return iterator(this->get_root_node(), this); } - - //! <b>Effects</b>: Returns an iterator that points to a position - //! before the first element. Equivalent to "end()" - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - const_iterator before_begin() const - { return const_iterator(uncast(this->get_root_node()), this); } - - //! <b>Effects</b>: Returns an iterator that points to a position - //! before the first element. Equivalent to "end()" - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - const_iterator cbefore_begin() const - { return this->before_begin(); } - - //! <b>Effects</b>: Returns an iterator to the last element contained in the list. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Note</b>: This function is present only if cached_last<> option is true. - iterator last() - { return iterator (this->get_last_node(), this); } - - //! <b>Effects</b>: Returns a const_iterator to the first element contained in the list. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Note</b>: This function is present only if cached_last<> option is true. - const_iterator last() const - { return const_iterator (this->get_last_node(), this); } - - //! <b>Effects</b>: Returns a const_iterator to the first element contained in the list. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Note</b>: This function is present only if cached_last<> option is true. - const_iterator clast() const - { return const_iterator(this->get_last_node(), this); } - - //! <b>Precondition</b>: end_iterator must be a valid end iterator - //! of slist. - //! - //! <b>Effects</b>: Returns a const reference to the slist associated to the end iterator - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - static slist_impl &container_from_end_iterator(iterator end_iterator) - { return slist_impl::priv_container_from_end_iterator(end_iterator); } - - //! <b>Precondition</b>: end_iterator must be a valid end const_iterator - //! of slist. - //! - //! <b>Effects</b>: Returns a const reference to the slist associated to the end iterator - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - static const slist_impl &container_from_end_iterator(const_iterator end_iterator) - { return slist_impl::priv_container_from_end_iterator(end_iterator); } - - //! <b>Effects</b>: Returns the number of the elements contained in the list. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Linear to the number of elements contained in the list. - //! if constant_time_size is false. Constant time otherwise. - //! - //! <b>Note</b>: Does not affect the validity of iterators and references. - size_type size() const - { - if(constant_time_size) - return this->priv_size_traits().get_size(); - else - return node_algorithms::count(this->get_root_node()) - 1; - } - - //! <b>Effects</b>: Returns true if the list contains no elements. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Note</b>: Does not affect the validity of iterators and references. - bool empty() const - { return node_algorithms::unique(this->get_root_node()); } - - //! <b>Effects</b>: Swaps the elements of x and *this. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Linear to the number of elements of both lists. - //! Constant-time if linear<> and/or cache_last<> options are used. - //! - //! <b>Note</b>: Does not affect the validity of iterators and references. - void swap(slist_impl& other) - { - if(cache_last){ - priv_swap_cache_last(this, &other); - } - else{ - this->priv_swap_lists(this->get_root_node(), other.get_root_node(), detail::bool_<linear>()); - } - if(constant_time_size){ - size_type backup = this->priv_size_traits().get_size(); - this->priv_size_traits().set_size(other.priv_size_traits().get_size()); - other.priv_size_traits().set_size(backup); - } - } - - //! <b>Effects</b>: Moves backwards all the elements, so that the first - //! element becomes the second, the second becomes the third... - //! the last element becomes the first one. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Linear to the number of elements plus the number shifts. - //! - //! <b>Note</b>: Iterators Does not affect the validity of iterators and references. - void shift_backwards(size_type n = 1) - { this->priv_shift_backwards(n, detail::bool_<linear>()); } - - //! <b>Effects</b>: Moves forward all the elements, so that the second - //! element becomes the first, the third becomes the second... - //! the first element becomes the last one. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Linear to the number of elements plus the number shifts. - //! - //! <b>Note</b>: Does not affect the validity of iterators and references. - void shift_forward(size_type n = 1) - { this->priv_shift_forward(n, detail::bool_<linear>()); } - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! Cloner should yield to nodes equivalent to the original nodes. - //! - //! <b>Effects</b>: Erases all the elements from *this - //! calling Disposer::operator()(pointer), clones all the - //! elements from src calling Cloner::operator()(const_reference ) - //! and inserts them on *this. - //! - //! If cloner throws, all cloned elements are unlinked and disposed - //! calling Disposer::operator()(pointer). - //! - //! <b>Complexity</b>: Linear to erased plus inserted elements. - //! - //! <b>Throws</b>: If cloner throws. - template <class Cloner, class Disposer> - void clone_from(const slist_impl &src, Cloner cloner, Disposer disposer) - { - this->clear_and_dispose(disposer); - detail::exception_disposer<slist_impl, Disposer> - rollback(*this, disposer); - const_iterator prev(this->cbefore_begin()); - const_iterator b(src.begin()), e(src.end()); - for(; b != e; ++b){ - prev = this->insert_after(prev, *cloner(*b)); - } - rollback.release(); - } - - //! <b>Requires</b>: value must be an lvalue and prev_p must point to an element - //! contained by the list or to end(). - //! - //! <b>Effects</b>: Inserts the value after the position pointed by prev_p. - //! No copy constructor is called. - //! - //! <b>Returns</b>: An iterator to the inserted element. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Note</b>: Does not affect the validity of iterators and references. - iterator insert_after(const_iterator prev_p, reference value) - { - node_ptr n = get_real_value_traits().to_node_ptr(value); - if(safemode_or_autounlink) - BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::inited(n)); - node_ptr prev_n(prev_p.pointed_node()); - node_algorithms::link_after(prev_n, n); - if(cache_last && (this->get_last_node() == prev_n)){ - this->set_last_node(n); - } - this->priv_size_traits().increment(); - return iterator (n, this); - } - - //! <b>Requires</b>: Dereferencing iterator must yield - //! an lvalue of type value_type and prev_p must point to an element - //! contained by the list or to the end node. - //! - //! <b>Effects</b>: Inserts the [first, last) - //! after the position prev_p. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Linear to the number of elements inserted. - //! - //! <b>Note</b>: Does not affect the validity of iterators and references. - template<class Iterator> - void insert_after(const_iterator prev_p, Iterator first, Iterator last) - { - for (; first != last; ++first) - prev_p = this->insert_after(prev_p, *first); - } - - //! <b>Requires</b>: value must be an lvalue and p must point to an element - //! contained by the list or to end(). - //! - //! <b>Effects</b>: Inserts the value before the position pointed by p. - //! No copy constructor is called. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Linear to the number of elements before p. - //! Constant-time if cache_last<> is true and p == end(). - //! - //! <b>Note</b>: Does not affect the validity of iterators and references. - iterator insert(const_iterator p, reference value) - { return this->insert_after(this->previous(p), value); } - - //! <b>Requires</b>: Dereferencing iterator must yield - //! an lvalue of type value_type and p must point to an element - //! contained by the list or to the end node. - //! - //! <b>Effects</b>: Inserts the pointed by b and e - //! before the position p. No copy constructors are called. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Linear to the number of elements inserted plus linear - //! to the elements before b. - //! Linear to the number of elements to insert if cache_last<> option is true and p == end(). - //! - //! <b>Note</b>: Does not affect the validity of iterators and references. - template<class Iterator> - void insert(const_iterator p, Iterator b, Iterator e) - { return this->insert_after(this->previous(p), b, e); } - - //! <b>Effects</b>: Erases the element after the element pointed by prev of - //! the list. No destructors are called. - //! - //! <b>Returns</b>: the first element remaining beyond the removed elements, - //! or end() if no such element exists. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) to the - //! erased element. - iterator erase_after(const_iterator prev) - { return this->erase_after_and_dispose(prev, detail::null_disposer()); } - - //! <b>Effects</b>: Erases the range (before_first, last) from - //! the list. No destructors are called. - //! - //! <b>Returns</b>: the first element remaining beyond the removed elements, - //! or end() if no such element exists. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Linear to the number of erased elements if it's a safe-mode - //! , auto-unlink value or constant-time size is activated. Constant time otherwise. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) to the - //! erased element. - iterator erase_after(const_iterator before_first, const_iterator last) - { - if(safemode_or_autounlink || constant_time_size){ - return this->erase_after_and_dispose(before_first, last, detail::null_disposer()); - } - else{ - node_ptr bfp = before_first.pointed_node(); - node_ptr lp = last.pointed_node(); - if(cache_last){ - if(lp == this->get_end_node()){ - this->set_last_node(bfp); - } - } - node_algorithms::unlink_after(bfp, lp); - return last.unconst(); - } - } - - //! <b>Effects</b>: Erases the range (before_first, last) from - //! the list. n must be std::distance(before_first, last) - 1. - //! No destructors are called. - //! - //! <b>Returns</b>: the first element remaining beyond the removed elements, - //! or end() if no such element exists. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: constant-time if link_mode is normal_link. - //! Linear to the elements (last - before_first) otherwise. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) to the - //! erased element. - iterator erase_after(const_iterator before_first, const_iterator last, difference_type n) - { - BOOST_INTRUSIVE_INVARIANT_ASSERT(std::distance(++const_iterator(before_first), last) == difference_type(n)); - if(safemode_or_autounlink){ - return this->erase_after(before_first, last); - } - else{ - node_ptr bfp = before_first.pointed_node(); - node_ptr lp = last.pointed_node(); - if(cache_last){ - if((lp == this->get_end_node())){ - this->set_last_node(bfp); - } - } - node_algorithms::unlink_after(bfp, lp); - if(constant_time_size){ - this->priv_size_traits().set_size(this->priv_size_traits().get_size() - n); - } - return last.unconst(); - } - } - - //! <b>Effects</b>: Erases the element pointed by i of the list. - //! No destructors are called. - //! - //! <b>Returns</b>: the first element remaining beyond the removed element, - //! or end() if no such element exists. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Linear to the elements before i. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) to the - //! erased element. - iterator erase(const_iterator i) - { return this->erase_after(this->previous(i)); } - - //! <b>Requires</b>: first and last must be valid iterator to elements in *this. - //! - //! <b>Effects</b>: Erases the range pointed by b and e. - //! No destructors are called. - //! - //! <b>Returns</b>: the first element remaining beyond the removed elements, - //! or end() if no such element exists. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Linear to the elements before last. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) to the - //! erased elements. - iterator erase(const_iterator first, const_iterator last) - { return this->erase_after(this->previous(first), last); } - - //! <b>Effects</b>: Erases the range [first, last) from - //! the list. n must be std::distance(first, last). - //! No destructors are called. - //! - //! <b>Returns</b>: the first element remaining beyond the removed elements, - //! or end() if no such element exists. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: linear to the elements before first if link_mode is normal_link - //! and constant_time_size is activated. Linear to the elements before last otherwise. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) to the - //! erased element. - iterator erase(const_iterator first, const_iterator last, difference_type n) - { return this->erase_after(this->previous(first), last, n); } - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! - //! <b>Effects</b>: Erases the element after the element pointed by prev of - //! the list. - //! Disposer::operator()(pointer) is called for the removed element. - //! - //! <b>Returns</b>: the first element remaining beyond the removed elements, - //! or end() if no such element exists. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Note</b>: Invalidates the iterators to the erased element. - template<class Disposer> - iterator erase_after_and_dispose(const_iterator prev, Disposer disposer) - { - const_iterator it(prev); - ++it; - node_ptr to_erase(it.pointed_node()); - ++it; - node_ptr prev_n(prev.pointed_node()); - node_algorithms::unlink_after(prev_n); - if(cache_last && (to_erase == this->get_last_node())){ - this->set_last_node(prev_n); - } - if(safemode_or_autounlink) - node_algorithms::init(to_erase); - disposer(get_real_value_traits().to_value_ptr(to_erase)); - this->priv_size_traits().decrement(); - return it.unconst(); - } - - /// @cond - - template<class Disposer> - static iterator s_erase_after_and_dispose(const_iterator prev, Disposer disposer) - { - BOOST_STATIC_ASSERT(((!cache_last)&&(!constant_time_size)&&(!stateful_value_traits))); - const_iterator it(prev); - ++it; - node_ptr to_erase(it.pointed_node()); - ++it; - node_ptr prev_n(prev.pointed_node()); - node_algorithms::unlink_after(prev_n); - if(safemode_or_autounlink) - node_algorithms::init(to_erase); - disposer(real_value_traits::to_value_ptr(to_erase)); - return it.unconst(); - } - - static iterator s_erase_after(const_iterator prev) - { return s_erase_after_and_dispose(prev, detail::null_disposer()); } - - /// @endcond - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! - //! <b>Effects</b>: Erases the range (before_first, last) from - //! the list. - //! Disposer::operator()(pointer) is called for the removed elements. - //! - //! <b>Returns</b>: the first element remaining beyond the removed elements, - //! or end() if no such element exists. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Lineal to the elements (last - before_first + 1). - //! - //! <b>Note</b>: Invalidates the iterators to the erased element. - template<class Disposer> - iterator erase_after_and_dispose(const_iterator before_first, const_iterator last, Disposer disposer) - { - node_ptr bfp(before_first.pointed_node()), lp(last.pointed_node()); - node_ptr fp(node_traits::get_next(bfp)); - node_algorithms::unlink_after(bfp, lp); - while(fp != lp){ - node_ptr to_erase(fp); - fp = node_traits::get_next(fp); - if(safemode_or_autounlink) - node_algorithms::init(to_erase); - disposer(get_real_value_traits().to_value_ptr(to_erase)); - this->priv_size_traits().decrement(); - } - if(cache_last && (node_traits::get_next(bfp) == this->get_end_node())){ - this->set_last_node(bfp); - } - return last.unconst(); - } - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! - //! <b>Effects</b>: Erases the element pointed by i of the list. - //! No destructors are called. - //! Disposer::operator()(pointer) is called for the removed element. - //! - //! <b>Returns</b>: the first element remaining beyond the removed element, - //! or end() if no such element exists. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Linear to the elements before i. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) to the - //! erased element. - template<class Disposer> - iterator erase_and_dispose(const_iterator i, Disposer disposer) - { return this->erase_after_and_dispose(this->previous(i), disposer); } - - #if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) - template<class Disposer> - iterator erase_and_dispose(iterator i, Disposer disposer) - { return this->erase_and_dispose(const_iterator(i), disposer); } - #endif - - //! <b>Requires</b>: first and last must be valid iterator to elements in *this. - //! Disposer::operator()(pointer) shouldn't throw. - //! - //! <b>Effects</b>: Erases the range pointed by b and e. - //! No destructors are called. - //! Disposer::operator()(pointer) is called for the removed elements. - //! - //! <b>Returns</b>: the first element remaining beyond the removed elements, - //! or end() if no such element exists. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Linear to the number of erased elements plus linear - //! to the elements before first. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) to the - //! erased elements. - template<class Disposer> - iterator erase_and_dispose(const_iterator first, const_iterator last, Disposer disposer) - { return this->erase_after_and_dispose(this->previous(first), last, disposer); } - - //! <b>Requires</b>: Dereferencing iterator must yield - //! an lvalue of type value_type. - //! - //! <b>Effects</b>: Clears the list and inserts the range pointed by b and e. - //! No destructors or copy constructors are called. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Linear to the number of elements inserted plus - //! linear to the elements contained in the list if it's a safe-mode - //! or auto-unlink value. - //! Linear to the number of elements inserted in the list otherwise. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. - template<class Iterator> - void assign(Iterator b, Iterator e) - { - this->clear(); - this->insert_after(this->cbefore_begin(), b, e); - } - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! - //! <b>Requires</b>: Dereferencing iterator must yield - //! an lvalue of type value_type. - //! - //! <b>Effects</b>: Clears the list and inserts the range pointed by b and e. - //! No destructors or copy constructors are called. - //! Disposer::operator()(pointer) is called for the removed elements. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Linear to the number of elements inserted plus - //! linear to the elements contained in the list. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. - template<class Iterator, class Disposer> - void dispose_and_assign(Disposer disposer, Iterator b, Iterator e) - { - this->clear_and_dispose(disposer); - this->insert_after(this->cbefore_begin(), b, e, disposer); - } - - //! <b>Requires</b>: prev must point to an element contained by this list or - //! to the before_begin() element - //! - //! <b>Effects</b>: Transfers all the elements of list x to this list, after the - //! the element pointed by prev. No destructors or copy constructors are called. - //! - //! <b>Returns</b>: Nothing. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: In general, linear to the elements contained in x. - //! Constant-time if cache_last<> option is true and also constant-time if - //! linear<> option is true "this" is empty and "last" is not used. - //! - //! <b>Note</b>: Iterators of values obtained from list x now point to elements of this - //! list. Iterators of this list and all the references are not invalidated. - //! - //! <b>Additional note</b>: If the optional parameter "last" is provided, it will be - //! assigned to the last spliced element or prev if x is empty. - //! This iterator can be used as new "prev" iterator for a new splice_after call. - //! that will splice new values after the previously spliced values. - void splice_after(const_iterator prev, slist_impl &x, const_iterator *last = 0) - { - if(x.empty()){ - if(last) *last = prev; - } - else if(linear && this->empty()){ - this->swap(x); - if(last) *last = this->previous(this->cend()); - } - else{ - const_iterator last_x(x.previous(x.end())); //<- constant time if cache_last is active - node_ptr prev_n(prev.pointed_node()); - node_ptr last_x_n(last_x.pointed_node()); - if(cache_last){ - x.set_last_node(x.get_root_node()); - if(node_traits::get_next(prev_n) == this->get_end_node()){ - this->set_last_node(last_x_n); - } - } - node_algorithms::transfer_after( prev_n, x.before_begin().pointed_node(), last_x_n); - this->priv_size_traits().set_size(this->priv_size_traits().get_size() + x.priv_size_traits().get_size()); - x.priv_size_traits().set_size(size_type(0)); - if(last) *last = last_x; - } - } - - //! <b>Requires</b>: prev must point to an element contained by this list or - //! to the before_begin() element. prev_ele must point to an element contained in list - //! x or must be x.before_begin(). - //! - //! <b>Effects</b>: Transfers the element after prev_ele, from list x to this list, - //! after the element pointed by prev. No destructors or copy constructors are called. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Note</b>: Iterators of values obtained from list x now point to elements of this - //! list. Iterators of this list and all the references are not invalidated. - void splice_after(const_iterator prev_pos, slist_impl &x, const_iterator prev_ele) - { - const_iterator elem = prev_ele; - this->splice_after(prev_pos, x, prev_ele, ++elem, 1); - } - - //! <b>Requires</b>: prev_pos must be a dereferenceable iterator in *this or be - //! before_begin(), and before_first and before_last belong to x and - //! ++before_first != x.end() && before_last != x.end(). - //! - //! <b>Effects</b>: Transfers the range (before_first, before_last] from list x to this - //! list, after the element pointed by prev_pos. - //! No destructors or copy constructors are called. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Linear to the number of elements transferred - //! if constant_time_size is true. Constant-time otherwise. - //! - //! <b>Note</b>: Iterators of values obtained from list x now point to elements of this - //! list. Iterators of this list and all the references are not invalidated. - void splice_after(const_iterator prev_pos, slist_impl &x, const_iterator before_first, const_iterator before_last) - { - if(constant_time_size) - this->splice_after(prev_pos, x, before_first, before_last, std::distance(before_first, before_last)); - else - this->priv_splice_after - (prev_pos.pointed_node(), x, before_first.pointed_node(), before_last.pointed_node()); - } - - //! <b>Requires</b>: prev_pos must be a dereferenceable iterator in *this or be - //! before_begin(), and before_first and before_last belong to x and - //! ++before_first != x.end() && before_last != x.end() and - //! n == std::distance(before_first, before_last). - //! - //! <b>Effects</b>: Transfers the range (before_first, before_last] from list x to this - //! list, after the element pointed by p. No destructors or copy constructors are called. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant time. - //! - //! <b>Note</b>: Iterators of values obtained from list x now point to elements of this - //! list. Iterators of this list and all the references are not invalidated. - void splice_after(const_iterator prev_pos, slist_impl &x, const_iterator before_first, const_iterator before_last, difference_type n) - { - if(n){ - BOOST_INTRUSIVE_INVARIANT_ASSERT(std::distance(before_first, before_last) == n); - this->priv_splice_after - (prev_pos.pointed_node(), x, before_first.pointed_node(), before_last.pointed_node()); - if(constant_time_size){ - this->priv_size_traits().set_size(this->priv_size_traits().get_size() + n); - x.priv_size_traits().set_size(x.priv_size_traits().get_size() - n); - } - } - } - - //! <b>Requires</b>: it is an iterator to an element in *this. - //! - //! <b>Effects</b>: Transfers all the elements of list x to this list, before the - //! the element pointed by it. No destructors or copy constructors are called. - //! - //! <b>Returns</b>: Nothing. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Linear to the elements contained in x plus linear to - //! the elements before it. - //! Linear to the elements before it if cache_last<> option is true. - //! Constant-time if cache_last<> option is true and it == end(). - //! - //! <b>Note</b>: Iterators of values obtained from list x now point to elements of this - //! list. Iterators of this list and all the references are not invalidated. - //! - //! <b>Additional note</b>: If the optional parameter "last" is provided, it will be - //! assigned to the last spliced element or prev if x is empty. - //! This iterator can be used as new "prev" iterator for a new splice_after call. - //! that will splice new values after the previously spliced values. - void splice(const_iterator it, slist_impl &x, const_iterator *last = 0) - { this->splice_after(this->previous(it), x, last); } - - //! <b>Requires</b>: it p must be a valid iterator of *this. - //! elem must point to an element contained in list - //! x. - //! - //! <b>Effects</b>: Transfers the element elem, from list x to this list, - //! before the element pointed by pos. No destructors or copy constructors are called. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Linear to the elements before pos and before elem. - //! Linear to the elements before elem if cache_last<> option is true and pos == end(). - //! - //! <b>Note</b>: Iterators of values obtained from list x now point to elements of this - //! list. Iterators of this list and all the references are not invalidated. - void splice(const_iterator pos, slist_impl &x, const_iterator elem) - { return this->splice_after(this->previous(pos), x, x.previous(elem)); } - - //! <b>Requires</b>: pos must be a dereferenceable iterator in *this - //! and first and last belong to x and first and last a valid range on x. - //! - //! <b>Effects</b>: Transfers the range [first, last) from list x to this - //! list, before the element pointed by pos. - //! No destructors or copy constructors are called. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Linear to the sum of elements before pos, first, and last - //! plus linear to the number of elements transferred if constant_time_size is true. - //! Linear to the sum of elements before first, and last - //! plus linear to the number of elements transferred if constant_time_size is true - //! if cache_last<> is true and pos == end() - //! - //! <b>Note</b>: Iterators of values obtained from list x now point to elements of this - //! list. Iterators of this list and all the references are not invalidated. - void splice(const_iterator pos, slist_impl &x, const_iterator first, const_iterator last) - { return this->splice_after(this->previous(pos), x, x.previous(first), x.previous(last)); } - - //! <b>Requires</b>: pos must be a dereferenceable iterator in *this - //! and first and last belong to x and first and last a valid range on x. - //! n == std::distance(first, last). - //! - //! <b>Effects</b>: Transfers the range [first, last) from list x to this - //! list, before the element pointed by pos. - //! No destructors or copy constructors are called. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Linear to the sum of elements before pos, first, and last. - //! Linear to the sum of elements before first and last - //! if cache_last<> is true and pos == end(). - //! - //! <b>Note</b>: Iterators of values obtained from list x now point to elements of this - //! list. Iterators of this list and all the references are not invalidated. - void splice(const_iterator pos, slist_impl &x, const_iterator first, const_iterator last, difference_type n) - { return this->splice_after(this->previous(pos), x, x.previous(first), x.previous(last), n); } - - //! <b>Effects</b>: This function sorts the list *this according to std::less<value_type>. - //! The sort is stable, that is, the relative order of equivalent elements is preserved. - //! - //! <b>Throws</b>: If value_traits::node_traits::node - //! constructor throws (this does not happen with predefined Boost.Intrusive hooks) - //! or the predicate throws. Basic guarantee. - //! - //! <b>Complexity</b>: The number of comparisons is approximately N log N, where N - //! is the list's size. - //! - //! <b>Note</b>: Iterators and references are not invalidated - template<class Predicate> - void sort(Predicate p) - { - if (node_traits::get_next(node_traits::get_next(this->get_root_node())) - != this->get_root_node()) { - - slist_impl carry(this->priv_value_traits()); - detail::array_initializer<slist_impl, 64> counter(this->priv_value_traits()); - int fill = 0; - const_iterator last_inserted; - while(!this->empty()){ - last_inserted = this->cbegin(); - carry.splice_after(carry.cbefore_begin(), *this, this->cbefore_begin()); - int i = 0; - while(i < fill && !counter[i].empty()) { - carry.swap(counter[i]); - carry.merge(counter[i++], p, &last_inserted); - } - BOOST_INTRUSIVE_INVARIANT_ASSERT(counter[i].empty()); - const_iterator last_element(carry.previous(last_inserted, carry.end())); - - if(constant_time_size){ - counter[i].splice_after( counter[i].cbefore_begin(), carry - , carry.cbefore_begin(), last_element - , carry.size()); - } - else{ - counter[i].splice_after( counter[i].cbefore_begin(), carry - , carry.cbefore_begin(), last_element); - } - if(i == fill) - ++fill; - } - - for (int i = 1; i < fill; ++i) - counter[i].merge(counter[i-1], p, &last_inserted); - --fill; - const_iterator last_element(counter[fill].previous(last_inserted, counter[fill].end())); - if(constant_time_size){ - this->splice_after( cbefore_begin(), counter[fill], counter[fill].cbefore_begin() - , last_element, counter[fill].size()); - } - else{ - this->splice_after( cbefore_begin(), counter[fill], counter[fill].cbefore_begin() - , last_element); - } - } - } - - //! <b>Requires</b>: p must be a comparison function that induces a strict weak - //! ordering and both *this and x must be sorted according to that ordering - //! The lists x and *this must be distinct. - //! - //! <b>Effects</b>: This function removes all of x's elements and inserts them - //! in order into *this. The merge is stable; that is, if an element from *this is - //! equivalent to one from x, then the element from *this will precede the one from x. - //! - //! <b>Throws</b>: If value_traits::node_traits::node - //! constructor throws (this does not happen with predefined Boost.Intrusive hooks) - //! or std::less<value_type> throws. Basic guarantee. - //! - //! <b>Complexity</b>: This function is linear time: it performs at most - //! size() + x.size() - 1 comparisons. - //! - //! <b>Note</b>: Iterators and references are not invalidated. - void sort() - { this->sort(std::less<value_type>()); } - - //! <b>Requires</b>: p must be a comparison function that induces a strict weak - //! ordering and both *this and x must be sorted according to that ordering - //! The lists x and *this must be distinct. - //! - //! <b>Effects</b>: This function removes all of x's elements and inserts them - //! in order into *this. The merge is stable; that is, if an element from *this is - //! equivalent to one from x, then the element from *this will precede the one from x. - //! - //! <b>Returns</b>: Nothing. - //! - //! <b>Throws</b>: If the predicate throws. Basic guarantee. - //! - //! <b>Complexity</b>: This function is linear time: it performs at most - //! size() + x.size() - 1 comparisons. - //! - //! <b>Note</b>: Iterators and references are not invalidated. - //! - //! <b>Additional note</b>: If optional "last" argument is passed, it is assigned - //! to an iterator to the last transferred value or end() is x is empty. - template<class Predicate> - void merge(slist_impl& x, Predicate p, const_iterator *last = 0) - { - const_iterator e(this->cend()), ex(x.cend()), bb(this->cbefore_begin()), - bb_next; - if(last) *last = e.unconst(); - while(!x.empty()){ - const_iterator ibx_next(x.cbefore_begin()), ibx(ibx_next++); - while (++(bb_next = bb) != e && !p(*ibx_next, *bb_next)){ - bb = bb_next; - } - if(bb_next == e){ - //Now transfer the rest to the end of the container - this->splice_after(bb, x, last); - break; - } - else{ - size_type n(0); - do{ - ibx = ibx_next; ++n; - } while(++(ibx_next = ibx) != ex && p(*ibx_next, *bb_next)); - this->splice_after(bb, x, x.before_begin(), ibx, n); - if(last) *last = ibx; - } - } - } - - //! <b>Effects</b>: This function removes all of x's elements and inserts them - //! in order into *this according to std::less<value_type>. The merge is stable; - //! that is, if an element from *this is equivalent to one from x, then the element - //! from *this will precede the one from x. - //! - //! <b>Throws</b>: if std::less<value_type> throws. Basic guarantee. - //! - //! <b>Complexity</b>: This function is linear time: it performs at most - //! size() + x.size() - 1 comparisons. - //! - //! <b>Note</b>: Iterators and references are not invalidated - void merge(slist_impl& x) - { this->merge(x, std::less<value_type>()); } - - //! <b>Effects</b>: Reverses the order of elements in the list. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: This function is linear to the contained elements. - //! - //! <b>Note</b>: Iterators and references are not invalidated - void reverse() - { - if(cache_last && !this->empty()){ - this->set_last_node(node_traits::get_next(this->get_root_node())); - } - this->priv_reverse(detail::bool_<linear>()); - } - - //! <b>Effects</b>: Removes all the elements that compare equal to value. - //! No destructors are called. - //! - //! <b>Throws</b>: If std::equal_to<value_type> throws. Basic guarantee. - //! - //! <b>Complexity</b>: Linear time. It performs exactly size() comparisons for equality. - //! - //! <b>Note</b>: The relative order of elements that are not removed is unchanged, - //! and iterators to elements that are not removed remain valid. This function is - //! linear time: it performs exactly size() comparisons for equality. - void remove(const_reference value) - { this->remove_if(detail::equal_to_value<const_reference>(value)); } - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! - //! <b>Effects</b>: Removes all the elements that compare equal to value. - //! Disposer::operator()(pointer) is called for every removed element. - //! - //! <b>Throws</b>: If std::equal_to<value_type> throws. Basic guarantee. - //! - //! <b>Complexity</b>: Linear time. It performs exactly size() comparisons for equality. - //! - //! <b>Note</b>: The relative order of elements that are not removed is unchanged, - //! and iterators to elements that are not removed remain valid. - template<class Disposer> - void remove_and_dispose(const_reference value, Disposer disposer) - { this->remove_and_dispose_if(detail::equal_to_value<const_reference>(value), disposer); } - - //! <b>Effects</b>: Removes all the elements for which a specified - //! predicate is satisfied. No destructors are called. - //! - //! <b>Throws</b>: If pred throws. Basic guarantee. - //! - //! <b>Complexity</b>: Linear time. It performs exactly size() calls to the predicate. - //! - //! <b>Note</b>: The relative order of elements that are not removed is unchanged, - //! and iterators to elements that are not removed remain valid. - template<class Pred> - void remove_if(Pred pred) - { this->remove_and_dispose_if(pred, detail::null_disposer()); } - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! - //! <b>Effects</b>: Removes all the elements for which a specified - //! predicate is satisfied. - //! Disposer::operator()(pointer) is called for every removed element. - //! - //! <b>Throws</b>: If pred throws. Basic guarantee. - //! - //! <b>Complexity</b>: Linear time. It performs exactly size() comparisons for equality. - //! - //! <b>Note</b>: The relative order of elements that are not removed is unchanged, - //! and iterators to elements that are not removed remain valid. - template<class Pred, class Disposer> - void remove_and_dispose_if(Pred pred, Disposer disposer) - { - const_iterator bcur(this->before_begin()), cur(this->begin()), e(this->end()); - - while(cur != e){ - if (pred(*cur)){ - cur = this->erase_after_and_dispose(bcur, disposer); - } - else{ - bcur = cur; - ++cur; - } - } - if(cache_last){ - this->set_last_node(bcur.pointed_node()); - } - } - - //! <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>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()); } - - //! <b>Effects</b>: Removes adjacent duplicate elements or adjacent - //! elements that satisfy some binary predicate from the list. - //! No destructors are called. - //! - //! <b>Throws</b>: If the predicate throws. Basic guarantee. - //! - //! <b>Complexity</b>: Linear time (size()-1) comparisons equality comparisons. - //! - //! <b>Note</b>: The relative order of elements that are not removed is unchanged, - //! and iterators to elements that are not removed remain valid. - template<class BinaryPredicate> - void unique(BinaryPredicate pred) - { this->unique_and_dispose(pred, detail::null_disposer()); } - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! - //! <b>Effects</b>: Removes adjacent duplicate elements or adjacent - //! elements that satisfy some binary predicate 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>Complexity</b>: Linear time (size()-1) comparisons equality comparisons. - //! - //! <b>Note</b>: The relative order of elements that are not removed is unchanged, - //! and iterators to elements that are not removed remain valid. - template<class Disposer> - void unique_and_dispose(Disposer disposer) - { this->unique(std::equal_to<value_type>(), disposer); } - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! - //! <b>Effects</b>: Removes adjacent duplicate elements or adjacent - //! elements that satisfy some binary predicate from the list. - //! Disposer::operator()(pointer) is called for every removed element. - //! - //! <b>Throws</b>: If the predicate throws. Basic guarantee. - //! - //! <b>Complexity</b>: Linear time (size()-1) comparisons equality comparisons. - //! - //! <b>Note</b>: The relative order of elements that are not removed is unchanged, - //! and iterators to elements that are not removed remain valid. - template<class BinaryPredicate, class Disposer> - void unique_and_dispose(BinaryPredicate pred, Disposer disposer) - { - const_iterator end_n(this->cend()); - const_iterator bcur(this->cbegin()); - if(bcur != end_n){ - const_iterator cur(bcur); - ++cur; - while(cur != end_n) { - if (pred(*bcur, *cur)){ - cur = this->erase_after_and_dispose(bcur, disposer); - } - else{ - bcur = cur; - ++cur; - } - } - if(cache_last){ - this->set_last_node(bcur.pointed_node()); - } - } - } - - //! <b>Requires</b>: value must be a reference to a value inserted in a list. - //! - //! <b>Effects</b>: This function returns a const_iterator pointing to the element - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant time. - //! - //! <b>Note</b>: Iterators and references are not invalidated. - //! This static function is available only if the <i>value traits</i> - //! is stateless. - static iterator s_iterator_to(reference value) - { - BOOST_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), 0); - } - - //! <b>Requires</b>: value must be a const reference to a value inserted in a list. - //! - //! <b>Effects</b>: This function returns an iterator pointing to the element. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant time. - //! - //! <b>Note</b>: Iterators and references are not invalidated. - //! This static function is available only if the <i>value traits</i> - //! is stateless. - static const_iterator s_iterator_to(const_reference value) - { - BOOST_STATIC_ASSERT((!stateful_value_traits)); - //BOOST_INTRUSIVE_INVARIANT_ASSERT (!node_algorithms::inited(value_traits::to_node_ptr(const_cast<reference> (value)))); - return const_iterator (value_traits::to_node_ptr(const_cast<reference> (value)), 0); - } - - //! <b>Requires</b>: value must be a reference to a value inserted in a list. - //! - //! <b>Effects</b>: This function returns a const_iterator pointing to the element - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant time. - //! - //! <b>Note</b>: Iterators and references are not invalidated. - iterator iterator_to(reference value) - { - //BOOST_INTRUSIVE_INVARIANT_ASSERT (!node_algorithms::inited(value_traits::to_node_ptr(value))); - return iterator (value_traits::to_node_ptr(value), this); - } - - //! <b>Requires</b>: value must be a const reference to a value inserted in a list. - //! - //! <b>Effects</b>: This function returns an iterator pointing to the element. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant time. - //! - //! <b>Note</b>: Iterators and references are not invalidated. - const_iterator iterator_to(const_reference value) const - { - //BOOST_INTRUSIVE_INVARIANT_ASSERT (!node_algorithms::inited(value_traits::to_node_ptr(const_cast<reference> (value)))); - return const_iterator (value_traits::to_node_ptr(const_cast<reference> (value)), this); - } - - //! <b>Returns</b>: The iterator to the element before i in the list. - //! Returns the end-iterator, if either i is the begin-iterator or the - //! list is empty. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Linear to the number of elements before i. - //! Constant if cache_last<> is true and i == end(). - iterator previous(iterator i) - { return this->previous(this->cbefore_begin(), i); } - - //! <b>Returns</b>: The const_iterator to the element before i in the list. - //! Returns the end-const_iterator, if either i is the begin-const_iterator or - //! the list is empty. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Linear to the number of elements before i. - //! Constant if cache_last<> is true and i == end(). - const_iterator previous(const_iterator i) const - { return this->previous(this->cbefore_begin(), i); } - - //! <b>Returns</b>: The iterator to the element before i in the list, - //! starting the search on element after prev_from. - //! Returns the end-iterator, if either i is the begin-iterator or the - //! list is empty. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Linear to the number of elements before i. - //! Constant if cache_last<> is true and i == end(). - iterator previous(const_iterator prev_from, iterator i) - { return this->previous(prev_from, const_iterator(i)).unconst(); } - - //! <b>Returns</b>: The const_iterator to the element before i in the list, - //! starting the search on element after prev_from. - //! Returns the end-const_iterator, if either i is the begin-const_iterator or - //! the list is empty. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Linear to the number of elements before i. - //! Constant if cache_last<> is true and i == end(). - const_iterator previous(const_iterator prev_from, const_iterator i) const - { - if(cache_last && (i.pointed_node() == this->get_end_node())){ - return const_iterator(uncast(this->get_last_node()), this); - } - return const_iterator - (node_algorithms::get_previous_node - (prev_from.pointed_node(), i.pointed_node()), this); - } - - //! <b>Requires</b>: prev_pos must be a dereferenceable iterator in *this or be - //! before_begin(), and before_first and before_last belong to x and - //! ++before_first != x.end() && before_last != x.end(). - //! - //! <b>Effects</b>: Transfers the range (before_first, before_last] to this - //! list, after the element pointed by prev_pos. - //! No destructors or copy constructors are called. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Linear to the number of elements transferred - //! if constant_time_size is true. Constant-time otherwise. - //! - //! <b>Note</b>: Iterators of values obtained from list x now point to elements of this - //! list. Iterators of this list and all the references are not invalidated. - void incorporate_after(const_iterator prev_from, const node_ptr & first, const node_ptr & before_last) - { - if(constant_time_size) - this->incorporate_after(prev_from, first, before_last, std::distance(first, before_last)+1); - else - this->priv_incorporate_after - (prev_from.pointed_node(), first, before_last); - } - - //! <b>Requires</b>: prev_pos must be a dereferenceable iterator in *this or be - //! before_begin(), and before_first and before_last belong to x and - //! ++before_first != x.end() && before_last != x.end() and - //! n == std::distance(first, before_last) + 1. - //! - //! <b>Effects</b>: Transfers the range (before_first, before_last] from list x to this - //! list, after the element pointed by p. No destructors or copy constructors are called. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant time. - //! - //! <b>Note</b>: Iterators of values obtained from list x now point to elements of this - //! list. Iterators of this list and all the references are not invalidated. - void incorporate_after(const_iterator prev_pos, const node_ptr & first, const node_ptr & before_last, difference_type n) - { - if(n){ - BOOST_INTRUSIVE_INVARIANT_ASSERT(std::distance(iterator(first, this), iterator(before_last, this))+1 == n); - this->priv_incorporate_after(prev_pos.pointed_node(), first, before_last); - if(constant_time_size){ - this->priv_size_traits().set_size(this->priv_size_traits().get_size() + n); - } - } - } - - private: - void priv_splice_after(const node_ptr & prev_pos_n, slist_impl &x, const node_ptr & before_first_n, const node_ptr & before_last_n) - { - if (before_first_n != before_last_n && prev_pos_n != before_first_n && prev_pos_n != before_last_n) - { - if(cache_last){ - if(node_traits::get_next(prev_pos_n) == this->get_end_node()){ - this->set_last_node(before_last_n); - } - if(node_traits::get_next(before_last_n) == x.get_end_node()){ - x.set_last_node(before_first_n); - } - } - node_algorithms::transfer_after(prev_pos_n, before_first_n, before_last_n); - } - } - - void priv_incorporate_after(const node_ptr & prev_pos_n, const node_ptr & first_n, const node_ptr & before_last_n) - { - if(cache_last){ - if(node_traits::get_next(prev_pos_n) == this->get_end_node()){ - this->set_last_node(before_last_n); - } - } - node_algorithms::incorporate_after(prev_pos_n, first_n, before_last_n); - } - - void priv_reverse(detail::bool_<false>) - { node_algorithms::reverse(this->get_root_node()); } - - void priv_reverse(detail::bool_<true>) - { - node_ptr new_first = node_algorithms::reverse - (node_traits::get_next(this->get_root_node())); - node_traits::set_next(this->get_root_node(), new_first); - } - - void priv_shift_backwards(size_type n, detail::bool_<false>) - { - node_ptr last = node_algorithms::move_forward(this->get_root_node(), (std::size_t)n); - if(cache_last && last){ - this->set_last_node(last); - } - } - - void priv_shift_backwards(size_type n, detail::bool_<true>) - { - std::pair<node_ptr, node_ptr> ret( - node_algorithms::move_first_n_forward - (node_traits::get_next(this->get_root_node()), (std::size_t)n)); - if(ret.first){ - node_traits::set_next(this->get_root_node(), ret.first); - if(cache_last){ - this->set_last_node(ret.second); - } - } - } - - void priv_shift_forward(size_type n, detail::bool_<false>) - { - node_ptr last = node_algorithms::move_backwards(this->get_root_node(), (std::size_t)n); - if(cache_last && last){ - this->set_last_node(last); - } - } - - void priv_shift_forward(size_type n, detail::bool_<true>) - { - std::pair<node_ptr, node_ptr> ret( - node_algorithms::move_first_n_backwards - (node_traits::get_next(this->get_root_node()), (std::size_t)n)); - if(ret.first){ - node_traits::set_next(this->get_root_node(), ret.first); - if(cache_last){ - this->set_last_node(ret.second); - } - } - } - - static void priv_swap_cache_last(slist_impl *this_impl, slist_impl *other_impl) - { - bool other_was_empty = false; - if(this_impl->empty()){ - //Check if both are empty or - if(other_impl->empty()) - return; - //If this is empty swap pointers - slist_impl *tmp = this_impl; - this_impl = other_impl; - other_impl = tmp; - other_was_empty = true; - } - else{ - other_was_empty = other_impl->empty(); - } - - //Precondition: this is not empty - node_ptr other_old_last(other_impl->get_last_node()); - node_ptr other_bfirst(other_impl->get_root_node()); - node_ptr this_bfirst(this_impl->get_root_node()); - node_ptr this_old_last(this_impl->get_last_node()); - - //Move all nodes from this to other's beginning - node_algorithms::transfer_after(other_bfirst, this_bfirst, this_old_last); - other_impl->set_last_node(this_old_last); - - if(other_was_empty){ - this_impl->set_last_node(this_bfirst); - } - else{ - //Move trailing nodes from other to this - node_algorithms::transfer_after(this_bfirst, this_old_last, other_old_last); - this_impl->set_last_node(other_old_last); - } - } - - //circular version - static void priv_swap_lists(const node_ptr & this_node, const node_ptr & other_node, detail::bool_<false>) - { node_algorithms::swap_nodes(this_node, other_node); } - - //linear version - static void priv_swap_lists(const node_ptr & this_node, const node_ptr & other_node, detail::bool_<true>) - { node_algorithms::swap_trailing_nodes(this_node, other_node); } - - static slist_impl &priv_container_from_end_iterator(const const_iterator &end_iterator) - { - //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); - root_plus_size *r = detail::parent_from_member<root_plus_size, node> - ( boost::intrusive::detail::to_raw_pointer(end_iterator.pointed_node()), (&root_plus_size::root_)); - data_t *d = detail::parent_from_member<data_t, root_plus_size> - ( r, &data_t::root_plus_size_); - slist_impl *s = detail::parent_from_member<slist_impl, data_t>(d, &slist_impl::data_); - return *s; - } -}; - -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -inline bool operator< -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -(const slist_impl<T, Options...> &x, const slist_impl<T, Options...> &y) -#else -(const slist_impl<Config> &x, const slist_impl<Config> &y) -#endif -{ return std::lexicographical_compare(x.begin(), x.end(), y.begin(), y.end()); } - -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -bool operator== -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -(const slist_impl<T, Options...> &x, const slist_impl<T, Options...> &y) -#else -(const slist_impl<Config> &x, const slist_impl<Config> &y) -#endif -{ - typedef slist_impl<Config> slist_type; - typedef typename slist_type::const_iterator const_iterator; - const bool C = slist_type::constant_time_size; - if(C && x.size() != y.size()){ - return false; - } - const_iterator end1 = x.end(); - - const_iterator i1 = x.begin(); - const_iterator i2 = y.begin(); - if(C){ - while (i1 != end1 && *i1 == *i2) { - ++i1; - ++i2; - } - return i1 == end1; - } - else{ - const_iterator end2 = y.end(); - while (i1 != end1 && i2 != end2 && *i1 == *i2) { - ++i1; - ++i2; - } - return i1 == end1 && i2 == end2; - } -} - -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -inline bool operator!= -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -(const slist_impl<T, Options...> &x, const slist_impl<T, Options...> &y) -#else -(const slist_impl<Config> &x, const slist_impl<Config> &y) -#endif -{ return !(x == y); } - -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -inline bool operator> -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -(const slist_impl<T, Options...> &x, const slist_impl<T, Options...> &y) -#else -(const slist_impl<Config> &x, const slist_impl<Config> &y) -#endif -{ return y < x; } - -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -inline bool operator<= -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -(const slist_impl<T, Options...> &x, const slist_impl<T, Options...> &y) -#else -(const slist_impl<Config> &x, const slist_impl<Config> &y) -#endif -{ return !(y < x); } - -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -inline bool operator>= -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -(const slist_impl<T, Options...> &x, const slist_impl<T, Options...> &y) -#else -(const slist_impl<Config> &x, const slist_impl<Config> &y) -#endif -{ return !(x < y); } - -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -inline void swap -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -(slist_impl<T, Options...> &x, slist_impl<T, Options...> &y) -#else -(slist_impl<Config> &x, slist_impl<Config> &y) -#endif -{ x.swap(y); } - -//! Helper metafunction to define a \c slist that yields to the same type when the -//! same options (either explicitly or implicitly) are used. -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) || defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template<class T, class ...Options> -#else -template<class T, class O1 = none, class O2 = none, class O3 = none, class O4 = none, class O5 = none> -#endif -struct make_slist -{ - /// @cond - typedef typename pack_options - < slist_defaults<T>, - #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) - O1, O2, O3, O4, O5 - #else - Options... - #endif - >::type packed_options; - typedef typename detail::get_value_traits - <T, typename packed_options::value_traits>::type value_traits; - typedef slist_impl - < - slistopt - < value_traits - , typename packed_options::size_type - , packed_options::constant_time_size - , packed_options::linear - , packed_options::cache_last - > - > implementation_defined; - /// @endcond - typedef implementation_defined type; -}; - - -#ifndef BOOST_INTRUSIVE_DOXYGEN_INVOKED - -#if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template<class T, class O1, class O2, class O3, class O4, class O5> -#else -template<class T, class ...Options> -#endif -class slist - : public make_slist<T, - #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) - O1, O2, O3, O4, O5 - #else - Options... - #endif - >::type -{ - typedef typename make_slist - <T, - #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) - O1, O2, O3, O4, O5 - #else - Options... - #endif - >::type Base; - typedef typename Base::real_value_traits real_value_traits; - //Assert if passed value traits are compatible with the type - BOOST_STATIC_ASSERT((detail::is_same<typename real_value_traits::value_type, T>::value)); - BOOST_MOVABLE_BUT_NOT_COPYABLE(slist) - - public: - typedef typename Base::value_traits value_traits; - typedef typename Base::iterator iterator; - typedef typename Base::const_iterator const_iterator; - - slist(const value_traits &v_traits = value_traits()) - : Base(v_traits) - {} - - template<class Iterator> - slist(Iterator b, Iterator e, const value_traits &v_traits = value_traits()) - : Base(b, e, v_traits) - {} - - slist(BOOST_RV_REF(slist) x) - : Base(::boost::move(static_cast<Base&>(x))) - {} - - slist& operator=(BOOST_RV_REF(slist) x) - { this->Base::operator=(::boost::move(static_cast<Base&>(x))); return *this; } - - static slist &container_from_end_iterator(iterator end_iterator) - { return static_cast<slist &>(Base::container_from_end_iterator(end_iterator)); } - - static const slist &container_from_end_iterator(const_iterator end_iterator) - { return static_cast<const slist &>(Base::container_from_end_iterator(end_iterator)); } -}; - -#endif - -} //namespace intrusive -} //namespace boost - -#include <boost/intrusive/detail/config_end.hpp> - -#endif //BOOST_INTRUSIVE_SLIST_HPP diff --git a/src/third_party/boost/boost/intrusive/slist_hook.hpp b/src/third_party/boost/boost/intrusive/slist_hook.hpp deleted file mode 100644 index 1debe66c86d..00000000000 --- a/src/third_party/boost/boost/intrusive/slist_hook.hpp +++ /dev/null @@ -1,294 +0,0 @@ -///////////////////////////////////////////////////////////////////////////// -// -// (C) Copyright Olaf Krzikalla 2004-2006. -// (C) Copyright Ion Gaztanaga 2006-2009 -// -// Distributed under the Boost Software License, Version 1.0. -// (See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) -// -// See http://www.boost.org/libs/intrusive for documentation. -// -///////////////////////////////////////////////////////////////////////////// - -#ifndef BOOST_INTRUSIVE_SLIST_HOOK_HPP -#define BOOST_INTRUSIVE_SLIST_HOOK_HPP - -#include <boost/intrusive/detail/config_begin.hpp> -#include <boost/intrusive/intrusive_fwd.hpp> -#include <boost/intrusive/detail/utilities.hpp> -#include <boost/intrusive/detail/slist_node.hpp> -#include <boost/intrusive/circular_slist_algorithms.hpp> -#include <boost/intrusive/link_mode.hpp> -#include <boost/intrusive/options.hpp> -#include <boost/intrusive/detail/generic_hook.hpp> - -namespace boost { -namespace intrusive { - -/// @cond -template<class VoidPointer> -struct get_slist_node_algo -{ - typedef circular_slist_algorithms<slist_node_traits<VoidPointer> > type; -}; - -/// @endcond - -//! Helper metafunction to define a \c slist_base_hook that yields to the same -//! type when the same options (either explicitly or implicitly) are used. -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) || defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template<class ...Options> -#else -template<class O1 = none, class O2 = none, class O3 = none> -#endif -struct make_slist_base_hook -{ - /// @cond - typedef typename pack_options - < hook_defaults, - #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) - O1, O2, O3 - #else - Options... - #endif - >::type packed_options; - - typedef detail::generic_hook - < get_slist_node_algo<typename packed_options::void_pointer> - , typename packed_options::tag - , packed_options::link_mode - , detail::SlistBaseHook - > implementation_defined; - /// @endcond - typedef implementation_defined type; -}; - -//! Derive a class from slist_base_hook in order to store objects in -//! in an list. slist_base_hook holds the data necessary to maintain the -//! list and provides an appropriate value_traits class for list. -//! -//! The hook admits the following options: \c tag<>, \c void_pointer<> and -//! \c link_mode<>. -//! -//! \c tag<> defines a tag to identify the node. -//! The same tag value can be used in different classes, but if a class is -//! derived from more than one \c list_base_hook, then each \c list_base_hook needs its -//! unique tag. -//! -//! \c link_mode<> will specify the linking mode of the hook (\c normal_link, -//! \c auto_unlink or \c safe_link). -//! -//! \c void_pointer<> is the pointer type that will be used internally in the hook -//! and the the container configured to use this hook. -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) || defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template<class ...Options> -#else -template<class O1, class O2, class O3> -#endif -class slist_base_hook - : public make_slist_base_hook< - #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) - O1, O2, O3 - #else - Options... - #endif - >::type -{ - #if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) - public: - //! <b>Effects</b>: If link_mode is \c auto_unlink or \c safe_link - //! initializes the node to an unlinked state. - //! - //! <b>Throws</b>: Nothing. - slist_base_hook(); - - //! <b>Effects</b>: If link_mode is \c auto_unlink or \c safe_link - //! initializes the node to an unlinked state. The argument is ignored. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Rationale</b>: Providing a copy-constructor - //! makes classes using the hook STL-compliant without forcing the - //! user to do some additional work. \c swap can be used to emulate - //! move-semantics. - slist_base_hook(const slist_base_hook& ); - - //! <b>Effects</b>: Empty function. The argument is ignored. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Rationale</b>: Providing an assignment operator - //! makes classes using the hook STL-compliant without forcing the - //! user to do some additional work. \c swap can be used to emulate - //! move-semantics. - slist_base_hook& operator=(const slist_base_hook& ); - - //! <b>Effects</b>: If link_mode is \c normal_link, the destructor does - //! nothing (ie. no code is generated). If link_mode is \c safe_link and the - //! object is stored in an slist an assertion is raised. If link_mode is - //! \c auto_unlink and \c is_linked() is true, the node is unlinked. - //! - //! <b>Throws</b>: Nothing. - ~slist_base_hook(); - - //! <b>Effects</b>: Swapping two nodes swaps the position of the elements - //! related to those nodes in one or two containers. That is, if the node - //! this is part of the element e1, the node x is part of the element e2 - //! and both elements are included in the containers s1 and s2, then after - //! the swap-operation e1 is in s2 at the position of e2 and e2 is in s1 - //! at the position of e1. If one element is not in a container, then - //! after the swap-operation the other element is not in a container. - //! Iterators to e1 and e2 related to those nodes are invalidated. - //! - //! <b>Complexity</b>: Constant - //! - //! <b>Throws</b>: Nothing. - void swap_nodes(slist_base_hook &other); - - //! <b>Precondition</b>: link_mode must be \c safe_link or \c auto_unlink. - //! - //! <b>Returns</b>: true, if the node belongs to a container, false - //! otherwise. This function can be used to test whether \c slist::iterator_to - //! will return a valid iterator. - //! - //! <b>Complexity</b>: Constant - bool is_linked() const; - - //! <b>Effects</b>: Removes the node if it's inserted in a container. - //! This function is only allowed if link_mode is \c auto_unlink. - //! - //! <b>Throws</b>: Nothing. - void unlink(); - #endif -}; - -//! Helper metafunction to define a \c slist_member_hook that yields to the same -//! type when the same options (either explicitly or implicitly) are used. -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) || defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template<class ...Options> -#else -template<class O1 = none, class O2 = none, class O3 = none> -#endif -struct make_slist_member_hook -{ - /// @cond - typedef typename pack_options - < hook_defaults, - #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) - O1, O2, O3 - #else - Options... - #endif - >::type packed_options; - - typedef detail::generic_hook - < get_slist_node_algo<typename packed_options::void_pointer> - , member_tag - , packed_options::link_mode - , detail::NoBaseHook - > implementation_defined; - /// @endcond - typedef implementation_defined type; -}; - -//! Put a public data member slist_member_hook in order to store objects of this class in -//! an list. slist_member_hook holds the data necessary for maintaining the list and -//! provides an appropriate value_traits class for list. -//! -//! The hook admits the following options: \c void_pointer<> and -//! \c link_mode<>. -//! -//! \c link_mode<> will specify the linking mode of the hook (\c normal_link, -//! \c auto_unlink or \c safe_link). -//! -//! \c void_pointer<> is the pointer type that will be used internally in the hook -//! and the the container configured to use this hook. -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) || defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template<class ...Options> -#else -template<class O1, class O2, class O3> -#endif -class slist_member_hook - : public make_slist_member_hook< - #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) - O1, O2, O3 - #else - Options... - #endif - >::type -{ - #if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) - public: - //! <b>Effects</b>: If link_mode is \c auto_unlink or \c safe_link - //! initializes the node to an unlinked state. - //! - //! <b>Throws</b>: Nothing. - slist_member_hook(); - - //! <b>Effects</b>: If link_mode is \c auto_unlink or \c safe_link - //! initializes the node to an unlinked state. The argument is ignored. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Rationale</b>: Providing a copy-constructor - //! makes classes using the hook STL-compliant without forcing the - //! user to do some additional work. \c swap can be used to emulate - //! move-semantics. - slist_member_hook(const slist_member_hook& ); - - //! <b>Effects</b>: Empty function. The argument is ignored. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Rationale</b>: Providing an assignment operator - //! makes classes using the hook STL-compliant without forcing the - //! user to do some additional work. \c swap can be used to emulate - //! move-semantics. - slist_member_hook& operator=(const slist_member_hook& ); - - //! <b>Effects</b>: If link_mode is \c normal_link, the destructor does - //! nothing (ie. no code is generated). If link_mode is \c safe_link and the - //! object is stored in an slist an assertion is raised. If link_mode is - //! \c auto_unlink and \c is_linked() is true, the node is unlinked. - //! - //! <b>Throws</b>: Nothing. - ~slist_member_hook(); - - //! <b>Effects</b>: Swapping two nodes swaps the position of the elements - //! related to those nodes in one or two containers. That is, if the node - //! this is part of the element e1, the node x is part of the element e2 - //! and both elements are included in the containers s1 and s2, then after - //! the swap-operation e1 is in s2 at the position of e2 and e2 is in s1 - //! at the position of e1. If one element is not in a container, then - //! after the swap-operation the other element is not in a container. - //! Iterators to e1 and e2 related to those nodes are invalidated. - //! - //! <b>Complexity</b>: Constant - //! - //! <b>Throws</b>: Nothing. - void swap_nodes(slist_member_hook &other); - - //! <b>Precondition</b>: link_mode must be \c safe_link or \c auto_unlink. - //! - //! <b>Returns</b>: true, if the node belongs to a container, false - //! otherwise. This function can be used to test whether \c slist::iterator_to - //! will return a valid iterator. - //! - //! <b>Complexity</b>: Constant - bool is_linked() const; - - //! <b>Effects</b>: Removes the node if it's inserted in a container. - //! This function is only allowed if link_mode is \c auto_unlink. - //! - //! <b>Throws</b>: Nothing. - void unlink(); - #endif -}; - -} //namespace intrusive -} //namespace boost - -#include <boost/intrusive/detail/config_end.hpp> - -#endif //BOOST_INTRUSIVE_SLIST_HOOK_HPP diff --git a/src/third_party/boost/boost/intrusive/splay_set.hpp b/src/third_party/boost/boost/intrusive/splay_set.hpp deleted file mode 100644 index 5a21a06af81..00000000000 --- a/src/third_party/boost/boost/intrusive/splay_set.hpp +++ /dev/null @@ -1,2403 +0,0 @@ -///////////////////////////////////////////////////////////////////////////// -// -// (C) Copyright Ion Gaztanaga 2007-2009 -// -// Distributed under the Boost Software License, Version 1.0. -// (See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) -// -// See http://www.boost.org/libs/intrusive for documentation. -// -///////////////////////////////////////////////////////////////////////////// -#ifndef BOOST_INTRUSIVE_SPLAY_SET_HPP -#define BOOST_INTRUSIVE_SPLAY_SET_HPP - -#include <boost/intrusive/detail/config_begin.hpp> -#include <boost/intrusive/intrusive_fwd.hpp> -#include <boost/intrusive/splaytree.hpp> -#include <boost/intrusive/detail/mpl.hpp> -#include <boost/move/move.hpp> -#include <iterator> - -namespace boost { -namespace intrusive { - -//! The class template splay_set is an intrusive container, that mimics most of -//! the interface of std::set as described in the C++ standard. -//! -//! The template parameter \c T is the type to be managed by the container. -//! The user can specify additional options and if no options are provided -//! default options are used. -//! -//! The container supports the following options: -//! \c base_hook<>/member_hook<>/value_traits<>, -//! \c constant_time_size<>, \c size_type<> and -//! \c compare<>. -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -class splay_set_impl -{ - /// @cond - typedef splaytree_impl<Config> tree_type; - //! This class is - //! movable - BOOST_MOVABLE_BUT_NOT_COPYABLE(splay_set_impl) - - typedef tree_type implementation_defined; - /// @endcond - - public: - typedef typename implementation_defined::value_type value_type; - typedef typename implementation_defined::value_traits value_traits; - typedef typename implementation_defined::pointer pointer; - typedef typename implementation_defined::const_pointer const_pointer; - typedef typename implementation_defined::reference reference; - typedef typename implementation_defined::const_reference const_reference; - typedef typename implementation_defined::difference_type difference_type; - typedef typename implementation_defined::size_type size_type; - typedef typename implementation_defined::value_compare value_compare; - typedef typename implementation_defined::key_compare key_compare; - typedef typename implementation_defined::iterator iterator; - typedef typename implementation_defined::const_iterator const_iterator; - typedef typename implementation_defined::reverse_iterator reverse_iterator; - typedef typename implementation_defined::const_reverse_iterator const_reverse_iterator; - typedef typename implementation_defined::insert_commit_data insert_commit_data; - typedef typename implementation_defined::node_traits node_traits; - typedef typename implementation_defined::node node; - typedef typename implementation_defined::node_ptr node_ptr; - typedef typename implementation_defined::const_node_ptr const_node_ptr; - typedef typename implementation_defined::node_algorithms node_algorithms; - - static const bool constant_time_size = Config::constant_time_size; - - /// @cond - private: - tree_type tree_; - /// @endcond - - public: - //! <b>Effects</b>: Constructs an empty splay_set. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: If value_traits::node_traits::node - //! constructor throws (this does not happen with predefined Boost.Intrusive hooks) - //! or the copy constructor of the value_compare object throws. - splay_set_impl( const value_compare &cmp = value_compare() - , const value_traits &v_traits = value_traits()) - : tree_(cmp, v_traits) - {} - - //! <b>Requires</b>: Dereferencing iterator must yield an lvalue of type value_type. - //! cmp must be a comparison function that induces a strict weak ordering. - //! - //! <b>Effects</b>: Constructs an empty splay_set and inserts elements from - //! [b, e). - //! - //! <b>Complexity</b>: Linear in N if [b, e) is already sorted using - //! comp and otherwise amortized N * log N, where N is std::distance(last, first). - //! - //! <b>Throws</b>: If value_traits::node_traits::node - //! constructor throws (this does not happen with predefined Boost.Intrusive hooks) - //! or the copy constructor/operator() of the value_compare object throws. - template<class Iterator> - splay_set_impl( Iterator b, Iterator e - , const value_compare &cmp = value_compare() - , const value_traits &v_traits = value_traits()) - : tree_(true, b, e, cmp, v_traits) - {} - - //! <b>Effects</b>: to-do - //! - splay_set_impl(BOOST_RV_REF(splay_set_impl) x) - : tree_(::boost::move(x.tree_)) - {} - - //! <b>Effects</b>: to-do - //! - splay_set_impl& operator=(BOOST_RV_REF(splay_set_impl) x) - { tree_ = ::boost::move(x.tree_); return *this; } - - //! <b>Effects</b>: Detaches all elements from this. The objects in the splay_set - //! are not deleted (i.e. no destructors are called). - //! - //! <b>Complexity</b>: Linear to the number of elements on the container. - //! if it's a safe-mode or auto-unlink value_type. Constant time otherwise. - //! - //! <b>Throws</b>: Nothing. - ~splay_set_impl() - {} - - //! <b>Effects</b>: Returns an iterator pointing to the beginning of the splay_set. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - iterator begin() - { return tree_.begin(); } - - //! <b>Effects</b>: Returns a const_iterator pointing to the beginning of the splay_set. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_iterator begin() const - { return tree_.begin(); } - - //! <b>Effects</b>: Returns a const_iterator pointing to the beginning of the splay_set. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_iterator cbegin() const - { return tree_.cbegin(); } - - //! <b>Effects</b>: Returns an iterator pointing to the end of the splay_set. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - iterator end() - { return tree_.end(); } - - //! <b>Effects</b>: Returns a const_iterator pointing to the end of the splay_set. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_iterator end() const - { return tree_.end(); } - - //! <b>Effects</b>: Returns a const_iterator pointing to the end of the splay_set. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_iterator cend() const - { return tree_.cend(); } - - //! <b>Effects</b>: Returns a reverse_iterator pointing to the beginning of the - //! reversed splay_set. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - reverse_iterator rbegin() - { return tree_.rbegin(); } - - //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning - //! of the reversed splay_set. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_reverse_iterator rbegin() const - { return tree_.rbegin(); } - - //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning - //! of the reversed splay_set. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_reverse_iterator crbegin() const - { return tree_.crbegin(); } - - //! <b>Effects</b>: Returns a reverse_iterator pointing to the end - //! of the reversed splay_set. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - reverse_iterator rend() - { return tree_.rend(); } - - //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the end - //! of the reversed splay_set. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_reverse_iterator rend() const - { return tree_.rend(); } - - //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the end - //! of the reversed splay_set. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_reverse_iterator crend() const - { return tree_.crend(); } - - //! <b>Precondition</b>: end_iterator must be a valid end iterator - //! of splay_set. - //! - //! <b>Effects</b>: Returns a const reference to the splay_set associated to the end iterator - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - static splay_set_impl &container_from_end_iterator(iterator end_iterator) - { - return *detail::parent_from_member<splay_set_impl, tree_type> - ( &tree_type::container_from_end_iterator(end_iterator) - , &splay_set_impl::tree_); - } - - //! <b>Precondition</b>: end_iterator must be a valid end const_iterator - //! of splay_set. - //! - //! <b>Effects</b>: Returns a const reference to the splay_set associated to the end iterator - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - static const splay_set_impl &container_from_end_iterator(const_iterator end_iterator) - { - return *detail::parent_from_member<splay_set_impl, tree_type> - ( &tree_type::container_from_end_iterator(end_iterator) - , &splay_set_impl::tree_); - } - - //! <b>Precondition</b>: it must be a valid iterator of set. - //! - //! <b>Effects</b>: Returns a reference to the set associated to the iterator - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - static splay_set_impl &container_from_iterator(iterator it) - { - return *detail::parent_from_member<splay_set_impl, tree_type> - ( &tree_type::container_from_iterator(it) - , &splay_set_impl::tree_); - } - - //! <b>Precondition</b>: it must be a valid const_iterator of set. - //! - //! <b>Effects</b>: Returns a const reference to the set associated to the iterator - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Logarithmic. - static const splay_set_impl &container_from_iterator(const_iterator it) - { - return *detail::parent_from_member<splay_set_impl, tree_type> - ( &tree_type::container_from_iterator(it) - , &splay_set_impl::tree_); - } - - //! <b>Effects</b>: Returns the key_compare object used by the splay_set. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: If key_compare copy-constructor throws. - key_compare key_comp() const - { return tree_.value_comp(); } - - //! <b>Effects</b>: Returns the value_compare object used by the splay_set. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: If value_compare copy-constructor throws. - value_compare value_comp() const - { return tree_.value_comp(); } - - //! <b>Effects</b>: Returns true if the container is empty. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - bool empty() const - { return tree_.empty(); } - - //! <b>Effects</b>: Returns the number of elements stored in the splay_set. - //! - //! <b>Complexity</b>: Linear to elements contained in *this if, - //! constant-time size option is enabled. Constant-time otherwise. - //! - //! <b>Throws</b>: Nothing. - size_type size() const - { return tree_.size(); } - - //! <b>Effects</b>: Swaps the contents of two splay_sets. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: If the swap() call for the comparison functor - //! found using ADL throws. Strong guarantee. - void swap(splay_set_impl& other) - { tree_.swap(other.tree_); } - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! Cloner should yield to nodes equivalent to the original nodes. - //! - //! <b>Effects</b>: Erases all the elements from *this - //! calling Disposer::operator()(pointer), clones all the - //! elements from src calling Cloner::operator()(const_reference ) - //! and inserts them on *this. Copies the predicate from the source container. - //! - //! If cloner throws, all cloned elements are unlinked and disposed - //! calling Disposer::operator()(pointer). - //! - //! <b>Complexity</b>: Linear to erased plus inserted elements. - //! - //! <b>Throws</b>: If cloner throws or predicate copy assignment throws. Basic guarantee. - template <class Cloner, class Disposer> - void clone_from(const splay_set_impl &src, Cloner cloner, Disposer disposer) - { tree_.clone_from(src.tree_, cloner, disposer); } - - //! <b>Requires</b>: value must be an lvalue - //! - //! <b>Effects</b>: Tries to inserts value into the splay_set. - //! - //! <b>Returns</b>: If the value - //! is not already present inserts it and returns a pair containing the - //! iterator to the new value and true. If there is an equivalent value - //! returns a pair containing an iterator to the already present value - //! and false. - //! - //! <b>Complexity</b>: Amortized logarithmic. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. Strong guarantee. - //! - //! <b>Note</b>: Does not affect the validity of iterators and references. - //! No copy-constructors are called. - std::pair<iterator, bool> insert(reference value) - { return tree_.insert_unique(value); } - - //! <b>Requires</b>: value must be an lvalue - //! - //! <b>Effects</b>: Tries to to insert x into the splay_set, using "hint" - //! as a hint to where it will be inserted. - //! - //! <b>Returns</b>: An iterator that points to the position where the - //! new element was inserted into the splay_set. - //! - //! <b>Complexity</b>: Amortized logarithmic in general, but it's amortized - //! constant time if t is inserted immediately before hint. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. Strong guarantee. - //! - //! <b>Note</b>: Does not affect the validity of iterators and references. - //! No copy-constructors are called. - iterator insert(const_iterator hint, reference value) - { return tree_.insert_unique(hint, value); } - - //! <b>Requires</b>: key_value_comp must be a comparison function that induces - //! the same strict weak ordering as value_compare. The difference is that - //! key_value_comp compares an arbitrary key with the contained values. - //! - //! <b>Effects</b>: Checks if a value can be inserted in the splay_set, using - //! a user provided key instead of the value itself. - //! - //! <b>Returns</b>: If there is an equivalent value - //! returns a pair containing an iterator to the already present value - //! and false. If the value can be inserted returns true in the returned - //! pair boolean and fills "commit_data" that is meant to be used with - //! the "insert_commit" function. - //! - //! <b>Complexity</b>: Amortized logarithmic. - //! - //! <b>Throws</b>: If the key_value_comp ordering function throws. Strong guarantee. - //! - //! <b>Notes</b>: This function is used to improve performance when constructing - //! a value_type is expensive: if there is an equivalent value - //! the constructed object must be discarded. Many times, the part of the - //! node that is used to impose the order is much cheaper to construct - //! than the value_type and this function offers the possibility to use that - //! part to check if the insertion will be successful. - //! - //! If the check is successful, the user can construct the value_type and use - //! "insert_commit" to insert the object in constant-time. This gives a total - //! logarithmic complexity to the insertion: check(O(log(N)) + commit(O(1)). - //! - //! "commit_data" remains valid for a subsequent "insert_commit" only if no more - //! objects are inserted or erased from the splay_set. - template<class KeyType, class KeyValueCompare> - std::pair<iterator, bool> insert_check - (const KeyType &key, KeyValueCompare key_value_comp, insert_commit_data &commit_data) - { return tree_.insert_unique_check(key, key_value_comp, commit_data); } - - //! <b>Requires</b>: key_value_comp must be a comparison function that induces - //! the same strict weak ordering as value_compare. The difference is that - //! key_value_comp compares an arbitrary key with the contained values. - //! - //! <b>Effects</b>: Checks if a value can be inserted in the splay_set, using - //! a user provided key instead of the value itself, using "hint" - //! as a hint to where it will be inserted. - //! - //! <b>Returns</b>: If there is an equivalent value - //! returns a pair containing an iterator to the already present value - //! and false. If the value can be inserted returns true in the returned - //! pair boolean and fills "commit_data" that is meant to be used with - //! the "insert_commit" function. - //! - //! <b>Complexity</b>: Amortized logarithmic in general, but it's amortized - //! constant time if t is inserted immediately before hint. - //! - //! <b>Throws</b>: If the key_value_comp ordering function throws. Strong guarantee. - //! - //! <b>Notes</b>: This function is used to improve performance when constructing - //! a value_type is expensive: if there is an equivalent value - //! the constructed object must be discarded. Many times, the part of the - //! constructing that is used to impose the order is much cheaper to construct - //! than the value_type and this function offers the possibility to use that key - //! to check if the insertion will be successful. - //! - //! If the check is successful, the user can construct the value_type and use - //! "insert_commit" to insert the object in constant-time. This can give a total - //! constant-time complexity to the insertion: check(O(1)) + commit(O(1)). - //! - //! "commit_data" remains valid for a subsequent "insert_commit" only if no more - //! objects are inserted or erased from the splay_set. - template<class KeyType, class KeyValueCompare> - std::pair<iterator, bool> insert_check - (const_iterator hint, const KeyType &key - ,KeyValueCompare key_value_comp, insert_commit_data &commit_data) - { return tree_.insert_unique_check(hint, key, key_value_comp, commit_data); } - - //! <b>Requires</b>: value must be an lvalue of type value_type. commit_data - //! must have been obtained from a previous call to "insert_check". - //! No objects should have been inserted or erased from the splay_set between - //! the "insert_check" that filled "commit_data" and the call to "insert_commit". - //! - //! <b>Effects</b>: Inserts the value in the splay_set using the information obtained - //! from the "commit_data" that a previous "insert_check" filled. - //! - //! <b>Returns</b>: An iterator to the newly inserted object. - //! - //! <b>Complexity</b>: Constant time. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Notes</b>: This function has only sense if a "insert_check" has been - //! previously executed to fill "commit_data". No value should be inserted or - //! erased between the "insert_check" and "insert_commit" calls. - iterator insert_commit(reference value, const insert_commit_data &commit_data) - { return tree_.insert_unique_commit(value, commit_data); } - - //! <b>Requires</b>: Dereferencing iterator must yield an lvalue - //! of type value_type. - //! - //! <b>Effects</b>: Inserts a range into the splay_set. - //! - //! <b>Complexity</b>: Insert range is amortized O(N * log(N)), where N is the - //! size of the range. However, it is linear in N if the range is already sorted - //! by value_comp(). - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. Basic guarantee. - //! - //! <b>Note</b>: Does not affect the validity of iterators and references. - //! No copy-constructors are called. - template<class Iterator> - void insert(Iterator b, Iterator e) - { tree_.insert_unique(b, e); } - - //! <b>Effects</b>: Erases the element pointed to by pos. - //! - //! <b>Complexity</b>: Average complexity is constant time. - //! - //! <b>Returns</b>: An iterator to the element after the erased element. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - iterator erase(const_iterator i) - { return tree_.erase(i); } - - //! <b>Effects</b>: Erases the range pointed to by b end e. - //! - //! <b>Complexity</b>: Average complexity for erase range is amortized - //! O(log(size() + N)), where N is the number of elements in the range. - //! - //! <b>Returns</b>: An iterator to the element after the erased elements. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - iterator erase(const_iterator b, const_iterator e) - { return tree_.erase(b, e); } - - //! <b>Effects</b>: Erases all the elements with the given value. - //! - //! <b>Returns</b>: The number of erased elements. - //! - //! <b>Complexity</b>: Amortized O(log(size()) + this->count(value)). - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. Basic guarantee. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - size_type erase(const_reference value) - { return tree_.erase(value); } - - //! <b>Effects</b>: Erases all the elements that compare equal with - //! the given key and the given comparison functor. - //! - //! <b>Returns</b>: The number of erased elements. - //! - //! <b>Complexity</b>: Amortized O(log(size() + this->count(key, comp)). - //! - //! <b>Throws</b>: If the comp ordering function throws. Basic guarantee. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - template<class KeyType, class KeyValueCompare> - size_type erase(const KeyType& key, KeyValueCompare comp - /// @cond - , typename detail::enable_if_c<!detail::is_convertible<KeyValueCompare, const_iterator>::value >::type * = 0 - /// @endcond - ) - { return tree_.erase(key, comp); } - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! - //! <b>Effects</b>: Erases the element pointed to by pos. - //! Disposer::operator()(pointer) is called for the removed element. - //! - //! <b>Complexity</b>: Average complexity for erase element is constant time. - //! - //! <b>Returns</b>: An iterator to the element after the erased element. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators - //! to the erased elements. - template<class Disposer> - iterator erase_and_dispose(const_iterator i, Disposer disposer) - { return tree_.erase_and_dispose(i, disposer); } - - #if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) - template<class Disposer> - iterator erase_and_dispose(iterator i, Disposer disposer) - { return this->erase_and_dispose(const_iterator(i), disposer); } - #endif - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! - //! <b>Effects</b>: Erases the range pointed to by b end e. - //! Disposer::operator()(pointer) is called for the removed elements. - //! - //! <b>Complexity</b>: Average complexity for erase range is at most - //! O(log(size() + N)), where N is the number of elements in the range. - //! - //! <b>Returns</b>: An iterator to the element after the erased elements. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators - //! to the erased elements. - template<class Disposer> - iterator erase_and_dispose(const_iterator b, const_iterator e, Disposer disposer) - { return tree_.erase_and_dispose(b, e, disposer); } - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! - //! <b>Effects</b>: Erases all the elements with the given value. - //! Disposer::operator()(pointer) is called for the removed elements. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. - //! - //! <b>Complexity</b>: Amortized O(log(size() + this->count(value)). Basic guarantee. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - template<class Disposer> - size_type erase_and_dispose(const_reference value, Disposer disposer) - { return tree_.erase_and_dispose(value, disposer); } - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! - //! <b>Effects</b>: Erases all the elements with the given key. - //! according to the comparison functor "comp". - //! Disposer::operator()(pointer) is called for the removed elements. - //! - //! <b>Returns</b>: The number of erased elements. - //! - //! <b>Complexity</b>: Amortized O(log(size() + this->count(key, comp)). - //! - //! <b>Throws</b>: If comp ordering function throws. Basic guarantee. - //! - //! <b>Note</b>: Invalidates the iterators - //! to the erased elements. - template<class KeyType, class KeyValueCompare, class Disposer> - size_type erase_and_dispose(const KeyType& key, KeyValueCompare comp, Disposer disposer - /// @cond - , typename detail::enable_if_c<!detail::is_convertible<KeyValueCompare, const_iterator>::value >::type * = 0 - /// @endcond - ) - { return tree_.erase_and_dispose(key, comp, disposer); } - - //! <b>Effects</b>: Erases all the elements of the container. - //! - //! <b>Complexity</b>: Linear to the number of elements on the container. - //! if it's a safe-mode or auto-unlink value_type. Constant time otherwise. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - void clear() - { return tree_.clear(); } - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! - //! <b>Effects</b>: Erases all the elements of the container. - //! - //! <b>Complexity</b>: Linear to the number of elements on the container. - //! Disposer::operator()(pointer) is called for the removed elements. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - template<class Disposer> - void clear_and_dispose(Disposer disposer) - { return tree_.clear_and_dispose(disposer); } - - //! <b>Effects</b>: Returns the number of contained elements with the given key - //! - //! <b>Complexity</b>: Amortized logarithmic to the number of elements contained plus lineal - //! to number of objects with the given key. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. - size_type count(const_reference value) - { return tree_.find(value) != end(); } - - //! <b>Effects</b>: Returns the number of contained elements with the same key - //! compared with the given comparison functor. - //! - //! <b>Complexity</b>: Amortized logarithmic to the number of elements contained plus lineal - //! to number of objects with the given key. - //! - //! <b>Throws</b>: If comp ordering function throws. - template<class KeyType, class KeyValueCompare> - size_type count(const KeyType& key, KeyValueCompare comp) - { return tree_.find(key, comp) != end(); } - - //! <b>Effects</b>: Returns the number of contained elements with the given key - //! - //! <b>Complexity</b>: Logarithmic to the number of elements contained plus lineal - //! to number of objects with the given key. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. - size_type count_dont_splay(const_reference value)const - { return tree_.find_dont_splay(value) != end(); } - - //! <b>Effects</b>: Returns the number of contained elements with the same key - //! compared with the given comparison functor. - //! - //! <b>Complexity</b>: Logarithmic to the number of elements contained plus lineal - //! to number of objects with the given key. - //! - //! <b>Throws</b>: If comp ordering function throws. - template<class KeyType, class KeyValueCompare> - size_type count_dont_splay(const KeyType& key, KeyValueCompare comp)const - { return tree_.find_dont_splay(key, comp) != end(); } - - //! <b>Effects</b>: Returns an iterator to the first element whose - //! key is not less than k or end() if that element does not exist. - //! - //! <b>Complexity</b>: Amortized logarithmic. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. - iterator lower_bound(const_reference value) - { return tree_.lower_bound(value); } - - //! <b>Requires</b>: comp must imply the same element order as - //! value_compare. Usually key is the part of the value_type - //! that is used in the ordering functor. - //! - //! <b>Effects</b>: Returns an iterator to the first element whose - //! key according to the comparison functor is not less than k or - //! end() if that element does not exist. - //! - //! <b>Complexity</b>: Amortized logarithmic. - //! - //! <b>Throws</b>: If comp ordering function throws. - //! - //! <b>Note</b>: This function is used when constructing a value_type - //! is expensive and the value_type can be compared with a cheaper - //! key type. Usually this key is part of the value_type. - template<class KeyType, class KeyValueCompare> - iterator lower_bound(const KeyType& key, KeyValueCompare comp) - { return tree_.lower_bound(key, comp); } - - //! <b>Effects</b>: Returns a const iterator to the first element whose - //! key is not less than k or end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. - const_iterator lower_bound_dont_splay(const_reference value) const - { return tree_.lower_bound_dont_splay(value); } - - //! <b>Requires</b>: comp must imply the same element order as - //! value_compare. Usually key is the part of the value_type - //! that is used in the ordering functor. - //! - //! <b>Effects</b>: Returns a const_iterator to the first element whose - //! key according to the comparison functor is not less than k or - //! end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If comp ordering function throws. - //! - //! <b>Note</b>: This function is used when constructing a value_type - //! is expensive and the value_type can be compared with a cheaper - //! key type. Usually this key is part of the value_type. - template<class KeyType, class KeyValueCompare> - const_iterator lower_bound_dont_splay(const KeyType& key, KeyValueCompare comp) const - { return tree_.lower_bound_dont_splay(key, comp); } - - //! <b>Effects</b>: Returns an iterator to the first element whose - //! key is greater than k or end() if that element does not exist. - //! - //! <b>Complexity</b>: Amortized logarithmic. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. - iterator upper_bound(const_reference value) - { return tree_.upper_bound(value); } - - //! <b>Requires</b>: comp must imply the same element order as - //! value_compare. Usually key is the part of the value_type - //! that is used in the ordering functor. - //! - //! <b>Effects</b>: Returns an iterator to the first element whose - //! key according to the comparison functor is greater than key or - //! end() if that element does not exist. - //! - //! <b>Complexity</b>: Amortized logarithmic. - //! - //! <b>Throws</b>: If comp ordering function throws. - //! - //! <b>Note</b>: This function is used when constructing a value_type - //! is expensive and the value_type can be compared with a cheaper - //! key type. Usually this key is part of the value_type. - template<class KeyType, class KeyValueCompare> - iterator upper_bound(const KeyType& key, KeyValueCompare comp) - { return tree_.upper_bound(key, comp); } - - //! <b>Effects</b>: Returns an iterator to the first element whose - //! key is greater than k or end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. - const_iterator upper_bound_dont_splay(const_reference value) const - { return tree_.upper_bound_dont_splay(value); } - - //! <b>Requires</b>: comp must imply the same element order as - //! value_compare. Usually key is the part of the value_type - //! that is used in the ordering functor. - //! - //! <b>Effects</b>: Returns a const_iterator to the first element whose - //! key according to the comparison functor is greater than key or - //! end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If comp ordering function throws. - //! - //! <b>Note</b>: This function is used when constructing a value_type - //! is expensive and the value_type can be compared with a cheaper - //! key type. Usually this key is part of the value_type. - template<class KeyType, class KeyValueCompare> - const_iterator upper_bound_dont_splay(const KeyType& key, KeyValueCompare comp) const - { return tree_.upper_bound_dont_splay(key, comp); } - - //! <b>Effects</b>: Finds an iterator to the first element whose value is - //! "value" or end() if that element does not exist. - //! - //! <b>Complexity</b>: Amortized logarithmic. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. - iterator find(const_reference value) - { return tree_.find(value); } - - //! <b>Requires</b>: comp must imply the same element order as - //! value_compare. Usually key is the part of the value_type - //! that is used in the ordering functor. - //! - //! <b>Effects</b>: Finds an iterator to the first element whose key is - //! "key" according to the comparison functor or end() if that element - //! does not exist. - //! - //! <b>Complexity</b>: Amortized logarithmic. - //! - //! <b>Throws</b>: If comp ordering function throws. - //! - //! <b>Note</b>: This function is used when constructing a value_type - //! is expensive and the value_type can be compared with a cheaper - //! key type. Usually this key is part of the value_type. - template<class KeyType, class KeyValueCompare> - iterator find(const KeyType& key, KeyValueCompare comp) - { return tree_.find(key, comp); } - - //! <b>Effects</b>: Finds a const_iterator to the first element whose value is - //! "value" or end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. - const_iterator find_dont_splay(const_reference value) const - { return tree_.find_dont_splay(value); } - - //! <b>Requires</b>: comp must imply the same element order as - //! value_compare. Usually key is the part of the value_type - //! that is used in the ordering functor. - //! - //! <b>Effects</b>: Finds a const_iterator to the first element whose key is - //! "key" according to the comparison functor or end() if that element - //! does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If comp ordering function throws. - //! - //! <b>Note</b>: This function is used when constructing a value_type - //! is expensive and the value_type can be compared with a cheaper - //! key type. Usually this key is part of the value_type. - template<class KeyType, class KeyValueCompare> - const_iterator find_dont_splay(const KeyType& key, KeyValueCompare comp) const - { return tree_.find_dont_splay(key, comp); } - - //! <b>Effects</b>: Finds a range containing all elements whose key is k or - //! an empty range that indicates the position where those elements would be - //! if they there is no elements with key k. - //! - //! <b>Complexity</b>: Amortized logarithmic. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. - std::pair<iterator,iterator> equal_range(const_reference value) - { return tree_.equal_range(value); } - - //! <b>Requires</b>: comp must imply the same element order as - //! value_compare. Usually key is the part of the value_type - //! that is used in the ordering functor. - //! - //! <b>Effects</b>: Finds a range containing all elements whose key is k - //! according to the comparison functor or an empty range - //! that indicates the position where those elements would be - //! if they there is no elements with key k. - //! - //! <b>Complexity</b>: Amortized logarithmic. - //! - //! <b>Throws</b>: If comp ordering function throws. - //! - //! <b>Note</b>: This function is used when constructing a value_type - //! is expensive and the value_type can be compared with a cheaper - //! key type. Usually this key is part of the value_type. - template<class KeyType, class KeyValueCompare> - std::pair<iterator,iterator> equal_range(const KeyType& key, KeyValueCompare comp) - { return tree_.equal_range(key, comp); } - - //! <b>Effects</b>: Finds a range containing all elements whose key is k or - //! an empty range that indicates the position where those elements would be - //! if they there is no elements with key k. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. - std::pair<const_iterator, const_iterator> - equal_range_dont_splay(const_reference value) const - { return tree_.equal_range_dont_splay(value); } - - //! <b>Requires</b>: comp must imply the same element order as - //! value_compare. Usually key is the part of the value_type - //! that is used in the ordering functor. - //! - //! <b>Effects</b>: Finds a range containing all elements whose key is k - //! according to the comparison functor or an empty range - //! that indicates the position where those elements would be - //! if they there is no elements with key k. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If comp ordering function throws. - //! - //! <b>Note</b>: This function is used when constructing a value_type - //! is expensive and the value_type can be compared with a cheaper - //! key type. Usually this key is part of the value_type. - template<class KeyType, class KeyValueCompare> - std::pair<const_iterator, const_iterator> - equal_range_dont_splay(const KeyType& key, KeyValueCompare comp) const - { return tree_.equal_range_dont_splay(key, comp); } - - //! <b>Requires</b>: value must be an lvalue and shall be in a splay_set of - //! appropriate type. Otherwise the behavior is undefined. - //! - //! <b>Effects</b>: Returns: a valid iterator i belonging to the splay_set - //! that points to the value - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: This static function is available only if the <i>value traits</i> - //! is stateless. - static iterator s_iterator_to(reference value) - { return tree_type::s_iterator_to(value); } - - //! <b>Requires</b>: value must be an lvalue and shall be in a splay_set of - //! appropriate type. Otherwise the behavior is undefined. - //! - //! <b>Effects</b>: Returns: a valid const_iterator i belonging to the - //! splay_set that points to the value - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: This static function is available only if the <i>value traits</i> - //! is stateless. - static const_iterator s_iterator_to(const_reference value) - { return tree_type::s_iterator_to(value); } - - //! <b>Requires</b>: value must be an lvalue and shall be in a splay_set of - //! appropriate type. Otherwise the behavior is undefined. - //! - //! <b>Effects</b>: Returns: a valid iterator i belonging to the splay_set - //! that points to the value - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - iterator iterator_to(reference value) - { return tree_.iterator_to(value); } - - //! <b>Requires</b>: value must be an lvalue and shall be in a splay_set of - //! appropriate type. Otherwise the behavior is undefined. - //! - //! <b>Effects</b>: Returns: a valid const_iterator i belonging to the - //! splay_set that points to the value - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_iterator iterator_to(const_reference value) const - { return tree_.iterator_to(value); } - - //! <b>Requires</b>: value shall not be in a splay_set/multisplay_set. - //! - //! <b>Effects</b>: init_node puts the hook of a value in a well-known default - //! state. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant time. - //! - //! <b>Note</b>: This function puts the hook in the well-known default state - //! used by auto_unlink and safe hooks. - static void init_node(reference value) - { tree_type::init_node(value); } - - //! <b>Effects</b>: Unlinks the leftmost node from the tree. - //! - //! <b>Complexity</b>: Average complexity is constant time. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Notes</b>: This function breaks the tree and the tree can - //! only be used for more unlink_leftmost_without_rebalance calls. - //! This function is normally used to achieve a step by step - //! controlled destruction of the tree. - pointer unlink_leftmost_without_rebalance() - { return tree_.unlink_leftmost_without_rebalance(); } - - //! <b>Requires</b>: replace_this must be a valid iterator of *this - //! and with_this must not be inserted in any tree. - //! - //! <b>Effects</b>: Replaces replace_this in its position in the - //! tree with with_this. The tree does not need to be rebalanced. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: This function will break container ordering invariants if - //! with_this is not equivalent to *replace_this according to the - //! ordering rules. This function is faster than erasing and inserting - //! the node, since no rebalancing or comparison is needed. - void replace_node(iterator replace_this, reference with_this) - { tree_.replace_node(replace_this, with_this); } - - //! <b>Requires</b>: i must be a valid iterator of *this. - //! - //! <b>Effects</b>: Rearranges the splay set so that the element pointed by i - //! is placed as the root of the tree, improving future searches of this value. - //! - //! <b>Complexity</b>: Amortized logarithmic. - //! - //! <b>Throws</b>: Nothing. - void splay_up(iterator i) - { tree_.splay_up(i); } - - //! <b>Effects</b>: Rearranges the splay set so that if *this stores an element - //! with a key equivalent to value the element is placed as the root of the - //! tree. If the element is not present returns the last node compared with the key. - //! If the tree is empty, end() is returned. - //! - //! <b>Complexity</b>: Amortized logarithmic. - //! - //! <b>Returns</b>: An iterator to the new root of the tree, end() if the tree is empty. - //! - //! <b>Throws</b>: If the comparison functor throws. - template<class KeyType, class KeyNodePtrCompare> - iterator splay_down(const KeyType &key, KeyNodePtrCompare comp) - { return tree_.splay_down(key, comp); } - - //! <b>Effects</b>: Rearranges the splay set so that if *this stores an element - //! with a key equivalent to value the element is placed as the root of the - //! tree. - //! - //! <b>Complexity</b>: Amortized logarithmic. - //! - //! <b>Returns</b>: An iterator to the new root of the tree, end() if the tree is empty. - //! - //! <b>Throws</b>: If the predicate throws. - iterator splay_down(const value_type &value) - { return tree_.splay_down(value); } - - //! <b>Effects</b>: Rebalances the tree. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Linear. - void rebalance() - { tree_.rebalance(); } - - //! <b>Requires</b>: old_root is a node of a tree. - //! - //! <b>Effects</b>: Rebalances the subtree rooted at old_root. - //! - //! <b>Returns</b>: The new root of the subtree. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Linear to the elements in the subtree. - iterator rebalance_subtree(iterator root) - { return tree_.rebalance_subtree(root); } - - /// @cond - friend bool operator==(const splay_set_impl &x, const splay_set_impl &y) - { return x.tree_ == y.tree_; } - - friend bool operator<(const splay_set_impl &x, const splay_set_impl &y) - { return x.tree_ < y.tree_; } - /// @endcond -}; - -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -inline bool operator!= -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -(const splay_set_impl<T, Options...> &x, const splay_set_impl<T, Options...> &y) -#else -(const splay_set_impl<Config> &x, const splay_set_impl<Config> &y) -#endif -{ return !(x == y); } - -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -inline bool operator> -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -(const splay_set_impl<T, Options...> &x, const splay_set_impl<T, Options...> &y) -#else -(const splay_set_impl<Config> &x, const splay_set_impl<Config> &y) -#endif -{ return y < x; } - -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -inline bool operator<= -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -(const splay_set_impl<T, Options...> &x, const splay_set_impl<T, Options...> &y) -#else -(const splay_set_impl<Config> &x, const splay_set_impl<Config> &y) -#endif -{ return !(y < x); } - -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -inline bool operator>= -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -(const splay_set_impl<T, Options...> &x, const splay_set_impl<T, Options...> &y) -#else -(const splay_set_impl<Config> &x, const splay_set_impl<Config> &y) -#endif -{ return !(x < y); } - -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -inline void swap -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -(splay_set_impl<T, Options...> &x, splay_set_impl<T, Options...> &y) -#else -(splay_set_impl<Config> &x, splay_set_impl<Config> &y) -#endif -{ x.swap(y); } - -//! Helper metafunction to define a \c splay_set that yields to the same type when the -//! same options (either explicitly or implicitly) are used. -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) || defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template<class T, class ...Options> -#else -template<class T, class O1 = none, class O2 = none - , class O3 = none, class O4 = none> -#endif -struct make_splay_set -{ - /// @cond - typedef splay_set_impl - < typename make_splaytree_opt<T, - #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) - O1, O2, O3, O4 - #else - Options... - #endif - >::type - > implementation_defined; - /// @endcond - typedef implementation_defined type; -}; - -#ifndef BOOST_INTRUSIVE_DOXYGEN_INVOKED -#if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template<class T, class O1, class O2, class O3, class O4> -#else -template<class T, class ...Options> -#endif -class splay_set - : public make_splay_set<T, - #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) - O1, O2, O3, O4 - #else - Options... - #endif - >::type -{ - typedef typename make_splay_set - <T, - #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) - O1, O2, O3, O4 - #else - Options... - #endif - >::type Base; - BOOST_MOVABLE_BUT_NOT_COPYABLE(splay_set) - - public: - typedef typename Base::value_compare value_compare; - typedef typename Base::value_traits value_traits; - typedef typename Base::iterator iterator; - typedef typename Base::const_iterator const_iterator; - - //Assert if passed value traits are compatible with the type - BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value)); - - splay_set( const value_compare &cmp = value_compare() - , const value_traits &v_traits = value_traits()) - : Base(cmp, v_traits) - {} - - template<class Iterator> - splay_set( Iterator b, Iterator e - , const value_compare &cmp = value_compare() - , const value_traits &v_traits = value_traits()) - : Base(b, e, cmp, v_traits) - {} - - splay_set(BOOST_RV_REF(splay_set) x) - : Base(::boost::move(static_cast<Base&>(x))) - {} - - splay_set& operator=(BOOST_RV_REF(splay_set) x) - { this->Base::operator=(::boost::move(static_cast<Base&>(x))); return *this; } - - static splay_set &container_from_end_iterator(iterator end_iterator) - { return static_cast<splay_set &>(Base::container_from_end_iterator(end_iterator)); } - - static const splay_set &container_from_end_iterator(const_iterator end_iterator) - { return static_cast<const splay_set &>(Base::container_from_end_iterator(end_iterator)); } - - static splay_set &container_from_iterator(iterator it) - { return static_cast<splay_set &>(Base::container_from_iterator(it)); } - - static const splay_set &container_from_iterator(const_iterator it) - { return static_cast<const splay_set &>(Base::container_from_iterator(it)); } -}; - -#endif - -//! The class template splay_multiset is an intrusive container, that mimics most of -//! the interface of std::multiset as described in the C++ standard. -//! -//! The template parameter \c T is the type to be managed by the container. -//! The user can specify additional options and if no options are provided -//! default options are used. -//! -//! The container supports the following options: -//! \c base_hook<>/member_hook<>/value_traits<>, -//! \c constant_time_size<>, \c size_type<> and -//! \c compare<>. -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -class splay_multiset_impl -{ - /// @cond - typedef splaytree_impl<Config> tree_type; - - //Movable - BOOST_MOVABLE_BUT_NOT_COPYABLE(splay_multiset_impl) - typedef tree_type implementation_defined; - /// @endcond - - public: - typedef typename implementation_defined::value_type value_type; - typedef typename implementation_defined::value_traits value_traits; - typedef typename implementation_defined::pointer pointer; - typedef typename implementation_defined::const_pointer const_pointer; - typedef typename implementation_defined::reference reference; - typedef typename implementation_defined::const_reference const_reference; - typedef typename implementation_defined::difference_type difference_type; - typedef typename implementation_defined::size_type size_type; - typedef typename implementation_defined::value_compare value_compare; - typedef typename implementation_defined::key_compare key_compare; - typedef typename implementation_defined::iterator iterator; - typedef typename implementation_defined::const_iterator const_iterator; - typedef typename implementation_defined::reverse_iterator reverse_iterator; - typedef typename implementation_defined::const_reverse_iterator const_reverse_iterator; - typedef typename implementation_defined::insert_commit_data insert_commit_data; - typedef typename implementation_defined::node_traits node_traits; - typedef typename implementation_defined::node node; - typedef typename implementation_defined::node_ptr node_ptr; - typedef typename implementation_defined::const_node_ptr const_node_ptr; - typedef typename implementation_defined::node_algorithms node_algorithms; - - static const bool constant_time_size = Config::constant_time_size; - - /// @cond - private: - tree_type tree_; - /// @endcond - - public: - //! <b>Effects</b>: Constructs an empty splay_multiset. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: If value_traits::node_traits::node - //! constructor throws (this does not happen with predefined Boost.Intrusive hooks) - //! or the copy constructor/operator() of the value_compare object throws. - splay_multiset_impl( const value_compare &cmp = value_compare() - , const value_traits &v_traits = value_traits()) - : tree_(cmp, v_traits) - {} - - //! <b>Requires</b>: Dereferencing iterator must yield an lvalue of type value_type. - //! cmp must be a comparison function that induces a strict weak ordering. - //! - //! <b>Effects</b>: Constructs an empty splay_multiset and inserts elements from - //! [b, e). - //! - //! <b>Complexity</b>: Linear in N if [b, e) is already sorted using - //! comp and otherwise amortized N * log N, where N is the distance between first and last. - //! - //! <b>Throws</b>: If value_traits::node_traits::node - //! constructor throws (this does not happen with predefined Boost.Intrusive hooks) - //! or the copy constructor/operator() of the value_compare object throws. - template<class Iterator> - splay_multiset_impl( Iterator b, Iterator e - , const value_compare &cmp = value_compare() - , const value_traits &v_traits = value_traits()) - : tree_(false, b, e, cmp, v_traits) - {} - - //! <b>Effects</b>: to-do - //! - splay_multiset_impl(BOOST_RV_REF(splay_multiset_impl) x) - : tree_(::boost::move(x.tree_)) - {} - - //! <b>Effects</b>: to-do - //! - splay_multiset_impl& operator=(BOOST_RV_REF(splay_multiset_impl) x) - { tree_ = ::boost::move(x.tree_); return *this; } - - //! <b>Effects</b>: Detaches all elements from this. The objects in the set - //! are not deleted (i.e. no destructors are called). - //! - //! <b>Complexity</b>: Linear to the number of elements on the container. - //! if it's a safe-mode or auto-unlink value_type. Constant time otherwise. - //! - //! <b>Throws</b>: Nothing. - ~splay_multiset_impl() - {} - - //! <b>Effects</b>: Returns an iterator pointing to the beginning of the splay_multiset. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - iterator begin() - { return tree_.begin(); } - - //! <b>Effects</b>: Returns a const_iterator pointing to the beginning of the splay_multiset. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_iterator begin() const - { return tree_.begin(); } - - //! <b>Effects</b>: Returns a const_iterator pointing to the beginning of the splay_multiset. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_iterator cbegin() const - { return tree_.cbegin(); } - - //! <b>Effects</b>: Returns an iterator pointing to the end of the splay_multiset. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - iterator end() - { return tree_.end(); } - - //! <b>Effects</b>: Returns a const_iterator pointing to the end of the splay_multiset. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_iterator end() const - { return tree_.end(); } - - //! <b>Effects</b>: Returns a const_iterator pointing to the end of the splay_multiset. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_iterator cend() const - { return tree_.cend(); } - - //! <b>Effects</b>: Returns a reverse_iterator pointing to the beginning of the - //! reversed splay_multiset. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - reverse_iterator rbegin() - { return tree_.rbegin(); } - - //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning - //! of the reversed splay_multiset. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_reverse_iterator rbegin() const - { return tree_.rbegin(); } - - //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning - //! of the reversed splay_multiset. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_reverse_iterator crbegin() const - { return tree_.crbegin(); } - - //! <b>Effects</b>: Returns a reverse_iterator pointing to the end - //! of the reversed splay_multiset. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - reverse_iterator rend() - { return tree_.rend(); } - - //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the end - //! of the reversed splay_multiset. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_reverse_iterator rend() const - { return tree_.rend(); } - - //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the end - //! of the reversed splay_multiset. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_reverse_iterator crend() const - { return tree_.crend(); } - - //! <b>Precondition</b>: end_iterator must be a valid end iterator - //! of splay_multiset. - //! - //! <b>Effects</b>: Returns a const reference to the splay_multiset associated to the end iterator - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - static splay_multiset_impl &container_from_end_iterator(iterator end_iterator) - { - return *detail::parent_from_member<splay_multiset_impl, tree_type> - ( &tree_type::container_from_end_iterator(end_iterator) - , &splay_multiset_impl::tree_); - } - - //! <b>Precondition</b>: end_iterator must be a valid end const_iterator - //! of splay_multiset. - //! - //! <b>Effects</b>: Returns a const reference to the splay_multiset associated to the end iterator - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - static const splay_multiset_impl &container_from_end_iterator(const_iterator end_iterator) - { - return *detail::parent_from_member<splay_multiset_impl, tree_type> - ( &tree_type::container_from_end_iterator(end_iterator) - , &splay_multiset_impl::tree_); - } - - //! <b>Precondition</b>: it must be a valid iterator of multiset. - //! - //! <b>Effects</b>: Returns a const reference to the multiset associated to the iterator - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Logarithmic. - static splay_multiset_impl &container_from_iterator(iterator it) - { - return *detail::parent_from_member<splay_multiset_impl, tree_type> - ( &tree_type::container_from_iterator(it) - , &splay_multiset_impl::tree_); - } - - //! <b>Precondition</b>: it must be a valid const_iterator of multiset. - //! - //! <b>Effects</b>: Returns a const reference to the multiset associated to the iterator - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - static const splay_multiset_impl &container_from_iterator(const_iterator it) - { - return *detail::parent_from_member<splay_multiset_impl, tree_type> - ( &tree_type::container_from_iterator(it) - , &splay_multiset_impl::tree_); - } - - //! <b>Effects</b>: Returns the key_compare object used by the splay_multiset. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: If key_compare copy-constructor throws. - key_compare key_comp() const - { return tree_.value_comp(); } - - //! <b>Effects</b>: Returns the value_compare object used by the splay_multiset. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: If value_compare copy-constructor throws. - value_compare value_comp() const - { return tree_.value_comp(); } - - //! <b>Effects</b>: Returns true if the container is empty. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - bool empty() const - { return tree_.empty(); } - - //! <b>Effects</b>: Returns the number of elements stored in the splay_multiset. - //! - //! <b>Complexity</b>: Linear to elements contained in *this if, - //! constant-time size option is enabled. Constant-time otherwise. - //! - //! <b>Throws</b>: Nothing. - size_type size() const - { return tree_.size(); } - - //! <b>Effects</b>: Swaps the contents of two splay_multisets. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: If the swap() call for the comparison functor - //! found using ADL throws. Strong guarantee. - void swap(splay_multiset_impl& other) - { tree_.swap(other.tree_); } - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! Cloner should yield to nodes equivalent to the original nodes. - //! - //! <b>Effects</b>: Erases all the elements from *this - //! calling Disposer::operator()(pointer), clones all the - //! elements from src calling Cloner::operator()(const_reference ) - //! and inserts them on *this. Copies the predicate from the source container. - //! - //! If cloner throws, all cloned elements are unlinked and disposed - //! calling Disposer::operator()(pointer). - //! - //! <b>Complexity</b>: Linear to erased plus inserted elements. - //! - //! <b>Throws</b>: If cloner throws or predicate copy assignment throws. Basic guarantee. - template <class Cloner, class Disposer> - void clone_from(const splay_multiset_impl &src, Cloner cloner, Disposer disposer) - { tree_.clone_from(src.tree_, cloner, disposer); } - - //! <b>Requires</b>: value must be an lvalue - //! - //! <b>Effects</b>: Inserts value into the splay_multiset. - //! - //! <b>Returns</b>: An iterator that points to the position where the new - //! element was inserted. - //! - //! <b>Complexity</b>: Amortized logarithmic. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. Strong guarantee. - //! - //! <b>Note</b>: Does not affect the validity of iterators and references. - //! No copy-constructors are called. - iterator insert(reference value) - { return tree_.insert_equal(this->end(), value); } - - //! <b>Requires</b>: value must be an lvalue - //! - //! <b>Effects</b>: Inserts x into the splay_multiset, using pos as a hint to - //! where it will be inserted. - //! - //! <b>Returns</b>: An iterator that points to the position where the new - //! element was inserted. - //! - //! <b>Complexity</b>: Amortized logarithmic in general, but it is amortized - //! constant time if t is inserted immediately before hint. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. Strong guarantee. - //! - //! <b>Note</b>: Does not affect the validity of iterators and references. - //! No copy-constructors are called. - iterator insert(const_iterator hint, reference value) - { return tree_.insert_equal(hint, value); } - - //! <b>Requires</b>: Dereferencing iterator must yield an lvalue - //! of type value_type. - //! - //! <b>Effects</b>: Inserts a range into the splay_multiset. - //! - //! <b>Returns</b>: An iterator that points to the position where the new - //! element was inserted. - //! - //! <b>Complexity</b>: Insert range is amortized O(N * log(N)), where N is the - //! size of the range. However, it is linear in N if the range is already sorted - //! by value_comp(). - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. Basic guarantee. - //! - //! <b>Note</b>: Does not affect the validity of iterators and references. - //! No copy-constructors are called. - template<class Iterator> - void insert(Iterator b, Iterator e) - { tree_.insert_equal(b, e); } - - //! <b>Effects</b>: Erases the element pointed to by pos. - //! - //! <b>Complexity</b>: Average complexity is constant time. - //! - //! <b>Returns</b>: An iterator to the element after the erased element. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - iterator erase(const_iterator i) - { return tree_.erase(i); } - - //! <b>Effects</b>: Erases the range pointed to by b end e. - //! - //! <b>Returns</b>: An iterator to the element after the erased elements. - //! - //! <b>Complexity</b>: Average complexity for erase range is amortized - //! O(log(size() + N)), where N is the number of elements in the range. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - iterator erase(const_iterator b, const_iterator e) - { return tree_.erase(b, e); } - - //! <b>Effects</b>: Erases all the elements with the given value. - //! - //! <b>Returns</b>: The number of erased elements. - //! - //! <b>Complexity</b>: Amortized O(log(size() + this->count(value)). - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. Basic guarantee. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - size_type erase(const_reference value) - { return tree_.erase(value); } - - //! <b>Effects</b>: Erases all the elements that compare equal with - //! the given key and the given comparison functor. - //! - //! <b>Returns</b>: The number of erased elements. - //! - //! <b>Complexity</b>: Amortized O(log(size() + this->count(key, comp)). - //! - //! <b>Throws</b>: If comp ordering function throws. Basic guarantee. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - template<class KeyType, class KeyValueCompare> - size_type erase(const KeyType& key, KeyValueCompare comp - /// @cond - , typename detail::enable_if_c<!detail::is_convertible<KeyValueCompare, const_iterator>::value >::type * = 0 - /// @endcond - ) - { return tree_.erase(key, comp); } - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! - //! <b>Returns</b>: An iterator to the element after the erased element. - //! - //! <b>Effects</b>: Erases the element pointed to by pos. - //! Disposer::operator()(pointer) is called for the removed element. - //! - //! <b>Complexity</b>: Average complexity for erase element is constant time. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators - //! to the erased elements. - template<class Disposer> - iterator erase_and_dispose(const_iterator i, Disposer disposer) - { return tree_.erase_and_dispose(i, disposer); } - - #if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) - template<class Disposer> - iterator erase_and_dispose(iterator i, Disposer disposer) - { return this->erase_and_dispose(const_iterator(i), disposer); } - #endif - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! - //! <b>Returns</b>: An iterator to the element after the erased elements. - //! - //! <b>Effects</b>: Erases the range pointed to by b end e. - //! Disposer::operator()(pointer) is called for the removed elements. - //! - //! <b>Complexity</b>: Average complexity for erase range is amortized - //! O(log(size() + N)), where N is the number of elements in the range. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators - //! to the erased elements. - template<class Disposer> - iterator erase_and_dispose(const_iterator b, const_iterator e, Disposer disposer) - { return tree_.erase_and_dispose(b, e, disposer); } - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! - //! <b>Effects</b>: Erases all the elements with the given value. - //! Disposer::operator()(pointer) is called for the removed elements. - //! - //! <b>Returns</b>: The number of erased elements. - //! - //! <b>Complexity</b>: Amortized O(log(size() + this->count(value)). - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. Basic guarantee. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - template<class Disposer> - size_type erase_and_dispose(const_reference value, Disposer disposer) - { return tree_.erase_and_dispose(value, disposer); } - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! - //! <b>Effects</b>: Erases all the elements with the given key. - //! according to the comparison functor "comp". - //! Disposer::operator()(pointer) is called for the removed elements. - //! - //! <b>Returns</b>: The number of erased elements. - //! - //! <b>Complexity</b>: Amortized O(log(size() + this->count(key, comp)). - //! - //! <b>Throws</b>: If comp ordering function throws. Basic guarantee. - //! - //! <b>Note</b>: Invalidates the iterators - //! to the erased elements. - template<class KeyType, class KeyValueCompare, class Disposer> - size_type erase_and_dispose(const KeyType& key, KeyValueCompare comp, Disposer disposer - /// @cond - , typename detail::enable_if_c<!detail::is_convertible<KeyValueCompare, const_iterator>::value >::type * = 0 - /// @endcond - ) - { return tree_.erase_and_dispose(key, comp, disposer); } - - //! <b>Effects</b>: Erases all the elements of the container. - //! - //! <b>Complexity</b>: Linear to the number of elements on the container. - //! if it's a safe-mode or auto-unlink value_type. Constant time otherwise. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - void clear() - { return tree_.clear(); } - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! - //! <b>Effects</b>: Erases all the elements of the container. - //! - //! <b>Complexity</b>: Linear to the number of elements on the container. - //! Disposer::operator()(pointer) is called for the removed elements. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - template<class Disposer> - void clear_and_dispose(Disposer disposer) - { return tree_.clear_and_dispose(disposer); } - - //! <b>Effects</b>: Returns the number of contained elements with the given key - //! - //! <b>Complexity</b>: Amortized logarithmic to the number of elements contained plus lineal - //! to number of objects with the given key. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. - size_type count(const_reference value) - { return tree_.count(value); } - - //! <b>Effects</b>: Returns the number of contained elements with the same key - //! compared with the given comparison functor. - //! - //! <b>Complexity</b>: Amortized logarithmic to the number of elements contained plus lineal - //! to number of objects with the given key. - //! - //! <b>Throws</b>: If comp ordering function throws. - template<class KeyType, class KeyValueCompare> - size_type count(const KeyType& key, KeyValueCompare comp) - { return tree_.count(key, comp); } - - //! <b>Effects</b>: Returns the number of contained elements with the given key - //! - //! <b>Complexity</b>: Logarithmic to the number of elements contained plus lineal - //! to number of objects with the given key. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. - size_type count_dont_splay(const_reference value) const - { return tree_.count_dont_splay(value); } - - //! <b>Effects</b>: Returns the number of contained elements with the same key - //! compared with the given comparison functor. - //! - //! <b>Complexity</b>: Logarithmic to the number of elements contained plus lineal - //! to number of objects with the given key. - //! - //! <b>Throws</b>: If comp ordering function throws. - template<class KeyType, class KeyValueCompare> - size_type count_dont_splay(const KeyType& key, KeyValueCompare comp) const - { return tree_.count_dont_splay(key, comp); } - - //! <b>Effects</b>: Returns an iterator to the first element whose - //! key is not less than k or end() if that element does not exist. - //! - //! <b>Complexity</b>: Amortized logarithmic. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. - iterator lower_bound(const_reference value) - { return tree_.lower_bound(value); } - - //! <b>Requires</b>: comp must imply the same element order as - //! value_compare. Usually key is the part of the value_type - //! that is used in the ordering functor. - //! - //! <b>Effects</b>: Returns an iterator to the first element whose - //! key according to the comparison functor is not less than k or - //! end() if that element does not exist. - //! - //! <b>Complexity</b>: Amortized logarithmic. - //! - //! <b>Throws</b>: If comp ordering function throws. - //! - //! <b>Note</b>: This function is used when constructing a value_type - //! is expensive and the value_type can be compared with a cheaper - //! key type. Usually this key is part of the value_type. - template<class KeyType, class KeyValueCompare> - iterator lower_bound(const KeyType& key, KeyValueCompare comp) - { return tree_.lower_bound(key, comp); } - - //! <b>Effects</b>: Returns a const iterator to the first element whose - //! key is not less than k or end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. - const_iterator lower_bound_dont_splay(const_reference value) const - { return tree_.lower_bound_dont_splay(value); } - - //! <b>Requires</b>: comp must imply the same element order as - //! value_compare. Usually key is the part of the value_type - //! that is used in the ordering functor. - //! - //! <b>Effects</b>: Returns a const_iterator to the first element whose - //! key according to the comparison functor is not less than k or - //! end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If comp ordering function throws. - //! - //! <b>Note</b>: This function is used when constructing a value_type - //! is expensive and the value_type can be compared with a cheaper - //! key type. Usually this key is part of the value_type. - template<class KeyType, class KeyValueCompare> - const_iterator lower_bound_dont_splay(const KeyType& key, KeyValueCompare comp) const - { return tree_.lower_bound_dont_splay(key, comp); } - - //! <b>Effects</b>: Returns an iterator to the first element whose - //! key is greater than k or end() if that element does not exist. - //! - //! <b>Complexity</b>: Amortized logarithmic. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. - iterator upper_bound(const_reference value) - { return tree_.upper_bound(value); } - - //! <b>Requires</b>: comp must imply the same element order as - //! value_compare. Usually key is the part of the value_type - //! that is used in the ordering functor. - //! - //! <b>Effects</b>: Returns an iterator to the first element whose - //! key according to the comparison functor is greater than key or - //! end() if that element does not exist. - //! - //! <b>Complexity</b>: Amortized logarithmic. - //! - //! <b>Throws</b>: If comp ordering function throws. - //! - //! <b>Note</b>: This function is used when constructing a value_type - //! is expensive and the value_type can be compared with a cheaper - //! key type. Usually this key is part of the value_type. - template<class KeyType, class KeyValueCompare> - iterator upper_bound(const KeyType& key, KeyValueCompare comp) - { return tree_.upper_bound(key, comp); } - - //! <b>Effects</b>: Returns an iterator to the first element whose - //! key is greater than k or end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. - const_iterator upper_bound_dont_splay(const_reference value) const - { return tree_.upper_bound_dont_splay(value); } - - //! <b>Requires</b>: comp must imply the same element order as - //! value_compare. Usually key is the part of the value_type - //! that is used in the ordering functor. - //! - //! <b>Effects</b>: Returns a const_iterator to the first element whose - //! key according to the comparison functor is greater than key or - //! end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If comp ordering function throws. - //! - //! <b>Note</b>: This function is used when constructing a value_type - //! is expensive and the value_type can be compared with a cheaper - //! key type. Usually this key is part of the value_type. - template<class KeyType, class KeyValueCompare> - const_iterator upper_bound_dont_splay(const KeyType& key, KeyValueCompare comp) const - { return tree_.upper_bound_dont_splay(key, comp); } - - //! <b>Effects</b>: Finds an iterator to the first element whose value is - //! "value" or end() if that element does not exist. - //! - //! <b>Complexity</b>: Amortized logarithmic. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. - iterator find(const_reference value) - { return tree_.find(value); } - - //! <b>Requires</b>: comp must imply the same element order as - //! value_compare. Usually key is the part of the value_type - //! that is used in the ordering functor. - //! - //! <b>Effects</b>: Finds an iterator to the first element whose key is - //! "key" according to the comparison functor or end() if that element - //! does not exist. - //! - //! <b>Complexity</b>: Amortized logarithmic. - //! - //! <b>Throws</b>: If comp ordering function throws. - //! - //! <b>Note</b>: This function is used when constructing a value_type - //! is expensive and the value_type can be compared with a cheaper - //! key type. Usually this key is part of the value_type. - template<class KeyType, class KeyValueCompare> - iterator find(const KeyType& key, KeyValueCompare comp) - { return tree_.find(key, comp); } - - //! <b>Effects</b>: Finds a const_iterator to the first element whose value is - //! "value" or end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. - const_iterator find_dont_splay(const_reference value) const - { return tree_.find_dont_splay(value); } - - //! <b>Requires</b>: comp must imply the same element order as - //! value_compare. Usually key is the part of the value_type - //! that is used in the ordering functor. - //! - //! <b>Effects</b>: Finds a const_iterator to the first element whose key is - //! "key" according to the comparison functor or end() if that element - //! does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If comp ordering function throws. - //! - //! <b>Note</b>: This function is used when constructing a value_type - //! is expensive and the value_type can be compared with a cheaper - //! key type. Usually this key is part of the value_type. - template<class KeyType, class KeyValueCompare> - const_iterator find_dont_splay(const KeyType& key, KeyValueCompare comp) const - { return tree_.find_dont_splay(key, comp); } - - //! <b>Effects</b>: Finds a range containing all elements whose key is k or - //! an empty range that indicates the position where those elements would be - //! if they there is no elements with key k. - //! - //! <b>Complexity</b>: Amortized logarithmic. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. - std::pair<iterator,iterator> equal_range(const_reference value) - { return tree_.equal_range(value); } - - //! <b>Requires</b>: comp must imply the same element order as - //! value_compare. Usually key is the part of the value_type - //! that is used in the ordering functor. - //! - //! <b>Effects</b>: Finds a range containing all elements whose key is k - //! according to the comparison functor or an empty range - //! that indicates the position where those elements would be - //! if they there is no elements with key k. - //! - //! <b>Complexity</b>: Amortized logarithmic. - //! - //! <b>Throws</b>: If comp ordering function throws. - //! - //! <b>Note</b>: This function is used when constructing a value_type - //! is expensive and the value_type can be compared with a cheaper - //! key type. Usually this key is part of the value_type. - template<class KeyType, class KeyValueCompare> - std::pair<iterator,iterator> equal_range(const KeyType& key, KeyValueCompare comp) - { return tree_.equal_range(key, comp); } - - //! <b>Effects</b>: Finds a range containing all elements whose key is k or - //! an empty range that indicates the position where those elements would be - //! if they there is no elements with key k. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. - std::pair<const_iterator, const_iterator> - equal_range_dont_splay(const_reference value) const - { return tree_.equal_range_dont_splay(value); } - - //! <b>Requires</b>: comp must imply the same element order as - //! value_compare. Usually key is the part of the value_type - //! that is used in the ordering functor. - //! - //! <b>Effects</b>: Finds a range containing all elements whose key is k - //! according to the comparison functor or an empty range - //! that indicates the position where those elements would be - //! if they there is no elements with key k. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If comp ordering function throws. - //! - //! <b>Note</b>: This function is used when constructing a value_type - //! is expensive and the value_type can be compared with a cheaper - //! key type. Usually this key is part of the value_type. - template<class KeyType, class KeyValueCompare> - std::pair<const_iterator, const_iterator> - equal_range_dont_splay(const KeyType& key, KeyValueCompare comp) const - { return tree_.equal_range_dont_splay(key, comp); } - - //! <b>Requires</b>: value must be an lvalue and shall be in a set of - //! appropriate type. Otherwise the behavior is undefined. - //! - //! <b>Effects</b>: Returns: a valid iterator i belonging to the set - //! that points to the value - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: This static function is available only if the <i>value traits</i> - //! is stateless. - static iterator s_iterator_to(reference value) - { return tree_type::s_iterator_to(value); } - - //! <b>Requires</b>: value must be an lvalue and shall be in a set of - //! appropriate type. Otherwise the behavior is undefined. - //! - //! <b>Effects</b>: Returns: a valid const_iterator i belonging to the - //! set that points to the value - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: This static function is available only if the <i>value traits</i> - //! is stateless. - static const_iterator s_iterator_to(const_reference value) - { return tree_type::s_iterator_to(value); } - - //! <b>Requires</b>: value must be an lvalue and shall be in a set of - //! appropriate type. Otherwise the behavior is undefined. - //! - //! <b>Effects</b>: Returns: a valid iterator i belonging to the set - //! that points to the value - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - iterator iterator_to(reference value) - { return tree_.iterator_to(value); } - - //! <b>Requires</b>: value must be an lvalue and shall be in a set of - //! appropriate type. Otherwise the behavior is undefined. - //! - //! <b>Effects</b>: Returns: a valid const_iterator i belonging to the - //! set that points to the value - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_iterator iterator_to(const_reference value) const - { return tree_.iterator_to(value); } - - //! <b>Requires</b>: value shall not be in a set/splay_multiset. - //! - //! <b>Effects</b>: init_node puts the hook of a value in a well-known default - //! state. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant time. - //! - //! <b>Note</b>: This function puts the hook in the well-known default state - //! used by auto_unlink and safe hooks. - static void init_node(reference value) - { tree_type::init_node(value); } - - //! <b>Effects</b>: Unlinks the leftmost node from the tree. - //! - //! <b>Complexity</b>: Average complexity is constant time. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Notes</b>: This function breaks the tree and the tree can - //! only be used for more unlink_leftmost_without_rebalance calls. - //! This function is normally used to achieve a step by step - //! controlled destruction of the tree. - pointer unlink_leftmost_without_rebalance() - { return tree_.unlink_leftmost_without_rebalance(); } - - //! <b>Requires</b>: replace_this must be a valid iterator of *this - //! and with_this must not be inserted in any tree. - //! - //! <b>Effects</b>: Replaces replace_this in its position in the - //! tree with with_this. The tree does not need to be rebalanced. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: This function will break container ordering invariants if - //! with_this is not equivalent to *replace_this according to the - //! ordering rules. This function is faster than erasing and inserting - //! the node, since no rebalancing or comparison is needed. - void replace_node(iterator replace_this, reference with_this) - { tree_.replace_node(replace_this, with_this); } - - //! <b>Requires</b>: i must be a valid iterator of *this. - //! - //! <b>Effects</b>: Rearranges the splay set so that the element pointed by i - //! is placed as the root of the tree, improving future searches of this value. - //! - //! <b>Complexity</b>: Amortized logarithmic. - //! - //! <b>Throws</b>: Nothing. - void splay_up(iterator i) - { tree_.splay_up(i); } - - //! <b>Effects</b>: Rearranges the splay set so that if *this stores an element - //! with a key equivalent to value the element is placed as the root of the - //! tree. If the element is not present returns the last node compared with the key. - //! If the tree is empty, end() is returned. - //! - //! <b>Complexity</b>: Amortized logarithmic. - //! - //! <b>Returns</b>: An iterator to the new root of the tree, end() if the tree is empty. - //! - //! <b>Throws</b>: If the comparison functor throws. - template<class KeyType, class KeyNodePtrCompare> - iterator splay_down(const KeyType &key, KeyNodePtrCompare comp) - { return tree_.splay_down(key, comp); } - - //! <b>Effects</b>: Rearranges the splay set so that if *this stores an element - //! with a key equivalent to value the element is placed as the root of the - //! tree. - //! - //! <b>Complexity</b>: Amortized logarithmic. - //! - //! <b>Returns</b>: An iterator to the new root of the tree, end() if the tree is empty. - //! - //! <b>Throws</b>: If the predicate throws. - iterator splay_down(const value_type &value) - { return tree_.splay_down(value); } - - //! <b>Effects</b>: Rebalances the tree. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Linear. - void rebalance() - { tree_.rebalance(); } - - //! <b>Requires</b>: old_root is a node of a tree. - //! - //! <b>Effects</b>: Rebalances the subtree rooted at old_root. - //! - //! <b>Returns</b>: The new root of the subtree. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Linear to the elements in the subtree. - iterator rebalance_subtree(iterator root) - { return tree_.rebalance_subtree(root); } - - /// @cond - friend bool operator==(const splay_multiset_impl &x, const splay_multiset_impl &y) - { return x.tree_ == y.tree_; } - - friend bool operator<(const splay_multiset_impl &x, const splay_multiset_impl &y) - { return x.tree_ < y.tree_; } - /// @endcond -}; - -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -inline bool operator!= -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -(const splay_multiset_impl<T, Options...> &x, const splay_multiset_impl<T, Options...> &y) -#else -(const splay_multiset_impl<Config> &x, const splay_multiset_impl<Config> &y) -#endif -{ return !(x == y); } - -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -inline bool operator> -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -(const splay_multiset_impl<T, Options...> &x, const splay_multiset_impl<T, Options...> &y) -#else -(const splay_multiset_impl<Config> &x, const splay_multiset_impl<Config> &y) -#endif -{ return y < x; } - -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -inline bool operator<= -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -(const splay_multiset_impl<T, Options...> &x, const splay_multiset_impl<T, Options...> &y) -#else -(const splay_multiset_impl<Config> &x, const splay_multiset_impl<Config> &y) -#endif -{ return !(y < x); } - -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -inline bool operator>= -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -(const splay_multiset_impl<T, Options...> &x, const splay_multiset_impl<T, Options...> &y) -#else -(const splay_multiset_impl<Config> &x, const splay_multiset_impl<Config> &y) -#endif -{ return !(x < y); } - -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -inline void swap -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -(splay_multiset_impl<T, Options...> &x, splay_multiset_impl<T, Options...> &y) -#else -(splay_multiset_impl<Config> &x, splay_multiset_impl<Config> &y) -#endif -{ x.swap(y); } - -//! Helper metafunction to define a \c splay_multiset that yields to the same type when the -//! same options (either explicitly or implicitly) are used. -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) || defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template<class T, class ...Options> -#else -template<class T, class O1 = none, class O2 = none - , class O3 = none, class O4 = none> -#endif -struct make_splay_multiset -{ - /// @cond - typedef splay_multiset_impl - < typename make_splaytree_opt<T, - #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) - O1, O2, O3, O4 - #else - Options... - #endif - >::type - > implementation_defined; - /// @endcond - typedef implementation_defined type; -}; - -#ifndef BOOST_INTRUSIVE_DOXYGEN_INVOKED - -#if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template<class T, class O1, class O2, class O3, class O4> -#else -template<class T, class ...Options> -#endif -class splay_multiset - : public make_splay_multiset<T, - #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) - O1, O2, O3, O4 - #else - Options... - #endif - >::type -{ - typedef typename make_splay_multiset - <T, - #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) - O1, O2, O3, O4 - #else - Options... - #endif - >::type Base; - BOOST_MOVABLE_BUT_NOT_COPYABLE(splay_multiset) - - public: - typedef typename Base::value_compare value_compare; - typedef typename Base::value_traits value_traits; - typedef typename Base::iterator iterator; - typedef typename Base::const_iterator const_iterator; - - //Assert if passed value traits are compatible with the type - BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value)); - - splay_multiset( const value_compare &cmp = value_compare() - , const value_traits &v_traits = value_traits()) - : Base(cmp, v_traits) - {} - - template<class Iterator> - splay_multiset( Iterator b, Iterator e - , const value_compare &cmp = value_compare() - , const value_traits &v_traits = value_traits()) - : Base(b, e, cmp, v_traits) - {} - - splay_multiset(BOOST_RV_REF(splay_multiset) x) - : Base(::boost::move(static_cast<Base&>(x))) - {} - - splay_multiset& operator=(BOOST_RV_REF(splay_multiset) x) - { this->Base::operator=(::boost::move(static_cast<Base&>(x))); return *this; } - - static splay_multiset &container_from_end_iterator(iterator end_iterator) - { return static_cast<splay_multiset &>(Base::container_from_end_iterator(end_iterator)); } - - static const splay_multiset &container_from_end_iterator(const_iterator end_iterator) - { return static_cast<const splay_multiset &>(Base::container_from_end_iterator(end_iterator)); } - - static splay_multiset &container_from_iterator(iterator it) - { return static_cast<splay_multiset &>(Base::container_from_iterator(it)); } - - static const splay_multiset &container_from_iterator(const_iterator it) - { return static_cast<const splay_multiset &>(Base::container_from_iterator(it)); } -}; - -#endif - -} //namespace intrusive -} //namespace boost - -#include <boost/intrusive/detail/config_end.hpp> - -#endif //BOOST_INTRUSIVE_SPLAY_SET_HPP diff --git a/src/third_party/boost/boost/intrusive/splay_set_hook.hpp b/src/third_party/boost/boost/intrusive/splay_set_hook.hpp deleted file mode 100644 index d42f4c8beea..00000000000 --- a/src/third_party/boost/boost/intrusive/splay_set_hook.hpp +++ /dev/null @@ -1,292 +0,0 @@ -///////////////////////////////////////////////////////////////////////////// -// -// (C) Copyright Olaf Krzikalla 2004-2006. -// (C) Copyright Ion Gaztanaga 2006-2009 -// -// Distributed under the Boost Software License, Version 1.0. -// (See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) -// -// See http://www.boost.org/libs/intrusive for documentation. -// -///////////////////////////////////////////////////////////////////////////// -#ifndef BOOST_INTRUSIVE_SPLAY_SET_HOOK_HPP -#define BOOST_INTRUSIVE_SPLAY_SET_HOOK_HPP - -#include <boost/intrusive/detail/config_begin.hpp> -#include <boost/intrusive/intrusive_fwd.hpp> -#include <boost/intrusive/detail/utilities.hpp> -#include <boost/intrusive/detail/tree_node.hpp> -#include <boost/intrusive/splaytree_algorithms.hpp> -#include <boost/intrusive/options.hpp> -#include <boost/intrusive/detail/generic_hook.hpp> - -namespace boost { -namespace intrusive { - -/// @cond -template<class VoidPointer> -struct get_splay_set_node_algo -{ - typedef splaytree_algorithms<tree_node_traits<VoidPointer> > type; -}; -/// @endcond - -//! Helper metafunction to define a \c splay_set_base_hook that yields to the same -//! type when the same options (either explicitly or implicitly) are used. -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) || defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template<class ...Options> -#else -template<class O1 = none, class O2 = none, class O3 = none> -#endif -struct make_splay_set_base_hook -{ - /// @cond - typedef typename pack_options - < hook_defaults, - #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) - O1, O2, O3 - #else - Options... - #endif - >::type packed_options; - - typedef detail::generic_hook - < get_splay_set_node_algo<typename packed_options::void_pointer> - , typename packed_options::tag - , packed_options::link_mode - , detail::SplaySetBaseHook - > implementation_defined; - /// @endcond - typedef implementation_defined type; -}; - -//! Derive a class from splay_set_base_hook in order to store objects in -//! in a splay_set/splay_multiset. splay_set_base_hook holds the data necessary to maintain -//! the splay_set/splay_multiset and provides an appropriate value_traits class for splay_set/splay_multiset. -//! -//! The hook admits the following options: \c tag<>, \c void_pointer<>, -//! \c link_mode<> and \c optimize_size<>. -//! -//! \c tag<> defines a tag to identify the node. -//! The same tag value can be used in different classes, but if a class is -//! derived from more than one \c list_base_hook, then each \c list_base_hook needs its -//! unique tag. -//! -//! \c void_pointer<> is the pointer type that will be used internally in the hook -//! and the the container configured to use this hook. -//! -//! \c link_mode<> will specify the linking mode of the hook (\c normal_link, -//! \c auto_unlink or \c safe_link). -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) || defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template<class ...Options> -#else -template<class O1, class O2, class O3> -#endif -class splay_set_base_hook - : public make_splay_set_base_hook< - #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) - O1, O2, O3 - #else - Options... - #endif - >::type -{ - #if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) - public: - //! <b>Effects</b>: If link_mode is \c auto_unlink or \c safe_link - //! initializes the node to an unlinked state. - //! - //! <b>Throws</b>: Nothing. - splay_set_base_hook(); - - //! <b>Effects</b>: If link_mode is \c auto_unlink or \c safe_link - //! initializes the node to an unlinked state. The argument is ignored. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Rationale</b>: Providing a copy-constructor - //! makes classes using the hook STL-compliant without forcing the - //! user to do some additional work. \c swap can be used to emulate - //! move-semantics. - splay_set_base_hook(const splay_set_base_hook& ); - - //! <b>Effects</b>: Empty function. The argument is ignored. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Rationale</b>: Providing an assignment operator - //! makes classes using the hook STL-compliant without forcing the - //! user to do some additional work. \c swap can be used to emulate - //! move-semantics. - splay_set_base_hook& operator=(const splay_set_base_hook& ); - - //! <b>Effects</b>: If link_mode is \c normal_link, the destructor does - //! nothing (ie. no code is generated). If link_mode is \c safe_link and the - //! object is stored in a set an assertion is raised. If link_mode is - //! \c auto_unlink and \c is_linked() is true, the node is unlinked. - //! - //! <b>Throws</b>: Nothing. - ~splay_set_base_hook(); - - //! <b>Effects</b>: Swapping two nodes swaps the position of the elements - //! related to those nodes in one or two containers. That is, if the node - //! this is part of the element e1, the node x is part of the element e2 - //! and both elements are included in the containers s1 and s2, then after - //! the swap-operation e1 is in s2 at the position of e2 and e2 is in s1 - //! at the position of e1. If one element is not in a container, then - //! after the swap-operation the other element is not in a container. - //! Iterators to e1 and e2 related to those nodes are invalidated. - //! - //! <b>Complexity</b>: Constant - //! - //! <b>Throws</b>: Nothing. - void swap_nodes(splay_set_base_hook &other); - - //! <b>Precondition</b>: link_mode must be \c safe_link or \c auto_unlink. - //! - //! <b>Returns</b>: true, if the node belongs to a container, false - //! otherwise. This function can be used to test whether \c set::iterator_to - //! will return a valid iterator. - //! - //! <b>Complexity</b>: Constant - bool is_linked() const; - - //! <b>Effects</b>: Removes the node if it's inserted in a container. - //! This function is only allowed if link_mode is \c auto_unlink. - //! - //! <b>Throws</b>: Nothing. - void unlink(); - #endif -}; - -//! Helper metafunction to define a \c splay_set_member_hook that yields to the same -//! type when the same options (either explicitly or implicitly) are used. -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) || defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template<class ...Options> -#else -template<class O1 = none, class O2 = none, class O3 = none> -#endif -struct make_splay_set_member_hook -{ - /// @cond - typedef typename pack_options - < hook_defaults, - #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) - O1, O2, O3 - #else - Options... - #endif - >::type packed_options; - - typedef detail::generic_hook - < get_splay_set_node_algo<typename packed_options::void_pointer> - , member_tag - , packed_options::link_mode - , detail::NoBaseHook - > implementation_defined; - /// @endcond - typedef implementation_defined type; -}; - -//! Put a public data member splay_set_member_hook in order to store objects of this -//! class in a splay_set/splay_multiset. splay_set_member_hook holds the data -//! necessary for maintaining the splay_set/splay_multiset and provides an appropriate -//! value_traits class for splay_set/splay_multiset. -//! -//! The hook admits the following options: \c void_pointer<>, -//! \c link_mode<> and \c optimize_size<>. -//! -//! \c void_pointer<> is the pointer type that will be used internally in the hook -//! and the the container configured to use this hook. -//! -//! \c link_mode<> will specify the linking mode of the hook (\c normal_link, -//! \c auto_unlink or \c safe_link). -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) || defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template<class ...Options> -#else -template<class O1, class O2, class O3> -#endif -class splay_set_member_hook - : public make_splay_set_member_hook< - #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) - O1, O2, O3 - #else - Options... - #endif - >::type -{ - #if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) - public: - //! <b>Effects</b>: If link_mode is \c auto_unlink or \c safe_link - //! initializes the node to an unlinked state. - //! - //! <b>Throws</b>: Nothing. - splay_set_member_hook(); - - //! <b>Effects</b>: If link_mode is \c auto_unlink or \c safe_link - //! initializes the node to an unlinked state. The argument is ignored. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Rationale</b>: Providing a copy-constructor - //! makes classes using the hook STL-compliant without forcing the - //! user to do some additional work. \c swap can be used to emulate - //! move-semantics. - splay_set_member_hook(const splay_set_member_hook& ); - - //! <b>Effects</b>: Empty function. The argument is ignored. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Rationale</b>: Providing an assignment operator - //! makes classes using the hook STL-compliant without forcing the - //! user to do some additional work. \c swap can be used to emulate - //! move-semantics. - splay_set_member_hook& operator=(const splay_set_member_hook& ); - - //! <b>Effects</b>: If link_mode is \c normal_link, the destructor does - //! nothing (ie. no code is generated). If link_mode is \c safe_link and the - //! object is stored in a set an assertion is raised. If link_mode is - //! \c auto_unlink and \c is_linked() is true, the node is unlinked. - //! - //! <b>Throws</b>: Nothing. - ~splay_set_member_hook(); - - //! <b>Effects</b>: Swapping two nodes swaps the position of the elements - //! related to those nodes in one or two containers. That is, if the node - //! this is part of the element e1, the node x is part of the element e2 - //! and both elements are included in the containers s1 and s2, then after - //! the swap-operation e1 is in s2 at the position of e2 and e2 is in s1 - //! at the position of e1. If one element is not in a container, then - //! after the swap-operation the other element is not in a container. - //! Iterators to e1 and e2 related to those nodes are invalidated. - //! - //! <b>Complexity</b>: Constant - //! - //! <b>Throws</b>: Nothing. - void swap_nodes(splay_set_member_hook &other); - - //! <b>Precondition</b>: link_mode must be \c safe_link or \c auto_unlink. - //! - //! <b>Returns</b>: true, if the node belongs to a container, false - //! otherwise. This function can be used to test whether \c set::iterator_to - //! will return a valid iterator. - //! - //! <b>Complexity</b>: Constant - bool is_linked() const; - - //! <b>Effects</b>: Removes the node if it's inserted in a container. - //! This function is only allowed if link_mode is \c auto_unlink. - //! - //! <b>Throws</b>: Nothing. - void unlink(); - #endif -}; - -} //namespace intrusive -} //namespace boost - -#include <boost/intrusive/detail/config_end.hpp> - -#endif //BOOST_INTRUSIVE_SPLAY_SET_HOOK_HPP diff --git a/src/third_party/boost/boost/intrusive/splaytree.hpp b/src/third_party/boost/boost/intrusive/splaytree.hpp deleted file mode 100644 index 01b28d0a778..00000000000 --- a/src/third_party/boost/boost/intrusive/splaytree.hpp +++ /dev/null @@ -1,1686 +0,0 @@ -///////////////////////////////////////////////////////////////////////////// -// -// (C) Copyright Ion Gaztanaga 2007-2009 -// -// Distributed under the Boost Software License, Version 1.0. -// (See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) -// -// See http://www.boost.org/libs/intrusive for documentation. -// -///////////////////////////////////////////////////////////////////////////// -#ifndef BOOST_INTRUSIVE_SPLAYTREE_HPP -#define BOOST_INTRUSIVE_SPLAYTREE_HPP - -#include <boost/intrusive/detail/config_begin.hpp> -#include <functional> -#include <iterator> -#include <utility> -#include <cstddef> -#include <algorithm> -#include <boost/intrusive/detail/assert.hpp> -#include <boost/static_assert.hpp> -#include <boost/intrusive/intrusive_fwd.hpp> -#include <boost/intrusive/pointer_traits.hpp> -#include <boost/intrusive/splay_set_hook.hpp> -#include <boost/intrusive/detail/tree_node.hpp> -#include <boost/intrusive/detail/ebo_functor_holder.hpp> -#include <boost/intrusive/detail/clear_on_destructor_base.hpp> -#include <boost/intrusive/detail/mpl.hpp> -#include <boost/intrusive/detail/utilities.hpp> -#include <boost/intrusive/pointer_traits.hpp> -#include <boost/intrusive/options.hpp> -#include <boost/intrusive/splaytree_algorithms.hpp> -#include <boost/intrusive/link_mode.hpp> -#include <boost/move/move.hpp> - - -namespace boost { -namespace intrusive { - -/// @cond - -template <class ValueTraits, class Compare, class SizeType, bool ConstantTimeSize> -struct splaysetopt -{ - typedef ValueTraits value_traits; - typedef Compare compare; - typedef SizeType size_type; - static const bool constant_time_size = ConstantTimeSize; -}; - -template <class T> -struct splay_set_defaults - : pack_options - < none - , base_hook<detail::default_splay_set_hook> - , constant_time_size<true> - , size_type<std::size_t> - , compare<std::less<T> > - >::type -{}; - -/// @endcond - -//! The class template splaytree is an intrusive splay tree container that -//! is used to construct intrusive splay_set and splay_multiset containers. The no-throw -//! guarantee holds only, if the value_compare object -//! doesn't throw. -//! -//! The template parameter \c T is the type to be managed by the container. -//! The user can specify additional options and if no options are provided -//! default options are used. -//! -//! The container supports the following options: -//! \c base_hook<>/member_hook<>/value_traits<>, -//! \c constant_time_size<>, \c size_type<> and -//! \c compare<>. -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -class splaytree_impl - : private detail::clear_on_destructor_base<splaytree_impl<Config> > -{ - template<class C> friend class detail::clear_on_destructor_base; - public: - typedef typename Config::value_traits value_traits; - /// @cond - static const bool external_value_traits = - detail::external_value_traits_is_true<value_traits>::value; - typedef typename detail::eval_if_c - < external_value_traits - , detail::eval_value_traits<value_traits> - , detail::identity<value_traits> - >::type real_value_traits; - /// @endcond - typedef typename real_value_traits::pointer pointer; - typedef typename real_value_traits::const_pointer const_pointer; - typedef typename pointer_traits<pointer>::element_type value_type; - typedef typename pointer_traits<pointer>::reference reference; - typedef typename pointer_traits<const_pointer>::reference const_reference; - typedef typename pointer_traits<pointer>::difference_type difference_type; - typedef typename Config::size_type size_type; - typedef value_type key_type; - typedef typename Config::compare value_compare; - typedef value_compare key_compare; - typedef tree_iterator<splaytree_impl, false> iterator; - typedef tree_iterator<splaytree_impl, true> const_iterator; - typedef boost::intrusive::detail::reverse_iterator<iterator> reverse_iterator; - typedef boost::intrusive::detail::reverse_iterator<const_iterator>const_reverse_iterator; - typedef typename real_value_traits::node_traits node_traits; - typedef typename node_traits::node node; - typedef typename pointer_traits - <pointer>::template rebind_pointer - <node>::type node_ptr; - typedef typename pointer_traits - <pointer>::template rebind_pointer - <const node>::type const_node_ptr; - typedef splaytree_algorithms<node_traits> node_algorithms; - - static const bool constant_time_size = Config::constant_time_size; - static const bool stateful_value_traits = detail::is_stateful_value_traits<real_value_traits>::value; - - /// @cond - private: - typedef detail::size_holder<constant_time_size, size_type> size_traits; - - //noncopyable - BOOST_MOVABLE_BUT_NOT_COPYABLE(splaytree_impl) - - enum { safemode_or_autounlink = - (int)real_value_traits::link_mode == (int)auto_unlink || - (int)real_value_traits::link_mode == (int)safe_link }; - - //Constant-time size is incompatible with auto-unlink hooks! - BOOST_STATIC_ASSERT(!(constant_time_size && ((int)real_value_traits::link_mode == (int)auto_unlink))); - - struct header_plus_size : public size_traits - { node header_; }; - - struct node_plus_pred_t : public detail::ebo_functor_holder<value_compare> - { - node_plus_pred_t(const value_compare &comp) - : detail::ebo_functor_holder<value_compare>(comp) - {} - header_plus_size header_plus_size_; - }; - - struct data_t : public splaytree_impl::value_traits - { - typedef typename splaytree_impl::value_traits value_traits; - data_t(const value_compare & comp, const value_traits &val_traits) - : value_traits(val_traits), node_plus_pred_(comp) - {} - node_plus_pred_t node_plus_pred_; - } data_; - - const value_compare &priv_comp() const - { return data_.node_plus_pred_.get(); } - - value_compare &priv_comp() - { return data_.node_plus_pred_.get(); } - - const value_traits &priv_value_traits() const - { return data_; } - - value_traits &priv_value_traits() - { return data_; } - - node_ptr priv_header_ptr() - { return pointer_traits<node_ptr>::pointer_to(data_.node_plus_pred_.header_plus_size_.header_); } - - const_node_ptr priv_header_ptr() const - { return pointer_traits<const_node_ptr>::pointer_to(data_.node_plus_pred_.header_plus_size_.header_); } - - static node_ptr uncast(const const_node_ptr & ptr) - { return pointer_traits<node_ptr>::const_cast_from(ptr); } - - size_traits &priv_size_traits() - { return data_.node_plus_pred_.header_plus_size_; } - - const size_traits &priv_size_traits() const - { return data_.node_plus_pred_.header_plus_size_; } - - const real_value_traits &get_real_value_traits(detail::bool_<false>) const - { return data_; } - - const real_value_traits &get_real_value_traits(detail::bool_<true>) const - { return data_.get_value_traits(*this); } - - real_value_traits &get_real_value_traits(detail::bool_<false>) - { return data_; } - - real_value_traits &get_real_value_traits(detail::bool_<true>) - { return data_.get_value_traits(*this); } - - /// @endcond - - public: - - const real_value_traits &get_real_value_traits() const - { return this->get_real_value_traits(detail::bool_<external_value_traits>()); } - - real_value_traits &get_real_value_traits() - { return this->get_real_value_traits(detail::bool_<external_value_traits>()); } - - typedef typename node_algorithms::insert_commit_data insert_commit_data; - - //! <b>Effects</b>: Constructs an empty tree. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: If value_traits::node_traits::node - //! constructor throws (this does not happen with predefined Boost.Intrusive hooks) - //! or the copy constructorof the value_compare object throws. Basic guarantee. - splaytree_impl( const value_compare &cmp = value_compare() - , const value_traits &v_traits = value_traits()) - : data_(cmp, v_traits) - { - node_algorithms::init_header(this->priv_header_ptr()); - this->priv_size_traits().set_size(size_type(0)); - } - - //! <b>Requires</b>: Dereferencing iterator must yield an lvalue of type value_type. - //! cmp must be a comparison function that induces a strict weak ordering. - //! - //! <b>Effects</b>: Constructs an empty tree and inserts elements from - //! [b, e). - //! - //! <b>Complexity</b>: Linear in N if [b, e) is already sorted using - //! comp and otherwise amortized N * log N, where N is the distance between first and last. - //! - //! <b>Throws</b>: If value_traits::node_traits::node - //! constructor throws (this does not happen with predefined Boost.Intrusive hooks) - //! or the copy constructor/operator() of the value_compare object throws. Basic guarantee. - template<class Iterator> - splaytree_impl ( bool unique, Iterator b, Iterator e - , const value_compare &cmp = value_compare() - , const value_traits &v_traits = value_traits()) - : data_(cmp, v_traits) - { - node_algorithms::init_header(this->priv_header_ptr()); - this->priv_size_traits().set_size(size_type(0)); - if(unique) - this->insert_unique(b, e); - else - this->insert_equal(b, e); - } - - //! <b>Effects</b>: to-do - //! - splaytree_impl(BOOST_RV_REF(splaytree_impl) x) - : data_(::boost::move(x.priv_comp()), ::boost::move(x.priv_value_traits())) - { - node_algorithms::init_header(this->priv_header_ptr()); - this->priv_size_traits().set_size(size_type(0)); - this->swap(x); - } - - //! <b>Effects</b>: to-do - //! - splaytree_impl& operator=(BOOST_RV_REF(splaytree_impl) x) - { this->swap(x); return *this; } - - //! <b>Effects</b>: Detaches all elements from this. The objects in the set - //! are not deleted (i.e. no destructors are called), but the nodes according to - //! the value_traits template parameter are reinitialized and thus can be reused. - //! - //! <b>Complexity</b>: Linear to the number of elements on the container. - //! if it's a safe-mode or auto-unlink value_type. Constant time otherwise. - //! - //! <b>Throws</b>: Nothing. - ~splaytree_impl() - {} - - //! <b>Effects</b>: Returns an iterator pointing to the beginning of the tree. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - iterator begin() - { return iterator(node_algorithms::begin_node(this->priv_header_ptr()), this); } - - //! <b>Effects</b>: Returns a const_iterator pointing to the beginning of the tree. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_iterator begin() const - { return cbegin(); } - - //! <b>Effects</b>: Returns a const_iterator pointing to the beginning of the tree. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_iterator cbegin() const - { return const_iterator(node_algorithms::begin_node(this->priv_header_ptr()), this); } - - //! <b>Effects</b>: Returns an iterator pointing to the end of the tree. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - iterator end() - { return iterator (this->priv_header_ptr(), this); } - - //! <b>Effects</b>: Returns a const_iterator pointing to the end of the tree. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_iterator end() const - { return cend(); } - - //! <b>Effects</b>: Returns a const_iterator pointing to the end of the tree. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_iterator cend() const - { return const_iterator (uncast(this->priv_header_ptr()), this); } - - //! <b>Effects</b>: Returns a reverse_iterator pointing to the beginning of the - //! reversed tree. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - reverse_iterator rbegin() - { return reverse_iterator(end()); } - - //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning - //! of the reversed tree. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_reverse_iterator rbegin() const - { return const_reverse_iterator(end()); } - - //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning - //! of the reversed tree. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_reverse_iterator crbegin() const - { return const_reverse_iterator(end()); } - - //! <b>Effects</b>: Returns a reverse_iterator pointing to the end - //! of the reversed tree. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - reverse_iterator rend() - { return reverse_iterator(begin()); } - - //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the end - //! of the reversed tree. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_reverse_iterator rend() const - { return const_reverse_iterator(begin()); } - - //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the end - //! of the reversed tree. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_reverse_iterator crend() const - { return const_reverse_iterator(begin()); } - - //! <b>Precondition</b>: end_iterator must be a valid end iterator - //! of splaytree. - //! - //! <b>Effects</b>: Returns a const reference to the splaytree associated to the end iterator - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - static splaytree_impl &container_from_end_iterator(iterator end_iterator) - { return priv_container_from_end_iterator(end_iterator); } - - //! <b>Precondition</b>: end_iterator must be a valid end const_iterator - //! of splaytree. - //! - //! <b>Effects</b>: Returns a const reference to the splaytree associated to the end iterator - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - static const splaytree_impl &container_from_end_iterator(const_iterator end_iterator) - { return priv_container_from_end_iterator(end_iterator); } - - //! <b>Precondition</b>: it must be a valid iterator - //! of rbtree. - //! - //! <b>Effects</b>: Returns a const reference to the tree associated to the iterator - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Logarithmic. - static splaytree_impl &container_from_iterator(iterator it) - { return priv_container_from_iterator(it); } - - //! <b>Precondition</b>: it must be a valid end const_iterator - //! of rbtree. - //! - //! <b>Effects</b>: Returns a const reference to the tree associated to the iterator - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Logarithmic. - static const splaytree_impl &container_from_iterator(const_iterator it) - { return priv_container_from_iterator(it); } - - //! <b>Effects</b>: Returns the value_compare object used by the tree. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: If value_compare copy-constructor throws. - value_compare value_comp() const - { return priv_comp(); } - - //! <b>Effects</b>: Returns true if the container is empty. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - bool empty() const - { return this->cbegin() == this->cend(); } - - //! <b>Effects</b>: Returns the number of elements stored in the tree. - //! - //! <b>Complexity</b>: Linear to elements contained in *this - //! if constant-time size option is disabled. Constant time otherwise. - //! - //! <b>Throws</b>: Nothing. - size_type size() const - { - if(constant_time_size){ - return this->priv_size_traits().get_size(); - } - else{ - return (size_type)node_algorithms::size(this->priv_header_ptr()); - } - } - - //! <b>Effects</b>: Swaps the contents of two splaytrees. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: If the comparison functor's swap call throws. - void swap(splaytree_impl& other) - { - //This can throw - using std::swap; - swap(priv_comp(), priv_comp()); - //These can't throw - node_algorithms::swap_tree(this->priv_header_ptr(), other.priv_header_ptr()); - if(constant_time_size){ - size_type backup = this->priv_size_traits().get_size(); - this->priv_size_traits().set_size(other.priv_size_traits().get_size()); - other.priv_size_traits().set_size(backup); - } - } - - //! <b>Requires</b>: value must be an lvalue - //! - //! <b>Effects</b>: Inserts value into the tree before the lower bound. - //! - //! <b>Complexity</b>: Average complexity for insert element is amortized - //! logarithmic. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. Strong guarantee. - //! - //! <b>Note</b>: Does not affect the validity of iterators and references. - //! No copy-constructors are called. - iterator insert_equal(reference value) - { - detail::key_nodeptr_comp<value_compare, splaytree_impl> - key_node_comp(priv_comp(), this); - node_ptr to_insert(get_real_value_traits().to_node_ptr(value)); - if(safemode_or_autounlink) - BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert)); - iterator ret (node_algorithms::insert_equal_lower_bound - (this->priv_header_ptr(), to_insert, key_node_comp), this); - this->priv_size_traits().increment(); - return ret; - } - - //! <b>Requires</b>: value must be an lvalue, and "hint" must be - //! a valid iterator. - //! - //! <b>Effects</b>: Inserts x into the tree, using "hint" as a hint to - //! where it will be inserted. If "hint" is the upper_bound - //! the insertion takes constant time (two comparisons in the worst case) - //! - //! <b>Complexity</b>: Amortized logarithmic in general, but it is amortized - //! constant time if t is inserted immediately before hint. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. Strong guarantee. - //! - //! <b>Note</b>: Does not affect the validity of iterators and references. - //! No copy-constructors are called. - iterator insert_equal(const_iterator hint, reference value) - { - detail::key_nodeptr_comp<value_compare, splaytree_impl> - key_node_comp(priv_comp(), this); - node_ptr to_insert(get_real_value_traits().to_node_ptr(value)); - if(safemode_or_autounlink) - BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert)); - iterator ret(node_algorithms::insert_equal - (this->priv_header_ptr(), hint.pointed_node(), to_insert, key_node_comp), this); - this->priv_size_traits().increment(); - return ret; - } - - //! <b>Requires</b>: Dereferencing iterator must yield an lvalue - //! of type value_type. - //! - //! <b>Effects</b>: Inserts a each element of a range into the tree - //! before the upper bound of the key of each element. - //! - //! <b>Complexity</b>: Insert range is in general amortized O(N * log(N)), where N is the - //! size of the range. However, it is linear in N if the range is already sorted - //! by value_comp(). - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Does not affect the validity of iterators and references. - //! No copy-constructors are called. - template<class Iterator> - void insert_equal(Iterator b, Iterator e) - { - if(this->empty()){ - iterator end(this->end()); - for (; b != e; ++b) - this->insert_equal(end, *b); - } - } - - //! <b>Requires</b>: value must be an lvalue - //! - //! <b>Effects</b>: Inserts value into the tree if the value - //! is not already present. - //! - //! <b>Complexity</b>: Amortized logarithmic. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Does not affect the validity of iterators and references. - //! No copy-constructors are called. - std::pair<iterator, bool> insert_unique(reference value) - { - insert_commit_data commit_data; - std::pair<iterator, bool> ret = insert_unique_check(value, priv_comp(), commit_data); - if(!ret.second) - return ret; - return std::pair<iterator, bool> (insert_unique_commit(value, commit_data), true); - } - - //! <b>Requires</b>: value must be an lvalue, and "hint" must be - //! a valid iterator - //! - //! <b>Effects</b>: Tries to insert x into the tree, using "hint" as a hint - //! to where it will be inserted. - //! - //! <b>Complexity</b>: Amortized logarithmic in general, but it is amortized - //! constant time (two comparisons in the worst case) - //! if t is inserted immediately before hint. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Does not affect the validity of iterators and references. - //! No copy-constructors are called. - iterator insert_unique(const_iterator hint, reference value) - { - insert_commit_data commit_data; - std::pair<iterator, bool> ret = insert_unique_check(hint, value, priv_comp(), commit_data); - if(!ret.second) - return ret.first; - return insert_unique_commit(value, commit_data); - } - - //! <b>Requires</b>: Dereferencing iterator must yield an lvalue - //! of type value_type. - //! - //! <b>Effects</b>: Tries to insert each element of a range into the tree. - //! - //! <b>Complexity</b>: Insert range is in general amortized O(N * log(N)), where N is the - //! size of the range. However, it is linear in N if the range is already sorted - //! by value_comp(). - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Does not affect the validity of iterators and references. - //! No copy-constructors are called. - template<class Iterator> - void insert_unique(Iterator b, Iterator e) - { - for (; b != e; ++b) - this->insert_unique(*b); - } - - //! <b>Requires</b>: key_value_comp must be a comparison function that induces - //! the same strict weak ordering as value_compare. The difference is that - //! key_value_comp compares an arbitrary key with the contained values. - //! - //! <b>Effects</b>: Checks if a value can be inserted in the container, using - //! a user provided key instead of the value itself. - //! - //! <b>Returns</b>: If there is an equivalent value - //! returns a pair containing an iterator to the already present value - //! and false. If the value can be inserted returns true in the returned - //! pair boolean and fills "commit_data" that is meant to be used with - //! the "insert_commit" function. - //! - //! <b>Complexity</b>: Average complexity is at most logarithmic. - //! - //! <b>Throws</b>: If the key_value_comp ordering function throws. Strong guarantee. - //! - //! <b>Notes</b>: This function is used to improve performance when constructing - //! a value_type is expensive: if there is an equivalent value - //! the constructed object must be discarded. Many times, the part of the - //! node that is used to impose the order is much cheaper to construct - //! than the value_type and this function offers the possibility to use that - //! part to check if the insertion will be successful. - //! - //! If the check is successful, the user can construct the value_type and use - //! "insert_commit" to insert the object in constant-time. This gives a total - //! logarithmic complexity to the insertion: check(O(log(N)) + commit(O(1)). - //! - //! "commit_data" remains valid for a subsequent "insert_commit" only if no more - //! objects are inserted or erased from the container. - template<class KeyType, class KeyValueCompare> - std::pair<iterator, bool> insert_unique_check - (const KeyType &key, KeyValueCompare key_value_comp, insert_commit_data &commit_data) - { - detail::key_nodeptr_comp<KeyValueCompare, splaytree_impl> - comp(key_value_comp, this); - std::pair<node_ptr, bool> ret = - (node_algorithms::insert_unique_check - (this->priv_header_ptr(), key, comp, commit_data)); - return std::pair<iterator, bool>(iterator(ret.first, this), ret.second); - } - - //! <b>Requires</b>: key_value_comp must be a comparison function that induces - //! the same strict weak ordering as value_compare. The difference is that - //! key_value_comp compares an arbitrary key with the contained values. - //! - //! <b>Effects</b>: Checks if a value can be inserted in the container, using - //! a user provided key instead of the value itself, using "hint" - //! as a hint to where it will be inserted. - //! - //! <b>Returns</b>: If there is an equivalent value - //! returns a pair containing an iterator to the already present value - //! and false. If the value can be inserted returns true in the returned - //! pair boolean and fills "commit_data" that is meant to be used with - //! the "insert_commit" function. - //! - //! <b>Complexity</b>: Logarithmic in general, but it's amortized - //! constant time if t is inserted immediately before hint. - //! - //! <b>Throws</b>: If the key_value_comp ordering function throws. Strong guarantee. - //! - //! <b>Notes</b>: This function is used to improve performance when constructing - //! a value_type is expensive: if there is an equivalent value - //! the constructed object must be discarded. Many times, the part of the - //! constructing that is used to impose the order is much cheaper to construct - //! than the value_type and this function offers the possibility to use that key - //! to check if the insertion will be successful. - //! - //! If the check is successful, the user can construct the value_type and use - //! "insert_commit" to insert the object in constant-time. This can give a total - //! constant-time complexity to the insertion: check(O(1)) + commit(O(1)). - //! - //! "commit_data" remains valid for a subsequent "insert_commit" only if no more - //! objects are inserted or erased from the container. - template<class KeyType, class KeyValueCompare> - std::pair<iterator, bool> insert_unique_check - (const_iterator hint, const KeyType &key - ,KeyValueCompare key_value_comp, insert_commit_data &commit_data) - { - detail::key_nodeptr_comp<KeyValueCompare, splaytree_impl> - comp(key_value_comp, this); - std::pair<node_ptr, bool> ret = - node_algorithms::insert_unique_check - (this->priv_header_ptr(), hint.pointed_node(), key, comp, commit_data); - return std::pair<iterator, bool>(iterator(ret.first, this), ret.second); - } - - //! <b>Requires</b>: value must be an lvalue of type value_type. commit_data - //! must have been obtained from a previous call to "insert_check". - //! No objects should have been inserted or erased from the container between - //! the "insert_check" that filled "commit_data" and the call to "insert_commit". - //! - //! <b>Effects</b>: Inserts the value in the avl_set using the information obtained - //! from the "commit_data" that a previous "insert_check" filled. - //! - //! <b>Returns</b>: An iterator to the newly inserted object. - //! - //! <b>Complexity</b>: Constant time. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Notes</b>: This function has only sense if a "insert_check" has been - //! previously executed to fill "commit_data". No value should be inserted or - //! erased between the "insert_check" and "insert_commit" calls. - iterator insert_unique_commit(reference value, const insert_commit_data &commit_data) - { - node_ptr to_insert(get_real_value_traits().to_node_ptr(value)); - if(safemode_or_autounlink) - BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert)); - node_algorithms::insert_unique_commit - (this->priv_header_ptr(), to_insert, commit_data); - this->priv_size_traits().increment(); - return iterator(to_insert, this); - } - - //! <b>Effects</b>: Erases the element pointed to by pos. - //! - //! <b>Complexity</b>: Average complexity for erase element is constant time. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - iterator erase(const_iterator i) - { - const_iterator ret(i); - ++ret; - node_ptr to_erase(i.pointed_node()); - if(safemode_or_autounlink) - BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(!node_algorithms::unique(to_erase)); - node_algorithms::erase(this->priv_header_ptr(), to_erase); - this->priv_size_traits().decrement(); - if(safemode_or_autounlink) - node_algorithms::init(to_erase); - return ret.unconst(); - } - - //! <b>Effects</b>: Erases the range pointed to by b end e. - //! - //! <b>Complexity</b>: Average complexity for erase range is amortized - //! O(log(size() + N)), where N is the number of elements in the range. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - iterator erase(const_iterator b, const_iterator e) - { size_type n; return private_erase(b, e, n); } - - //! <b>Effects</b>: Erases all the elements with the given value. - //! - //! <b>Returns</b>: The number of erased elements. - //! - //! <b>Complexity</b>: Amortized O(log(size() + N). - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - size_type erase(const_reference value) - { return this->erase(value, priv_comp()); } - - //! <b>Effects</b>: Erases all the elements with the given key. - //! according to the comparison functor "comp". - //! - //! <b>Returns</b>: The number of erased elements. - //! - //! <b>Complexity</b>: Amortized O(log(size() + N). - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - template<class KeyType, class KeyValueCompare> - size_type erase(const KeyType& key, KeyValueCompare comp - /// @cond - , typename detail::enable_if_c<!detail::is_convertible<KeyValueCompare, const_iterator>::value >::type * = 0 - /// @endcond - ) - { - std::pair<iterator,iterator> p = this->equal_range(key, comp); - size_type n; - private_erase(p.first, p.second, n); - return n; - } - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! - //! <b>Effects</b>: Erases the element pointed to by pos. - //! Disposer::operator()(pointer) is called for the removed element. - //! - //! <b>Complexity</b>: Average complexity for erase element is constant time. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators - //! to the erased elements. - template<class Disposer> - iterator erase_and_dispose(const_iterator i, Disposer disposer) - { - node_ptr to_erase(i.pointed_node()); - iterator ret(this->erase(i)); - disposer(get_real_value_traits().to_value_ptr(to_erase)); - return ret; - } - - #if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) - template<class Disposer> - iterator erase_and_dispose(iterator i, Disposer disposer) - { return this->erase_and_dispose(const_iterator(i), disposer); } - #endif - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! - //! <b>Effects</b>: Erases the range pointed to by b end e. - //! Disposer::operator()(pointer) is called for the removed elements. - //! - //! <b>Complexity</b>: Average complexity for erase range is amortized - //! O(log(size() + N)), where N is the number of elements in the range. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators - //! to the erased elements. - template<class Disposer> - iterator erase_and_dispose(const_iterator b, const_iterator e, Disposer disposer) - { size_type n; return private_erase(b, e, n, disposer); } - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! - //! <b>Effects</b>: Erases all the elements with the given value. - //! Disposer::operator()(pointer) is called for the removed elements. - //! - //! <b>Returns</b>: The number of erased elements. - //! - //! <b>Complexity</b>: Amortized O(log(size() + N). - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - template<class Disposer> - size_type erase_and_dispose(const_reference value, Disposer disposer) - { - std::pair<iterator,iterator> p = this->equal_range(value); - size_type n; - private_erase(p.first, p.second, n, disposer); - return n; - } - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! - //! <b>Effects</b>: Erases all the elements with the given key. - //! according to the comparison functor "comp". - //! Disposer::operator()(pointer) is called for the removed elements. - //! - //! <b>Returns</b>: The number of erased elements. - //! - //! <b>Complexity</b>: Amortized O(log(size() + N). - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators - //! to the erased elements. - template<class KeyType, class KeyValueCompare, class Disposer> - size_type erase_and_dispose(const KeyType& key, KeyValueCompare comp, Disposer disposer - /// @cond - , typename detail::enable_if_c<!detail::is_convertible<KeyValueCompare, const_iterator>::value >::type * = 0 - /// @endcond - ) - { - std::pair<iterator,iterator> p = this->equal_range(key, comp); - size_type n; - private_erase(p.first, p.second, n, disposer); - return n; - } - - //! <b>Effects</b>: Erases all of the elements. - //! - //! <b>Complexity</b>: Linear to the number of elements on the container. - //! if it's a safe-mode or auto-unlink value_type. Constant time otherwise. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - void clear() - { - if(safemode_or_autounlink){ - this->clear_and_dispose(detail::null_disposer()); - } - else{ - node_algorithms::init_header(this->priv_header_ptr()); - this->priv_size_traits().set_size(0); - } - } - - //! <b>Effects</b>: Erases all of the elements calling disposer(p) for - //! each node to be erased. - //! <b>Complexity</b>: Amortized O(log(size() + N)), - //! where N is the number of elements in the container. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. Calls N times to disposer functor. - template<class Disposer> - void clear_and_dispose(Disposer disposer) - { - node_algorithms::clear_and_dispose(this->priv_header_ptr() - , detail::node_disposer<Disposer, splaytree_impl>(disposer, this)); - this->priv_size_traits().set_size(0); - } - - //! <b>Effects</b>: Returns the number of contained elements with the given value - //! - //! <b>Complexity</b>: Amortized logarithmic to the number of elements contained plus lineal - //! to number of objects with the given value. - //! - //! <b>Throws</b>: Nothing. - size_type count(const_reference value) - { return this->count(value, priv_comp()); } - - //! <b>Effects</b>: Returns the number of contained elements with the given key - //! - //! <b>Complexity</b>: Amortized logarithmic to the number of elements contained plus lineal - //! to number of objects with the given key. - //! - //! <b>Throws</b>: Nothing. - template<class KeyType, class KeyValueCompare> - size_type count(const KeyType &key, KeyValueCompare comp) - { - std::pair<const_iterator, const_iterator> ret = this->equal_range(key, comp); - return std::distance(ret.first, ret.second); - } - - //! <b>Effects</b>: Returns the number of contained elements with the given value - //! - //! <b>Complexity</b>: Amortized logarithmic to the number of elements contained plus lineal - //! to number of objects with the given value. - //! - //! <b>Throws</b>: Nothing. - size_type count_dont_splay(const_reference value) const - { return this->count_dont_splay(value, priv_comp()); } - - //! <b>Effects</b>: Returns the number of contained elements with the given key - //! - //! <b>Complexity</b>: Amortized logarithmic to the number of elements contained plus lineal - //! to number of objects with the given key. - //! - //! <b>Throws</b>: Nothing. - template<class KeyType, class KeyValueCompare> - size_type count_dont_splay(const KeyType &key, KeyValueCompare comp) const - { - std::pair<const_iterator, const_iterator> ret = this->equal_range_dont_splay(key, comp); - return std::distance(ret.first, ret.second); - } - - //! <b>Effects</b>: Returns an iterator to the first element whose - //! key is not less than k or end() if that element does not exist. - //! - //! <b>Complexity</b>: Amortized logarithmic. - //! - //! <b>Throws</b>: Nothing. - iterator lower_bound(const_reference value) - { return this->lower_bound(value, priv_comp()); } - - //! <b>Effects</b>: Returns an iterator to the first element whose - //! key is not less than k or end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: Nothing. - const_iterator lower_bound_dont_splay(const_reference value) const - { return this->lower_bound_dont_splay(value, priv_comp()); } - - //! <b>Effects</b>: Returns an iterator to the first element whose - //! key is not less than k or end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: Nothing. - template<class KeyType, class KeyValueCompare> - iterator lower_bound(const KeyType &key, KeyValueCompare comp) - { - detail::key_nodeptr_comp<KeyValueCompare, splaytree_impl> - key_node_comp(comp, this); - return iterator(node_algorithms::lower_bound - (this->priv_header_ptr(), key, key_node_comp), this); - } - - //! <b>Effects</b>: Returns a const iterator to the first element whose - //! key is not less than k or end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: Nothing. - template<class KeyType, class KeyValueCompare> - const_iterator lower_bound_dont_splay(const KeyType &key, KeyValueCompare comp) const - { - detail::key_nodeptr_comp<KeyValueCompare, splaytree_impl> - key_node_comp(comp, this); - return const_iterator(node_algorithms::lower_bound - (this->priv_header_ptr(), key, key_node_comp, false), this); - } - - //! <b>Effects</b>: Returns an iterator to the first element whose - //! key is greater than k or end() if that element does not exist. - //! - //! <b>Complexity</b>: Amortized logarithmic. - //! - //! <b>Throws</b>: Nothing. - iterator upper_bound(const_reference value) - { return this->upper_bound(value, priv_comp()); } - - //! <b>Effects</b>: Returns an iterator to the first element whose - //! key is greater than k according to comp or end() if that element - //! does not exist. - //! - //! <b>Complexity</b>: Amortized logarithmic. - //! - //! <b>Throws</b>: Nothing. - template<class KeyType, class KeyValueCompare> - iterator upper_bound(const KeyType &key, KeyValueCompare comp) - { - detail::key_nodeptr_comp<KeyValueCompare, splaytree_impl> - key_node_comp(comp, this); - return iterator(node_algorithms::upper_bound - (this->priv_header_ptr(), key, key_node_comp), this); - } - - //! <b>Effects</b>: Returns an iterator to the first element whose - //! key is greater than k or end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: Nothing. - const_iterator upper_bound_dont_splay(const_reference value) const - { return this->upper_bound_dont_splay(value, priv_comp()); } - - //! <b>Effects</b>: Returns an iterator to the first element whose - //! key is greater than k according to comp or end() if that element - //! does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: Nothing. - template<class KeyType, class KeyValueCompare> - const_iterator upper_bound_dont_splay(const KeyType &key, KeyValueCompare comp) const - { - detail::key_nodeptr_comp<KeyValueCompare, splaytree_impl> - key_node_comp(comp, this); - return const_iterator(node_algorithms::upper_bound_dont_splay - (this->priv_header_ptr(), key, key_node_comp, false), this); - } - - //! <b>Effects</b>: Finds an iterator to the first element whose key is - //! k or end() if that element does not exist. - //! - //! <b>Complexity</b>: Amortized logarithmic. - //! - //! <b>Throws</b>: Nothing. - iterator find(const_reference value) - { return this->find(value, priv_comp()); } - - //! <b>Effects</b>: Finds an iterator to the first element whose key is - //! k or end() if that element does not exist. - //! - //! <b>Complexity</b>: Amortized logarithmic. - //! - //! <b>Throws</b>: Nothing. - template<class KeyType, class KeyValueCompare> - iterator find(const KeyType &key, KeyValueCompare comp) - { - detail::key_nodeptr_comp<KeyValueCompare, splaytree_impl> - key_node_comp(comp, this); - return iterator - (node_algorithms::find(this->priv_header_ptr(), key, key_node_comp), this); - } - - //! <b>Effects</b>: Finds a const_iterator to the first element whose key is - //! k or end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: Nothing. - const_iterator find_dont_splay(const_reference value) const - { return this->find_dont_splay(value, priv_comp()); } - - //! <b>Effects</b>: Finds a const_iterator to the first element whose key is - //! k or end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: Nothing. - template<class KeyType, class KeyValueCompare> - const_iterator find_dont_splay(const KeyType &key, KeyValueCompare comp) const - { - detail::key_nodeptr_comp<KeyValueCompare, splaytree_impl> - key_node_comp(comp, this); - return const_iterator - (node_algorithms::find(this->priv_header_ptr(), key, key_node_comp, false), this); - } - - //! <b>Effects</b>: Finds a range containing all elements whose key is k or - //! an empty range that indicates the position where those elements would be - //! if they there is no elements with key k. - //! - //! <b>Complexity</b>: Amortized logarithmic. - //! - //! <b>Throws</b>: Nothing. - std::pair<iterator,iterator> equal_range(const_reference value) - { return this->equal_range(value, priv_comp()); } - - //! <b>Effects</b>: Finds a range containing all elements whose key is k or - //! an empty range that indicates the position where those elements would be - //! if they there is no elements with key k. - //! - //! <b>Complexity</b>: Amortized logarithmic. - //! - //! <b>Throws</b>: Nothing. - template<class KeyType, class KeyValueCompare> - std::pair<iterator,iterator> equal_range(const KeyType &key, KeyValueCompare comp) - { - detail::key_nodeptr_comp<KeyValueCompare, splaytree_impl> - key_node_comp(comp, this); - std::pair<node_ptr, node_ptr> ret - (node_algorithms::equal_range(this->priv_header_ptr(), key, key_node_comp)); - return std::pair<iterator, iterator>(iterator(ret.first, this), iterator(ret.second, this)); - } - - //! <b>Effects</b>: Finds a range containing all elements whose key is k or - //! an empty range that indicates the position where those elements would be - //! if they there is no elements with key k. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: Nothing. - std::pair<const_iterator, const_iterator> - equal_range_dont_splay(const_reference value) const - { return this->equal_range_dont_splay(value, priv_comp()); } - - //! <b>Effects</b>: Finds a range containing all elements whose key is k or - //! an empty range that indicates the position where those elements would be - //! if they there is no elements with key k. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: Nothing. - template<class KeyType, class KeyValueCompare> - std::pair<const_iterator, const_iterator> - equal_range_dont_splay(const KeyType &key, KeyValueCompare comp) const - { - detail::key_nodeptr_comp<KeyValueCompare, splaytree_impl> - key_node_comp(comp, this); - std::pair<node_ptr, node_ptr> ret - (node_algorithms::equal_range(this->priv_header_ptr(), key, key_node_comp, false)); - return std::pair<const_iterator, const_iterator>(const_iterator(ret.first, this), const_iterator(ret.second, this)); - } - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! Cloner should yield to nodes equivalent to the original nodes. - //! - //! <b>Effects</b>: Erases all the elements from *this - //! calling Disposer::operator()(pointer), clones all the - //! elements from src calling Cloner::operator()(const_reference ) - //! and inserts them on *this. Copies the predicate from the source container. - //! - //! If cloner throws, all cloned elements are unlinked and disposed - //! calling Disposer::operator()(pointer). - //! - //! <b>Complexity</b>: Linear to erased plus inserted elements. - //! - //! <b>Throws</b>: If cloner throws or predicate copy assignment throws. Basic guarantee. - template <class Cloner, class Disposer> - void clone_from(const splaytree_impl &src, Cloner cloner, Disposer disposer) - { - this->clear_and_dispose(disposer); - if(!src.empty()){ - detail::exception_disposer<splaytree_impl, Disposer> - rollback(*this, disposer); - node_algorithms::clone - (src.priv_header_ptr() - ,this->priv_header_ptr() - ,detail::node_cloner<Cloner, splaytree_impl>(cloner, this) - ,detail::node_disposer<Disposer, splaytree_impl>(disposer, this)); - this->priv_size_traits().set_size(src.priv_size_traits().get_size()); - this->priv_comp() = src.priv_comp(); - rollback.release(); - } - } - - //! <b>Effects</b>: Unlinks the leftmost node from the tree. - //! - //! <b>Complexity</b>: Average complexity is constant time. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Notes</b>: This function breaks the tree and the tree can - //! only be used for more unlink_leftmost_without_rebalance calls. - //! This function is normally used to achieve a step by step - //! controlled destruction of the tree. - pointer unlink_leftmost_without_rebalance() - { - node_ptr to_be_disposed(node_algorithms::unlink_leftmost_without_rebalance - (this->priv_header_ptr())); - if(!to_be_disposed) - return 0; - this->priv_size_traits().decrement(); - if(safemode_or_autounlink)//If this is commented does not work with normal_link - node_algorithms::init(to_be_disposed); - return get_real_value_traits().to_value_ptr(to_be_disposed); - } - - //! <b>Requires</b>: i must be a valid iterator of *this. - //! - //! <b>Effects</b>: Rearranges the splay set so that the element pointed by i - //! is placed as the root of the tree, improving future searches of this value. - //! - //! <b>Complexity</b>: Amortized logarithmic. - //! - //! <b>Throws</b>: Nothing. - void splay_up(iterator i) - { return node_algorithms::splay_up(i.pointed_node(), this->priv_header_ptr()); } - - //! <b>Effects</b>: Rearranges the splay set so that if *this stores an element - //! with a key equivalent to value the element is placed as the root of the - //! tree. If the element is not present returns the last node compared with the key. - //! If the tree is empty, end() is returned. - //! - //! <b>Complexity</b>: Amortized logarithmic. - //! - //! <b>Returns</b>: An iterator to the new root of the tree, end() if the tree is empty. - //! - //! <b>Throws</b>: If the comparison functor throws. - template<class KeyType, class KeyValueCompare> - iterator splay_down(const KeyType &key, KeyValueCompare comp) - { - detail::key_nodeptr_comp<KeyValueCompare, splaytree_impl> - key_node_comp(comp, this); - node_ptr r = node_algorithms::splay_down(this->priv_header_ptr(), key, key_node_comp); - return iterator(r, this); - } - - //! <b>Effects</b>: Rearranges the splay set so that if *this stores an element - //! with a key equivalent to value the element is placed as the root of the - //! tree. - //! - //! <b>Complexity</b>: Amortized logarithmic. - //! - //! <b>Returns</b>: An iterator to the new root of the tree, end() if the tree is empty. - //! - //! <b>Throws</b>: If the predicate throws. - iterator splay_down(const value_type &value) - { return this->splay_down(value, priv_comp()); } - - //! <b>Requires</b>: replace_this must be a valid iterator of *this - //! and with_this must not be inserted in any tree. - //! - //! <b>Effects</b>: Replaces replace_this in its position in the - //! tree with with_this. The tree does not need to be rebalanced. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: This function will break container ordering invariants if - //! with_this is not equivalent to *replace_this according to the - //! ordering rules. This function is faster than erasing and inserting - //! the node, since no rebalancing or comparison is needed. - void replace_node(iterator replace_this, reference with_this) - { - node_algorithms::replace_node( get_real_value_traits().to_node_ptr(*replace_this) - , this->priv_header_ptr() - , get_real_value_traits().to_node_ptr(with_this)); - if(safemode_or_autounlink) - node_algorithms::init(replace_this.pointed_node()); - } - - //! <b>Requires</b>: value must be an lvalue and shall be in a set of - //! appropriate type. Otherwise the behavior is undefined. - //! - //! <b>Effects</b>: Returns: a valid iterator i belonging to the set - //! that points to the value - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: This static function is available only if the <i>value traits</i> - //! is stateless. - static iterator s_iterator_to(reference value) - { - BOOST_STATIC_ASSERT((!stateful_value_traits)); - return iterator (value_traits::to_node_ptr(value), 0); - } - - //! <b>Requires</b>: value must be an lvalue and shall be in a set of - //! appropriate type. Otherwise the behavior is undefined. - //! - //! <b>Effects</b>: Returns: a valid const_iterator i belonging to the - //! set that points to the value - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: This static function is available only if the <i>value traits</i> - //! is stateless. - static const_iterator s_iterator_to(const_reference value) - { - BOOST_STATIC_ASSERT((!stateful_value_traits)); - return const_iterator (value_traits::to_node_ptr(const_cast<reference> (value)), 0); - } - - //! <b>Requires</b>: value must be an lvalue and shall be in a set of - //! appropriate type. Otherwise the behavior is undefined. - //! - //! <b>Effects</b>: Returns: a valid iterator i belonging to the set - //! that points to the value - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - iterator iterator_to(reference value) - { return iterator (value_traits::to_node_ptr(value), this); } - - //! <b>Requires</b>: value must be an lvalue and shall be in a set of - //! appropriate type. Otherwise the behavior is undefined. - //! - //! <b>Effects</b>: Returns: a valid const_iterator i belonging to the - //! set that points to the value - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_iterator iterator_to(const_reference value) const - { return const_iterator (value_traits::to_node_ptr(const_cast<reference> (value)), this); } - - //! <b>Requires</b>: value shall not be in a tree. - //! - //! <b>Effects</b>: init_node puts the hook of a value in a well-known default - //! state. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant time. - //! - //! <b>Note</b>: This function puts the hook in the well-known default state - //! used by auto_unlink and safe hooks. - static void init_node(reference value) - { node_algorithms::init(value_traits::to_node_ptr(value)); } - - //! <b>Effects</b>: Rebalances the tree. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Linear. - void rebalance() - { node_algorithms::rebalance(this->priv_header_ptr()); } - - //! <b>Requires</b>: old_root is a node of a tree. - //! - //! <b>Effects</b>: Rebalances the subtree rooted at old_root. - //! - //! <b>Returns</b>: The new root of the subtree. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Linear to the elements in the subtree. - iterator rebalance_subtree(iterator root) - { return iterator(node_algorithms::rebalance_subtree(root.pointed_node()), this); } - -/* - //! <b>Effects</b>: removes x from a tree of the appropriate type. It has no effect, - //! if x is not in such a tree. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant time. - //! - //! <b>Note</b>: This static function is only usable with the "safe mode" - //! hook and non-constant time size lists. Otherwise, the user must use - //! the non-static "erase(reference )" member. If the user calls - //! this function with a non "safe mode" or constant time size list - //! a compilation error will be issued. - template<class T> - static void remove_node(T& value) - { - //This function is only usable for safe mode hooks and non-constant - //time lists. - //BOOST_STATIC_ASSERT((!(safemode_or_autounlink && constant_time_size))); - BOOST_STATIC_ASSERT((!constant_time_size)); - BOOST_STATIC_ASSERT((boost::is_convertible<T, value_type>::value)); - node_ptr to_remove(value_traits::to_node_ptr(value)); - node_algorithms::unlink_and_rebalance(to_remove); - if(safemode_or_autounlink) - node_algorithms::init(to_remove); - } -*/ - - /// @cond - private: - template<class Disposer> - iterator private_erase(const_iterator b, const_iterator e, size_type &n, Disposer disposer) - { - for(n = 0; b != e; ++n) - this->erase_and_dispose(b++, disposer); - return b.unconst(); - } - - iterator private_erase(const_iterator b, const_iterator e, size_type &n) - { - for(n = 0; b != e; ++n) - this->erase(b++); - return b.unconst(); - } - /// @endcond - - private: - static splaytree_impl &priv_container_from_end_iterator(const const_iterator &end_iterator) - { - header_plus_size *r = detail::parent_from_member<header_plus_size, node> - ( boost::intrusive::detail::to_raw_pointer(end_iterator.pointed_node()), &header_plus_size::header_); - node_plus_pred_t *n = detail::parent_from_member - <node_plus_pred_t, header_plus_size>(r, &node_plus_pred_t::header_plus_size_); - data_t *d = detail::parent_from_member<data_t, node_plus_pred_t>(n, &data_t::node_plus_pred_); - splaytree_impl *rb = detail::parent_from_member<splaytree_impl, data_t>(d, &splaytree_impl::data_); - return *rb; - } - - static splaytree_impl &priv_container_from_iterator(const const_iterator &it) - { return priv_container_from_end_iterator(it.end_iterator_from_it()); } -}; - -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -inline bool operator< -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -(const splaytree_impl<T, Options...> &x, const splaytree_impl<T, Options...> &y) -#else -(const splaytree_impl<Config> &x, const splaytree_impl<Config> &y) -#endif -{ return std::lexicographical_compare(x.begin(), x.end(), y.begin(), y.end()); } - -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -bool operator== -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -(const splaytree_impl<T, Options...> &x, const splaytree_impl<T, Options...> &y) -#else -(const splaytree_impl<Config> &x, const splaytree_impl<Config> &y) -#endif -{ - typedef splaytree_impl<Config> tree_type; - typedef typename tree_type::const_iterator const_iterator; - - if(tree_type::constant_time_size && x.size() != y.size()){ - return false; - } - const_iterator end1 = x.end(); - const_iterator i1 = x.begin(); - const_iterator i2 = y.begin(); - if(tree_type::constant_time_size){ - while (i1 != end1 && *i1 == *i2) { - ++i1; - ++i2; - } - return i1 == end1; - } - else{ - const_iterator end2 = y.end(); - while (i1 != end1 && i2 != end2 && *i1 == *i2) { - ++i1; - ++i2; - } - return i1 == end1 && i2 == end2; - } -} - -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -inline bool operator!= -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -(const splaytree_impl<T, Options...> &x, const splaytree_impl<T, Options...> &y) -#else -(const splaytree_impl<Config> &x, const splaytree_impl<Config> &y) -#endif -{ return !(x == y); } - -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -inline bool operator> -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -(const splaytree_impl<T, Options...> &x, const splaytree_impl<T, Options...> &y) -#else -(const splaytree_impl<Config> &x, const splaytree_impl<Config> &y) -#endif -{ return y < x; } - -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -inline bool operator<= -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -(const splaytree_impl<T, Options...> &x, const splaytree_impl<T, Options...> &y) -#else -(const splaytree_impl<Config> &x, const splaytree_impl<Config> &y) -#endif -{ return !(y < x); } - -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -inline bool operator>= -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -(const splaytree_impl<T, Options...> &x, const splaytree_impl<T, Options...> &y) -#else -(const splaytree_impl<Config> &x, const splaytree_impl<Config> &y) -#endif -{ return !(x < y); } - -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -inline void swap -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -(splaytree_impl<T, Options...> &x, splaytree_impl<T, Options...> &y) -#else -(splaytree_impl<Config> &x, splaytree_impl<Config> &y) -#endif -{ x.swap(y); } - -/// @cond - -#if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template<class T, class O1 = none, class O2 = none - , class O3 = none, class O4 = none> -#else -template<class T, class ...Options> -#endif -struct make_splaytree_opt -{ - typedef typename pack_options - < splay_set_defaults<T>, - #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) - O1, O2, O3, O4 - #else - Options... - #endif - >::type packed_options; - typedef typename detail::get_value_traits - <T, typename packed_options::value_traits>::type value_traits; - - typedef splaysetopt - < value_traits - , typename packed_options::compare - , typename packed_options::size_type - , packed_options::constant_time_size - > type; -}; -/// @endcond - -//! Helper metafunction to define a \c splaytree that yields to the same type when the -//! same options (either explicitly or implicitly) are used. -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) || defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template<class T, class ...Options> -#else -template<class T, class O1 = none, class O2 = none - , class O3 = none, class O4 = none> -#endif -struct make_splaytree -{ - /// @cond - typedef splaytree_impl - < typename make_splaytree_opt<T, - #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) - O1, O2, O3, O4 - #else - Options... - #endif - >::type - > implementation_defined; - /// @endcond - typedef implementation_defined type; -}; - -#ifndef BOOST_INTRUSIVE_DOXYGEN_INVOKED -#if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template<class T, class O1, class O2, class O3, class O4> -#else -template<class T, class ...Options> -#endif -class splaytree - : public make_splaytree<T, - #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) - O1, O2, O3, O4 - #else - Options... - #endif - >::type -{ - typedef typename make_splaytree - <T, - #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) - O1, O2, O3, O4 - #else - Options... - #endif - >::type Base; - BOOST_MOVABLE_BUT_NOT_COPYABLE(splaytree) - - public: - typedef typename Base::value_compare value_compare; - typedef typename Base::value_traits value_traits; - typedef typename Base::real_value_traits real_value_traits; - typedef typename Base::iterator iterator; - typedef typename Base::const_iterator const_iterator; - - //Assert if passed value traits are compatible with the type - BOOST_STATIC_ASSERT((detail::is_same<typename real_value_traits::value_type, T>::value)); - - splaytree( const value_compare &cmp = value_compare() - , const value_traits &v_traits = value_traits()) - : Base(cmp, v_traits) - {} - - template<class Iterator> - splaytree( bool unique, Iterator b, Iterator e - , const value_compare &cmp = value_compare() - , const value_traits &v_traits = value_traits()) - : Base(unique, b, e, cmp, v_traits) - {} - - splaytree(BOOST_RV_REF(splaytree) x) - : Base(::boost::move(static_cast<Base&>(x))) - {} - - splaytree& operator=(BOOST_RV_REF(splaytree) x) - { this->Base::operator=(::boost::move(static_cast<Base&>(x))); return *this; } - - static splaytree &container_from_end_iterator(iterator end_iterator) - { return static_cast<splaytree &>(Base::container_from_end_iterator(end_iterator)); } - - static const splaytree &container_from_end_iterator(const_iterator end_iterator) - { return static_cast<const splaytree &>(Base::container_from_end_iterator(end_iterator)); } -}; - -#endif - - -} //namespace intrusive -} //namespace boost - -#include <boost/intrusive/detail/config_end.hpp> - -#endif //BOOST_INTRUSIVE_SPLAYTREE_HPP diff --git a/src/third_party/boost/boost/intrusive/splaytree_algorithms.hpp b/src/third_party/boost/boost/intrusive/splaytree_algorithms.hpp deleted file mode 100644 index 0c699030eaf..00000000000 --- a/src/third_party/boost/boost/intrusive/splaytree_algorithms.hpp +++ /dev/null @@ -1,973 +0,0 @@ -///////////////////////////////////////////////////////////////////////////// -// -// (C) Copyright Ion Gaztanaga 2007. -// -// Distributed under the Boost Software License, Version 1.0. -// (See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) -// -// See http://www.boost.org/libs/intrusive for documentation. -// -///////////////////////////////////////////////////////////////////////////// -// The implementation of splay trees is based on the article and code published -// in C++ Users Journal "Implementing Splay Trees in C++" (September 1, 2005). -// -// The code has been modified and (supposely) improved by Ion Gaztanaga. -// Here is the header of the file used as base code: -// -// splay_tree.h -- implementation of a STL complatible splay tree. -// -// Copyright (c) 2004 Ralf Mattethat -// -// Permission to copy, use, modify, sell and distribute this software -// is granted provided this copyright notice appears in all copies. -// This software is provided "as is" without express or implied -// warranty, and with no claim as to its suitability for any purpose. -// -// Please send questions, comments, complaints, performance data, etc to -// ralf.mattethat@teknologisk.dk -// -// Requirements for element type -// * must be copy-constructible -// * destructor must not throw exception -// -// Methods marked with note A only throws an exception if the evaluation of the -// predicate throws an exception. If an exception is thrown the call has no -// effect on the containers state -// -// Methods marked with note B only throws an exception if the coppy constructor -// or assignment operator of the predicate throws an exception. If an exception -// is thrown the call has no effect on the containers state -// -// iterators are only invalidated, if the element pointed to by the iterator -// is deleted. The same goes for element references -// - -#ifndef BOOST_INTRUSIVE_SPLAYTREE_ALGORITHMS_HPP -#define BOOST_INTRUSIVE_SPLAYTREE_ALGORITHMS_HPP - -#include <boost/intrusive/detail/config_begin.hpp> -#include <boost/intrusive/detail/assert.hpp> -#include <boost/intrusive/intrusive_fwd.hpp> -#include <boost/intrusive/pointer_traits.hpp> -#include <cstddef> -#include <boost/intrusive/detail/utilities.hpp> -#include <boost/intrusive/detail/tree_algorithms.hpp> - -namespace boost { -namespace intrusive { - -/// @cond -namespace detail { - -template<class NodeTraits> -struct splaydown_rollback -{ - typedef typename NodeTraits::node_ptr node_ptr; - splaydown_rollback( const node_ptr *pcur_subtree, const node_ptr & header - , const node_ptr & leftmost , const node_ptr & rightmost) - : pcur_subtree_(pcur_subtree) , header_(header) - , leftmost_(leftmost) , rightmost_(rightmost) - {} - - void release() - { pcur_subtree_ = 0; } - - ~splaydown_rollback() - { - if(pcur_subtree_){ - //Exception can only be thrown by comp, but - //tree invariants still hold. *pcur_subtree is the current root - //so link it to the header. - NodeTraits::set_parent(*pcur_subtree_, header_); - NodeTraits::set_parent(header_, *pcur_subtree_); - //Recover leftmost/rightmost pointers - NodeTraits::set_left (header_, leftmost_); - NodeTraits::set_right(header_, rightmost_); - } - } - const node_ptr *pcur_subtree_; - node_ptr header_, leftmost_, rightmost_; -}; - -} //namespace detail { -/// @endcond - -//! A splay tree is an implementation of a binary search tree. The tree is -//! self balancing using the splay algorithm as described in -//! -//! "Self-Adjusting Binary Search Trees -//! by Daniel Dominic Sleator and Robert Endre Tarjan -//! AT&T Bell Laboratories, Murray Hill, NJ -//! Journal of the ACM, Vol 32, no 3, July 1985, pp 652-686 - -//! splaytree_algorithms is configured with a NodeTraits class, which encapsulates the -//! information about the node to be manipulated. NodeTraits must support the -//! following interface: -//! -//! <b>Typedefs</b>: -//! -//! <tt>node</tt>: The type of the node that forms the circular list -//! -//! <tt>node_ptr</tt>: A pointer to a node -//! -//! <tt>const_node_ptr</tt>: A pointer to a const node -//! -//! <b>Static functions</b>: -//! -//! <tt>static node_ptr get_parent(const_node_ptr n);</tt> -//! -//! <tt>static void set_parent(node_ptr n, node_ptr parent);</tt> -//! -//! <tt>static node_ptr get_left(const_node_ptr n);</tt> -//! -//! <tt>static void set_left(node_ptr n, node_ptr left);</tt> -//! -//! <tt>static node_ptr get_right(const_node_ptr n);</tt> -//! -//! <tt>static void set_right(node_ptr n, node_ptr right);</tt> -template<class NodeTraits> -class splaytree_algorithms -{ - /// @cond - private: - typedef detail::tree_algorithms<NodeTraits> tree_algorithms; - /// @endcond - - public: - typedef typename NodeTraits::node node; - typedef NodeTraits node_traits; - typedef typename NodeTraits::node_ptr node_ptr; - typedef typename NodeTraits::const_node_ptr const_node_ptr; - - //! This type is the information that will be - //! filled by insert_unique_check - typedef typename tree_algorithms::insert_commit_data insert_commit_data; - - /// @cond - private: - static node_ptr uncast(const const_node_ptr & ptr) - { return pointer_traits<node_ptr>::const_cast_from(ptr); } - /// @endcond - - public: - static node_ptr begin_node(const const_node_ptr & header) - { return tree_algorithms::begin_node(header); } - - static node_ptr end_node(const const_node_ptr & header) - { return tree_algorithms::end_node(header); } - - //! <b>Requires</b>: node is a node of the tree or an node initialized - //! by init(...). - //! - //! <b>Effects</b>: Returns true if the node is initialized by init(). - //! - //! <b>Complexity</b>: Constant time. - //! - //! <b>Throws</b>: Nothing. - static bool unique(const const_node_ptr & node) - { return tree_algorithms::unique(node); } - - static void unlink(const node_ptr & node) - { tree_algorithms::unlink(node); } - - //! <b>Requires</b>: node1 and node2 can't be header nodes - //! of two trees. - //! - //! <b>Effects</b>: Swaps two nodes. After the function node1 will be inserted - //! in the position node2 before the function. node2 will be inserted in the - //! position node1 had before the function. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: This function will break container ordering invariants if - //! node1 and node2 are not equivalent according to the ordering rules. - //! - //!Experimental function - static void swap_nodes(const node_ptr & node1, const node_ptr & node2) - { - if(node1 == node2) - return; - - node_ptr header1(tree_algorithms::get_header(node1)), header2(tree_algorithms::get_header(node2)); - swap_nodes(node1, header1, node2, header2); - } - - //! <b>Requires</b>: node1 and node2 can't be header nodes - //! of two trees with header header1 and header2. - //! - //! <b>Effects</b>: Swaps two nodes. After the function node1 will be inserted - //! in the position node2 before the function. node2 will be inserted in the - //! position node1 had before the function. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: This function will break container ordering invariants if - //! node1 and node2 are not equivalent according to the ordering rules. - //! - //!Experimental function - static void swap_nodes(const node_ptr & node1, const node_ptr & header1, const node_ptr & node2, const node_ptr & header2) - { tree_algorithms::swap_nodes(node1, header1, node2, header2); } - - //! <b>Requires</b>: node_to_be_replaced must be inserted in a tree - //! and new_node must not be inserted in a tree. - //! - //! <b>Effects</b>: Replaces node_to_be_replaced in its position in the - //! tree with new_node. The tree does not need to be rebalanced - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: This function will break container ordering invariants if - //! 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 - static void replace_node(const node_ptr & node_to_be_replaced, const node_ptr & new_node) - { - if(node_to_be_replaced == new_node) - return; - replace_node(node_to_be_replaced, tree_algorithms::get_header(node_to_be_replaced), new_node); - } - - //! <b>Requires</b>: node_to_be_replaced must be inserted in a tree - //! with header "header" and new_node must not be inserted in a tree. - //! - //! <b>Effects</b>: Replaces node_to_be_replaced in its position in the - //! tree with new_node. The tree does not need to be rebalanced - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: This function will break container ordering invariants if - //! 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 or comparison is needed. - //! - //!Experimental function - static void replace_node(const node_ptr & node_to_be_replaced, const node_ptr & header, const node_ptr & new_node) - { tree_algorithms::replace_node(node_to_be_replaced, header, new_node); } - - //! <b>Requires</b>: p is a node from the tree except the header. - //! - //! <b>Effects</b>: Returns the next node of the tree. - //! - //! <b>Complexity</b>: Average constant time. - //! - //! <b>Throws</b>: Nothing. - static node_ptr next_node(const node_ptr & p) - { return tree_algorithms::next_node(p); } - - //! <b>Requires</b>: p is a node from the tree except the leftmost node. - //! - //! <b>Effects</b>: Returns the previous node of the tree. - //! - //! <b>Complexity</b>: Average constant time. - //! - //! <b>Throws</b>: Nothing. - static node_ptr prev_node(const node_ptr & p) - { return tree_algorithms::prev_node(p); } - - //! <b>Requires</b>: node must not be part of any tree. - //! - //! <b>Effects</b>: After the function unique(node) == true. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Nodes</b>: If node is inserted in a tree, this function corrupts the tree. - static void init(const node_ptr & node) - { tree_algorithms::init(node); } - - //! <b>Requires</b>: node must not be part of any tree. - //! - //! <b>Effects</b>: Initializes the header to represent an empty tree. - //! unique(header) == true. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Nodes</b>: If node is inserted in a tree, this function corrupts the tree. - static void init_header(const node_ptr & header) - { tree_algorithms::init_header(header); } - - //! <b>Requires</b>: "disposer" must be an object function - //! taking a node_ptr parameter and shouldn't throw. - //! - //! <b>Effects</b>: Empties the target tree calling - //! <tt>void disposer::operator()(const node_ptr &)</tt> for every node of the tree - //! except the header. - //! - //! <b>Complexity</b>: Linear to the number of element of the source tree plus the. - //! number of elements of tree target tree when calling this function. - //! - //! <b>Throws</b>: If cloner functor throws. If this happens target nodes are disposed. - template<class Disposer> - static void clear_and_dispose(const node_ptr & header, Disposer disposer) - { tree_algorithms::clear_and_dispose(header, disposer); } - - //! <b>Requires</b>: node is a node of the tree but it's not the header. - //! - //! <b>Effects</b>: Returns the number of nodes of the subtree. - //! - //! <b>Complexity</b>: Linear time. - //! - //! <b>Throws</b>: Nothing. - static std::size_t count(const const_node_ptr & node) - { return tree_algorithms::count(node); } - - //! <b>Requires</b>: header is the header node of the tree. - //! - //! <b>Effects</b>: Returns the number of nodes above the header. - //! - //! <b>Complexity</b>: Linear time. - //! - //! <b>Throws</b>: Nothing. - static std::size_t size(const const_node_ptr & header) - { return tree_algorithms::size(header); } - - //! <b>Requires</b>: header1 and header2 must be the header nodes - //! of two trees. - //! - //! <b>Effects</b>: Swaps two trees. After the function header1 will contain - //! links to the second tree and header2 will have links to the first tree. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - static void swap_tree(const node_ptr & header1, const node_ptr & header2) - { return tree_algorithms::swap_tree(header1, header2); } - - //! <b>Requires</b>: "header" must be the header node of a tree. - //! "commit_data" must have been obtained from a previous call to - //! "insert_unique_check". No objects should have been inserted or erased - //! from the set between the "insert_unique_check" that filled "commit_data" - //! and the call to "insert_commit". - //! - //! - //! <b>Effects</b>: Inserts new_node in the set using the information obtained - //! from the "commit_data" that a previous "insert_check" filled. - //! - //! <b>Complexity</b>: Constant time. - //! - //! <b>Throws</b>: Nothing. - //! - //! <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. - static void insert_unique_commit - (const node_ptr & header, const node_ptr & new_value, const insert_commit_data &commit_data) - { tree_algorithms::insert_unique_commit(header, new_value, commit_data); } - - //! <b>Requires</b>: "header" must be the header node of a tree. - //! KeyNodePtrCompare is a function object that induces a strict weak - //! ordering compatible with the strict weak ordering used to create the - //! the tree. NodePtrCompare compares KeyType with a node_ptr. - //! - //! <b>Effects</b>: Checks if there is an equivalent node to "key" in the - //! tree according to "comp" and obtains the needed information to realize - //! a constant-time node insertion if there is no equivalent node. - //! - //! <b>Returns</b>: If there is an equivalent value - //! returns a pair containing a node_ptr to the already present node - //! and false. If there is not equivalent key can be inserted returns true - //! in the returned pair's boolean and fills "commit_data" that is meant to - //! be used with the "insert_commit" function to achieve a constant-time - //! insertion function. - //! - //! <b>Complexity</b>: Average complexity is at most logarithmic. - //! - //! <b>Throws</b>: If "comp" throws. - //! - //! <b>Notes</b>: This function is used to improve performance when constructing - //! a node is expensive and the user does not want to have two equivalent nodes - //! in the tree: if there is an equivalent value - //! the constructed object must be discarded. Many times, the part of the - //! node that is used to impose the order is much cheaper to construct - //! than the node and this function offers the possibility to use that part - //! to check if the insertion will be successful. - //! - //! If the check is successful, the user can construct the node and use - //! "insert_commit" to insert the node in constant-time. This gives a total - //! logarithmic complexity to the insertion: check(O(log(N)) + commit(O(1)). - //! - //! "commit_data" remains valid for a subsequent "insert_unique_commit" only - //! if no more objects are inserted or erased from the set. - template<class KeyType, class KeyNodePtrCompare> - static std::pair<node_ptr, bool> insert_unique_check - (const node_ptr & header, const KeyType &key - ,KeyNodePtrCompare comp, insert_commit_data &commit_data) - { - splay_down(header, key, comp); - return tree_algorithms::insert_unique_check(header, key, comp, commit_data); - } - - template<class KeyType, class KeyNodePtrCompare> - static std::pair<node_ptr, bool> insert_unique_check - (const node_ptr & header, const node_ptr &hint, const KeyType &key - ,KeyNodePtrCompare comp, insert_commit_data &commit_data) - { - splay_down(header, key, comp); - return tree_algorithms::insert_unique_check(header, hint, key, comp, commit_data); - } - - static bool is_header(const const_node_ptr & p) - { return tree_algorithms::is_header(p); } - - //! <b>Requires</b>: "header" must be the header node of a tree. - //! KeyNodePtrCompare is a function object that induces a strict weak - //! ordering compatible with the strict weak ordering used to create the - //! the tree. KeyNodePtrCompare can compare KeyType with tree's node_ptrs. - //! - //! <b>Effects</b>: Returns an node_ptr to the element that is equivalent to - //! "key" according to "comp" or "header" if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If "comp" throws. - template<class KeyType, class KeyNodePtrCompare> - static node_ptr find - (const const_node_ptr & header, const KeyType &key, KeyNodePtrCompare comp, bool splay = true) - { - if(splay) - splay_down(uncast(header), key, comp); - node_ptr end = uncast(header); - node_ptr y = lower_bound(header, key, comp, false); - node_ptr r = (y == end || comp(key, y)) ? end : y; - return r; - } - - //! <b>Requires</b>: "header" must be the header node of a tree. - //! KeyNodePtrCompare is a function object that induces a strict weak - //! ordering compatible with the strict weak ordering used to create the - //! the tree. KeyNodePtrCompare can compare KeyType with tree's node_ptrs. - //! - //! <b>Effects</b>: Returns an a pair of node_ptr delimiting a range containing - //! all elements that are equivalent to "key" according to "comp" or an - //! empty range that indicates the position where those elements would be - //! if they there are no equivalent elements. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If "comp" throws. - template<class KeyType, class KeyNodePtrCompare> - static std::pair<node_ptr, node_ptr> equal_range - (const const_node_ptr & header, const KeyType &key, KeyNodePtrCompare comp, bool splay = true) - { - //if(splay) - //splay_down(uncast(header), key, comp); - std::pair<node_ptr, node_ptr> ret = - tree_algorithms::equal_range(header, key, comp); - - if(splay) - splay_up(ret.first, uncast(header)); - return ret; - } - - //! <b>Requires</b>: "header" must be the header node of a tree. - //! KeyNodePtrCompare is a function object that induces a strict weak - //! ordering compatible with the strict weak ordering used to create the - //! the tree. KeyNodePtrCompare can compare KeyType with tree's node_ptrs. - //! - //! <b>Effects</b>: Returns an node_ptr to the first element that is - //! not less than "key" according to "comp" or "header" if that element does - //! not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If "comp" throws. - template<class KeyType, class KeyNodePtrCompare> - static node_ptr lower_bound - (const const_node_ptr & header, const KeyType &key, KeyNodePtrCompare comp, bool splay = true) - { - //if(splay) - //splay_down(uncast(header), key, comp); - node_ptr y = tree_algorithms::lower_bound(header, key, comp); - if(splay) - splay_up(y, uncast(header)); - return y; - } - - //! <b>Requires</b>: "header" must be the header node of a tree. - //! KeyNodePtrCompare is a function object that induces a strict weak - //! ordering compatible with the strict weak ordering used to create the - //! the tree. KeyNodePtrCompare can compare KeyType with tree's node_ptrs. - //! - //! <b>Effects</b>: Returns an node_ptr to the first element that is greater - //! than "key" according to "comp" or "header" if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If "comp" throws. - template<class KeyType, class KeyNodePtrCompare> - static node_ptr upper_bound - (const const_node_ptr & header, const KeyType &key, KeyNodePtrCompare comp, bool splay = true) - { - //if(splay) - //splay_down(uncast(header), key, comp); - node_ptr y = tree_algorithms::upper_bound(header, key, comp); - if(splay) - splay_up(y, uncast(header)); - return y; - } - - //! <b>Requires</b>: "header" must be the header node of a tree. - //! NodePtrCompare is a function object that induces a strict weak - //! ordering compatible with the strict weak ordering used to create the - //! the tree. NodePtrCompare compares two node_ptrs. "hint" is node from - //! the "header"'s tree. - //! - //! <b>Effects</b>: Inserts new_node into the tree, using "hint" as a hint to - //! where it will be inserted. If "hint" is the upper_bound - //! the insertion takes constant time (two comparisons in the worst case). - //! - //! <b>Complexity</b>: Logarithmic in general, but it is amortized - //! constant time if new_node is inserted immediately before "hint". - //! - //! <b>Throws</b>: If "comp" throws. - template<class NodePtrCompare> - static node_ptr insert_equal - (const node_ptr & header, const node_ptr & hint, const node_ptr & new_node, NodePtrCompare comp) - { - splay_down(header, new_node, comp); - return tree_algorithms::insert_equal(header, hint, new_node, comp); - } - - - //! <b>Requires</b>: "header" must be the header node of a tree. - //! "pos" must be a valid iterator or header (end) node. - //! "pos" must be an iterator pointing to the successor to "new_node" - //! once inserted according to the order of already inserted nodes. This function does not - //! check "pos" and this precondition must be guaranteed by the caller. - //! - //! <b>Effects</b>: Inserts new_node into the tree before "pos". - //! - //! <b>Complexity</b>: Constant-time. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: If "pos" is not the successor of the newly inserted "new_node" - //! tree invariants might be broken. - static node_ptr insert_before - (const node_ptr & header, const node_ptr & pos, const node_ptr & new_node) - { - tree_algorithms::insert_before(header, pos, new_node); - splay_up(new_node, header); - return new_node; - } - - //! <b>Requires</b>: "header" must be the header node of a tree. - //! "new_node" must be, according to the used ordering no less than the - //! greatest inserted key. - //! - //! <b>Effects</b>: Inserts new_node into the tree before "pos". - //! - //! <b>Complexity</b>: Constant-time. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: If "new_node" is less than the greatest inserted key - //! tree invariants are broken. This function is slightly faster than - //! using "insert_before". - static void push_back(const node_ptr & header, const node_ptr & new_node) - { - tree_algorithms::push_back(header, new_node); - splay_up(new_node, header); - } - - //! <b>Requires</b>: "header" must be the header node of a tree. - //! "new_node" must be, according to the used ordering, no greater than the - //! lowest inserted key. - //! - //! <b>Effects</b>: Inserts new_node into the tree before "pos". - //! - //! <b>Complexity</b>: Constant-time. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: If "new_node" is greater than the lowest inserted key - //! tree invariants are broken. This function is slightly faster than - //! using "insert_before". - static void push_front(const node_ptr & header, const node_ptr & new_node) - { - tree_algorithms::push_front(header, new_node); - splay_up(new_node, header); - } - - //! <b>Requires</b>: "header" must be the header node of a tree. - //! NodePtrCompare is a function object that induces a strict weak - //! ordering compatible with the strict weak ordering used to create the - //! the tree. NodePtrCompare compares two node_ptrs. - //! - //! <b>Effects</b>: Inserts new_node into the tree before the upper bound - //! according to "comp". - //! - //! <b>Complexity</b>: Average complexity for insert element is at - //! most logarithmic. - //! - //! <b>Throws</b>: If "comp" throws. - template<class NodePtrCompare> - static node_ptr insert_equal_upper_bound - (const node_ptr & header, const node_ptr & new_node, NodePtrCompare comp) - { - splay_down(header, new_node, comp); - return tree_algorithms::insert_equal_upper_bound(header, new_node, comp); - } - - //! <b>Requires</b>: "header" must be the header node of a tree. - //! NodePtrCompare is a function object that induces a strict weak - //! ordering compatible with the strict weak ordering used to create the - //! the tree. NodePtrCompare compares two node_ptrs. - //! - //! <b>Effects</b>: Inserts new_node into the tree before the lower bound - //! according to "comp". - //! - //! <b>Complexity</b>: Average complexity for insert element is at - //! most logarithmic. - //! - //! <b>Throws</b>: If "comp" throws. - template<class NodePtrCompare> - static node_ptr insert_equal_lower_bound - (const node_ptr & header, const node_ptr & new_node, NodePtrCompare comp) - { - splay_down(header, new_node, comp); - return tree_algorithms::insert_equal_lower_bound(header, new_node, comp); - } - - //! <b>Requires</b>: "cloner" must be a function - //! object taking a node_ptr and returning a new cloned node of it. "disposer" must - //! take a node_ptr and shouldn't throw. - //! - //! <b>Effects</b>: First empties target tree calling - //! <tt>void disposer::operator()(const node_ptr &)</tt> for every node of the tree - //! except the header. - //! - //! Then, duplicates the entire tree pointed by "source_header" cloning each - //! source node with <tt>node_ptr Cloner::operator()(const node_ptr &)</tt> to obtain - //! the nodes of the target tree. If "cloner" throws, the cloned target nodes - //! are disposed using <tt>void disposer(const node_ptr &)</tt>. - //! - //! <b>Complexity</b>: Linear to the number of element of the source tree plus the. - //! number of elements of tree target tree when calling this function. - //! - //! <b>Throws</b>: If cloner functor throws. If this happens target nodes are disposed. - template <class Cloner, class Disposer> - static void clone - (const const_node_ptr & source_header, const node_ptr & target_header, Cloner cloner, Disposer disposer) - { tree_algorithms::clone(source_header, target_header, cloner, disposer); } - - // delete node | complexity : constant | exception : nothrow - static void erase(const node_ptr & header, const node_ptr & z, bool splay = true) - { -// node_base* n = t->right; -// if( t->left != node_ptr() ){ -// node_base* l = t->previous(); -// splay_up( l , t ); -// n = t->left; -// n->right = t->right; -// if( n->right != node_ptr() ) -// n->right->parent = n; -// } -// -// if( n != node_ptr() ) -// n->parent = t->parent; -// -// if( t->parent->left == t ) -// t->parent->left = n; -// else // must be ( t->parent->right == t ) -// t->parent->right = n; -// -// if( data_->parent == t ) -// data_->parent = find_leftmost(); - //posibility 1 - if(splay && NodeTraits::get_left(z)){ - splay_up(prev_node(z), header); - } - /* - //possibility 2 - if(splay && NodeTraits::get_left(z) != node_ptr() ){ - node_ptr l = NodeTraits::get_left(z); - splay_up(l, header); - }*//* - if(splay && NodeTraits::get_left(z) != node_ptr() ){ - node_ptr l = prev_node(z); - splay_up_impl(l, z); - }*/ - /* - //possibility 4 - if(splay){ - splay_up(z, header); - }*/ - - //if(splay) - //splay_up(z, header); - tree_algorithms::erase(header, z); - } - - // bottom-up splay, use data_ as parent for n | complexity : logarithmic | exception : nothrow - static void splay_up(const node_ptr & node, const node_ptr & header) - { - // If (node == header) do a splay for the right most node instead - // this is to boost performance of equal_range/count on equivalent containers in the case - // where there are many equal elements at the end - node_ptr n((node == header) ? NodeTraits::get_right(header) : node); - node_ptr t(header); - - if( n == t ) return; - - for( ;; ){ - node_ptr p(NodeTraits::get_parent(n)); - node_ptr g(NodeTraits::get_parent(p)); - - if( p == t ) break; - - if( g == t ){ - // zig - rotate(n); - } - else if ((NodeTraits::get_left(p) == n && NodeTraits::get_left(g) == p) || - (NodeTraits::get_right(p) == n && NodeTraits::get_right(g) == p) ){ - // zig-zig - rotate(p); - rotate(n); - } - else{ - // zig-zag - rotate(n); - rotate(n); - } - } - } - - // top-down splay | complexity : logarithmic | exception : strong, note A - template<class KeyType, class KeyNodePtrCompare> - static node_ptr splay_down(const node_ptr & header, const KeyType &key, KeyNodePtrCompare comp) - { - if(!NodeTraits::get_parent(header)) - return header; - //Most splay tree implementations use a dummy/null node to implement. - //this function. This has some problems for a generic library like Intrusive: - // - // * The node might not have a default constructor. - // * The default constructor could throw. - // - //We already have a header node. Leftmost and rightmost nodes of the tree - //are not changed when splaying (because the invariants of the tree don't - //change) We can back up them, use the header as the null node and - //reassign old values after the function has been completed. - node_ptr t = NodeTraits::get_parent(header); - //Check if tree has a single node - if(!NodeTraits::get_left(t) && !NodeTraits::get_right(t)) - return t; - //Backup leftmost/rightmost - node_ptr leftmost (NodeTraits::get_left(header)); - node_ptr rightmost(NodeTraits::get_right(header)); - { - detail::splaydown_rollback<NodeTraits> rollback(&t, header, leftmost, rightmost); - node_ptr null = header; - node_ptr l = null; - node_ptr r = null; - - for( ;; ){ - if(comp(key, t)){ - if(NodeTraits::get_left(t) == node_ptr() ) - break; - if(comp(key, NodeTraits::get_left(t))){ - t = tree_algorithms::rotate_right(t); - - if(NodeTraits::get_left(t) == node_ptr()) - break; - link_right(t, r); - } - else if(comp(NodeTraits::get_left(t), key)){ - link_right(t, r); - - if(NodeTraits::get_right(t) == node_ptr() ) - break; - link_left(t, l); - } - else{ - link_right(t, r); - } - } - else if(comp(t, key)){ - if(NodeTraits::get_right(t) == node_ptr() ) - break; - - if(comp(NodeTraits::get_right(t), key)){ - t = tree_algorithms::rotate_left( t ); - - if(NodeTraits::get_right(t) == node_ptr() ) - break; - link_left(t, l); - } - else if(comp(key, NodeTraits::get_right(t))){ - link_left(t, l); - - if(NodeTraits::get_left(t) == node_ptr()) - break; - - link_right(t, r); - } - else{ - link_left(t, l); - } - } - else{ - break; - } - } - - assemble(t, l, r, null); - rollback.release(); - } - - //t is the current root - NodeTraits::set_parent(header, t); - NodeTraits::set_parent(t, header); - //Recover leftmost/rightmost pointers - NodeTraits::set_left (header, leftmost); - NodeTraits::set_right(header, rightmost); - return t; - } - - //! <b>Requires</b>: header must be the header of a tree. - //! - //! <b>Effects</b>: Rebalances the tree. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Linear. - static void rebalance(const node_ptr & header) - { tree_algorithms::rebalance(header); } - - //! <b>Requires</b>: old_root is a node of a tree. - //! - //! <b>Effects</b>: Rebalances the subtree rooted at old_root. - //! - //! <b>Returns</b>: The new root of the subtree. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Linear. - static node_ptr rebalance_subtree(const node_ptr & old_root) - { return tree_algorithms::rebalance_subtree(old_root); } - - - //! <b>Requires</b>: "n" must be a node inserted in a tree. - //! - //! <b>Effects</b>: Returns a pointer to the header node of the tree. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: Nothing. - static node_ptr get_header(const node_ptr & n) - { return tree_algorithms::get_header(n); } - - private: - - /// @cond - - // assemble the three sub-trees into new tree pointed to by t | complexity : constant | exception : nothrow - static void assemble(const node_ptr &t, const node_ptr & l, const node_ptr & r, const const_node_ptr & null_node ) - { - NodeTraits::set_right(l, NodeTraits::get_left(t)); - NodeTraits::set_left(r, NodeTraits::get_right(t)); - - if(NodeTraits::get_right(l) != node_ptr()){ - NodeTraits::set_parent(NodeTraits::get_right(l), l); - } - - if(NodeTraits::get_left(r) != node_ptr()){ - NodeTraits::set_parent(NodeTraits::get_left(r), r); - } - - NodeTraits::set_left (t, NodeTraits::get_right(null_node)); - NodeTraits::set_right(t, NodeTraits::get_left(null_node)); - - if( NodeTraits::get_left(t) != node_ptr() ){ - NodeTraits::set_parent(NodeTraits::get_left(t), t); - } - - if( NodeTraits::get_right(t) ){ - NodeTraits::set_parent(NodeTraits::get_right(t), t); - } - } - - // break link to left child node and attach it to left tree pointed to by l | complexity : constant | exception : nothrow - static void link_left(node_ptr & t, node_ptr & l) - { - NodeTraits::set_right(l, t); - NodeTraits::set_parent(t, l); - l = t; - t = NodeTraits::get_right(t); - } - - // break link to right child node and attach it to right tree pointed to by r | complexity : constant | exception : nothrow - static void link_right(node_ptr & t, node_ptr & r) - { - NodeTraits::set_left(r, t); - NodeTraits::set_parent(t, r); - r = t; - t = NodeTraits::get_left(t); - } - - // rotate n with its parent | complexity : constant | exception : nothrow - static void rotate(const node_ptr & n) - { - node_ptr p = NodeTraits::get_parent(n); - node_ptr g = NodeTraits::get_parent(p); - //Test if g is header before breaking tree - //invariants that would make is_header invalid - bool g_is_header = is_header(g); - - if(NodeTraits::get_left(p) == n){ - NodeTraits::set_left(p, NodeTraits::get_right(n)); - if(NodeTraits::get_left(p) != node_ptr()) - NodeTraits::set_parent(NodeTraits::get_left(p), p); - NodeTraits::set_right(n, p); - } - else{ // must be ( p->right == n ) - NodeTraits::set_right(p, NodeTraits::get_left(n)); - if(NodeTraits::get_right(p) != node_ptr()) - NodeTraits::set_parent(NodeTraits::get_right(p), p); - NodeTraits::set_left(n, p); - } - - NodeTraits::set_parent(p, n); - NodeTraits::set_parent(n, g); - - if(g_is_header){ - if(NodeTraits::get_parent(g) == p) - NodeTraits::set_parent(g, n); - else{//must be ( g->right == p ) - BOOST_INTRUSIVE_INVARIANT_ASSERT(false); - NodeTraits::set_right(g, n); - } - } - else{ - if(NodeTraits::get_left(g) == p) - NodeTraits::set_left(g, n); - else //must be ( g->right == p ) - NodeTraits::set_right(g, n); - } - } - - /// @endcond -}; - -} //namespace intrusive -} //namespace boost - -#include <boost/intrusive/detail/config_end.hpp> - -#endif //BOOST_INTRUSIVE_SPLAYTREE_ALGORITHMS_HPP diff --git a/src/third_party/boost/boost/intrusive/treap.hpp b/src/third_party/boost/boost/intrusive/treap.hpp deleted file mode 100644 index cbf81c180e9..00000000000 --- a/src/third_party/boost/boost/intrusive/treap.hpp +++ /dev/null @@ -1,1784 +0,0 @@ -///////////////////////////////////////////////////////////////////////////// -// -// (C) Copyright Ion Gaztanaga 2008 -// -// Distributed under the Boost Software License, Version 1.0. -// (See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) -// -// See http://www.boost.org/libs/intrusive for documentation. -// -///////////////////////////////////////////////////////////////////////////// -#ifndef BOOST_INTRUSIVE_TRIE_HPP -#define BOOST_INTRUSIVE_TRIE_HPP - -#include <boost/intrusive/detail/config_begin.hpp> -#include <algorithm> -#include <cstddef> -#include <functional> -#include <iterator> -#include <utility> - -#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> -#include <boost/intrusive/detail/ebo_functor_holder.hpp> -#include <boost/intrusive/pointer_traits.hpp> -#include <boost/intrusive/detail/clear_on_destructor_base.hpp> -#include <boost/intrusive/detail/utilities.hpp> -#include <boost/intrusive/pointer_traits.hpp> -#include <boost/intrusive/options.hpp> -#include <boost/intrusive/detail/mpl.hpp> -#include <boost/intrusive/treap_algorithms.hpp> -#include <boost/intrusive/link_mode.hpp> -#include <boost/move/move.hpp> -#include <boost/intrusive/priority_compare.hpp> - -namespace boost { -namespace intrusive { - -/// @cond - -template <class ValueTraits, class Compare, class PrioCompare, class SizeType, bool ConstantTimeSize> -struct treap_setopt -{ - typedef ValueTraits value_traits; - typedef Compare compare; - typedef PrioCompare priority_compare; - typedef SizeType size_type; - static const bool constant_time_size = ConstantTimeSize; -}; - -template <class T> -struct treap_set_defaults - : pack_options - < none - , base_hook<detail::default_bs_set_hook> - , constant_time_size<true> - , size_type<std::size_t> - , compare<std::less<T> > - , priority<boost::intrusive::priority_compare<T> > - >::type -{}; - -/// @endcond - -//! The class template treap is an intrusive treap container that -//! is used to construct intrusive set and multiset containers. The no-throw -//! guarantee holds only, if the value_compare object and priority_compare object -//! don't throw. -//! -//! The template parameter \c T is the type to be managed by the container. -//! The user can specify additional options and if no options are provided -//! default options are used. -//! -//! The container supports the following options: -//! \c base_hook<>/member_hook<>/value_traits<>, -//! \c constant_time_size<>, \c size_type<>, -//! \c compare<> and \c priority_compare<> -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -class treap_impl - : private detail::clear_on_destructor_base<treap_impl<Config> > -{ - template<class C> friend class detail::clear_on_destructor_base; - public: - typedef typename Config::value_traits value_traits; - /// @cond - static const bool external_value_traits = - detail::external_value_traits_is_true<value_traits>::value; - typedef typename detail::eval_if_c - < external_value_traits - , detail::eval_value_traits<value_traits> - , detail::identity<value_traits> - >::type real_value_traits; - /// @endcond - typedef typename real_value_traits::pointer pointer; - typedef typename real_value_traits::const_pointer const_pointer; - typedef typename pointer_traits<pointer>::element_type value_type; - typedef typename pointer_traits<pointer>::reference reference; - typedef typename pointer_traits<const_pointer>::reference const_reference; - typedef typename pointer_traits<pointer>::difference_type difference_type; - typedef value_type key_type; - typedef typename Config::size_type size_type; - typedef typename Config::compare value_compare; - typedef typename Config::priority_compare priority_compare; - typedef value_compare key_compare; - typedef tree_iterator<treap_impl, false> iterator; - typedef tree_iterator<treap_impl, true> const_iterator; - typedef boost::intrusive::detail::reverse_iterator<iterator> reverse_iterator; - typedef boost::intrusive::detail::reverse_iterator<const_iterator>const_reverse_iterator; - typedef typename real_value_traits::node_traits node_traits; - typedef typename node_traits::node node; - typedef typename pointer_traits - <pointer>::template rebind_pointer - <node>::type node_ptr; - typedef typename pointer_traits - <pointer>::template rebind_pointer - <const node>::type const_node_ptr; - typedef treap_algorithms<node_traits> node_algorithms; - - static const bool constant_time_size = Config::constant_time_size; - static const bool stateful_value_traits = detail::is_stateful_value_traits<real_value_traits>::value; - - /// @cond - private: - typedef detail::size_holder<constant_time_size, size_type> size_traits; - - //noncopyable - BOOST_MOVABLE_BUT_NOT_COPYABLE(treap_impl) - - enum { safemode_or_autounlink = - (int)real_value_traits::link_mode == (int)auto_unlink || - (int)real_value_traits::link_mode == (int)safe_link }; - - //Constant-time size is incompatible with auto-unlink hooks! - BOOST_STATIC_ASSERT(!(constant_time_size && ((int)real_value_traits::link_mode == (int)auto_unlink))); - - struct header_plus_size : public size_traits - { node header_; }; - - struct node_plus_pred_t : public detail::ebo_functor_holder<value_compare> - { - node_plus_pred_t(const value_compare &comp, const priority_compare &p_comp) - : detail::ebo_functor_holder<value_compare>(comp) - , header_plus_priority_size_(p_comp) - {} - struct header_plus_priority_size - : public detail::ebo_functor_holder<priority_compare> - { - header_plus_priority_size(const priority_compare &p_comp) - : detail::ebo_functor_holder<priority_compare>(p_comp) - {} - header_plus_size header_plus_size_; - } header_plus_priority_size_; - }; - - struct data_t : public treap_impl::value_traits - { - typedef typename treap_impl::value_traits value_traits; - data_t(const value_compare & comp, const priority_compare &pcomp, const value_traits &val_traits) - : value_traits(val_traits), node_plus_pred_(comp, pcomp) - {} - node_plus_pred_t node_plus_pred_; - } data_; - - const value_compare &priv_comp() const - { return data_.node_plus_pred_.get(); } - - value_compare &priv_comp() - { return data_.node_plus_pred_.get(); } - - const priority_compare &priv_pcomp() const - { return data_.node_plus_pred_.header_plus_priority_size_.get(); } - - priority_compare &priv_pcomp() - { return data_.node_plus_pred_.header_plus_priority_size_.get(); } - - const value_traits &priv_value_traits() const - { return data_; } - - value_traits &priv_value_traits() - { return data_; } - - node_ptr priv_header_ptr() - { return pointer_traits<node_ptr>::pointer_to(data_.node_plus_pred_.header_plus_priority_size_.header_plus_size_.header_); } - - const_node_ptr priv_header_ptr() const - { return pointer_traits<const_node_ptr>::pointer_to(data_.node_plus_pred_.header_plus_priority_size_.header_plus_size_.header_); } - - static node_ptr uncast(const const_node_ptr & ptr) - { return pointer_traits<node_ptr>::const_cast_from(ptr); } - - size_traits &priv_size_traits() - { return data_.node_plus_pred_.header_plus_priority_size_.header_plus_size_; } - - const size_traits &priv_size_traits() const - { return data_.node_plus_pred_.header_plus_priority_size_.header_plus_size_; } - - const real_value_traits &get_real_value_traits(detail::bool_<false>) const - { return data_; } - - const real_value_traits &get_real_value_traits(detail::bool_<true>) const - { return data_.get_value_traits(*this); } - - real_value_traits &get_real_value_traits(detail::bool_<false>) - { return data_; } - - real_value_traits &get_real_value_traits(detail::bool_<true>) - { return data_.get_value_traits(*this); } - - /// @endcond - - public: - - const real_value_traits &get_real_value_traits() const - { return this->get_real_value_traits(detail::bool_<external_value_traits>()); } - - real_value_traits &get_real_value_traits() - { return this->get_real_value_traits(detail::bool_<external_value_traits>()); } - - typedef typename node_algorithms::insert_commit_data insert_commit_data; - - //! <b>Effects</b>: Constructs an empty treap. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: If value_traits::node_traits::node - //! constructor throws (this does not happen with predefined Boost.Intrusive hooks) - //! or the copy constructor of the value_compare/priority_compare objects throw. Basic guarantee. - treap_impl( const value_compare &cmp = value_compare() - , const priority_compare &pcmp = priority_compare() - , const value_traits &v_traits = value_traits()) - : data_(cmp, pcmp, v_traits) - { - node_algorithms::init_header(this->priv_header_ptr()); - this->priv_size_traits().set_size(size_type(0)); - } - - //! <b>Requires</b>: Dereferencing iterator must yield an lvalue of type value_type. - //! cmp must be a comparison function that induces a strict weak ordering. - //! - //! <b>Effects</b>: Constructs an empty treap and inserts elements from - //! [b, e). - //! - //! <b>Complexity</b>: Linear in N if [b, e) is already sorted using - //! comp and otherwise N * log N, where N is the distance between first and last. - //! - //! <b>Throws</b>: If value_traits::node_traits::node - //! constructor throws (this does not happen with predefined Boost.Intrusive hooks) - //! or the copy constructor/operator() of the value_compare/priority_compare objects - //! throw. Basic guarantee. - template<class Iterator> - treap_impl( bool unique, Iterator b, Iterator e - , const value_compare &cmp = value_compare() - , const priority_compare &pcmp = priority_compare() - , const value_traits &v_traits = value_traits()) - : data_(cmp, pcmp, v_traits) - { - node_algorithms::init_header(this->priv_header_ptr()); - this->priv_size_traits().set_size(size_type(0)); - if(unique) - this->insert_unique(b, e); - else - this->insert_equal(b, e); - } - - //! <b>Effects</b>: to-do - //! - treap_impl(BOOST_RV_REF(treap_impl) x) - : data_( ::boost::move(x.priv_comp()) - , ::boost::move(x.priv_pcomp()) - , ::boost::move(x.priv_value_traits())) - { - node_algorithms::init_header(this->priv_header_ptr()); - this->priv_size_traits().set_size(size_type(0)); - this->swap(x); - } - - //! <b>Effects</b>: to-do - //! - treap_impl& operator=(BOOST_RV_REF(treap_impl) x) - { this->swap(x); return *this; } - - //! <b>Effects</b>: Detaches all elements from this. The objects in the set - //! are not deleted (i.e. no destructors are called), but the nodes according to - //! the value_traits template parameter are reinitialized and thus can be reused. - //! - //! <b>Complexity</b>: Linear to elements contained in *this - //! if constant-time size option is disabled. Constant time otherwise. - //! - //! <b>Throws</b>: Nothing. - ~treap_impl() - {} - - //! <b>Effects</b>: Returns an iterator pointing to the beginning of the treap. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - iterator begin() - { return iterator (node_traits::get_left(this->priv_header_ptr()), this); } - - //! <b>Effects</b>: Returns a const_iterator pointing to the beginning of the treap. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_iterator begin() const - { return this->cbegin(); } - - //! <b>Effects</b>: Returns a const_iterator pointing to the beginning of the treap. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_iterator cbegin() const - { return const_iterator (node_traits::get_left(this->priv_header_ptr()), this); } - - //! <b>Effects</b>: Returns an iterator pointing to the end of the treap. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - iterator end() - { return iterator (this->priv_header_ptr(), this); } - - //! <b>Effects</b>: Returns a const_iterator pointing to the end of the treap. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_iterator end() const - { return this->cend(); } - - //! <b>Effects</b>: Returns a const_iterator pointing to the end of the treap. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_iterator cend() const - { return const_iterator (uncast(this->priv_header_ptr()), this); } - - - //! <b>Effects</b>: Returns an iterator pointing to the highest priority object of the treap. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - iterator top() - { return this->empty() ? this->end() : iterator (node_traits::get_parent(this->priv_header_ptr()), this); } - - //! <b>Effects</b>: Returns a const_iterator pointing to the highest priority object of the treap.. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_iterator top() const - { return this->ctop(); } - - //! <b>Effects</b>: Returns a const_iterator pointing to the highest priority object of the treap.. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_iterator ctop() const - { return this->empty() ? this->cend() : const_iterator (node_traits::get_parent(this->priv_header_ptr()), this); } - - //! <b>Effects</b>: Returns a reverse_iterator pointing to the beginning of the - //! reversed treap. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - reverse_iterator rbegin() - { return reverse_iterator(this->end()); } - - //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning - //! of the reversed treap. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_reverse_iterator rbegin() const - { return const_reverse_iterator(this->end()); } - - //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning - //! of the reversed treap. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_reverse_iterator crbegin() const - { return const_reverse_iterator(this->end()); } - - //! <b>Effects</b>: Returns a reverse_iterator pointing to the end - //! of the reversed treap. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - reverse_iterator rend() - { return reverse_iterator(this->begin()); } - - //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the end - //! of the reversed treap. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_reverse_iterator rend() const - { return const_reverse_iterator(this->begin()); } - - //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the end - //! of the reversed treap. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_reverse_iterator crend() const - { return const_reverse_iterator(this->begin()); } - - //! <b>Effects</b>: Returns a reverse_iterator pointing to the highest priority object of the - //! reversed treap. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - reverse_iterator rtop() - { return reverse_iterator(this->top()); } - - //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the highest priority objec - //! of the reversed treap. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_reverse_iterator rtop() const - { return const_reverse_iterator(this->top()); } - - //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the highest priority object - //! of the reversed treap. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_reverse_iterator crtop() const - { return const_reverse_iterator(this->top()); } - - //! <b>Precondition</b>: end_iterator must be a valid end iterator - //! of treap. - //! - //! <b>Effects</b>: Returns a const reference to the treap associated to the end iterator - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - static treap_impl &container_from_end_iterator(iterator end_iterator) - { return priv_container_from_end_iterator(end_iterator); } - - //! <b>Precondition</b>: end_iterator must be a valid end const_iterator - //! of treap. - //! - //! <b>Effects</b>: Returns a const reference to the treap associated to the iterator - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - static const treap_impl &container_from_end_iterator(const_iterator end_iterator) - { return priv_container_from_end_iterator(end_iterator); } - - //! <b>Precondition</b>: it must be a valid iterator - //! of treap. - //! - //! <b>Effects</b>: Returns a const reference to the treap associated to the iterator - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Logarithmic. - static treap_impl &container_from_iterator(iterator it) - { return priv_container_from_iterator(it); } - - //! <b>Precondition</b>: it must be a valid end const_iterator - //! of treap. - //! - //! <b>Effects</b>: Returns a const reference to the treap associated to the end iterator - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Logarithmic. - static const treap_impl &container_from_iterator(const_iterator it) - { return priv_container_from_iterator(it); } - - //! <b>Effects</b>: Returns the value_compare object used by the treap. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: If value_compare copy-constructor throws. - value_compare value_comp() const - { return this->priv_comp(); } - - //! <b>Effects</b>: Returns the priority_compare object used by the treap. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: If priority_compare copy-constructor throws. - priority_compare priority_comp() const - { return this->priv_pcomp(); } - - //! <b>Effects</b>: Returns true if the container is empty. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - bool empty() const - { return node_algorithms::unique(this->priv_header_ptr()); } - - //! <b>Effects</b>: Returns the number of elements stored in the treap. - //! - //! <b>Complexity</b>: Linear to elements contained in *this - //! if constant-time size option is disabled. Constant time otherwise. - //! - //! <b>Throws</b>: Nothing. - size_type size() const - { - if(constant_time_size) - return this->priv_size_traits().get_size(); - else{ - return (size_type)node_algorithms::size(this->priv_header_ptr()); - } - } - - //! <b>Effects</b>: Swaps the contents of two treaps. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: If the comparison functor's swap call throws. - void swap(treap_impl& other) - { - //This can throw - using std::swap; - swap(priv_comp(), priv_comp()); - swap(priv_pcomp(), priv_pcomp()); - //These can't throw - node_algorithms::swap_tree(this->priv_header_ptr(), other.priv_header_ptr()); - if(constant_time_size){ - size_type backup = this->priv_size_traits().get_size(); - this->priv_size_traits().set_size(other.priv_size_traits().get_size()); - other.priv_size_traits().set_size(backup); - } - } - - //! <b>Requires</b>: value must be an lvalue - //! - //! <b>Effects</b>: Inserts value into the treap before the upper bound. - //! - //! <b>Complexity</b>: Average complexity for insert element is at - //! most logarithmic. - //! - //! <b>Throws</b>: If the internal value_compare or priority_compare functions throw. Strong guarantee. - //! - //! <b>Note</b>: Does not affect the validity of iterators and references. - //! No copy-constructors are called. - iterator insert_equal(reference value) - { - detail::key_nodeptr_comp<value_compare, treap_impl> - key_node_comp(priv_comp(), this); - detail::key_nodeptr_comp<priority_compare, treap_impl> - key_node_pcomp(priv_pcomp(), this); - node_ptr to_insert(get_real_value_traits().to_node_ptr(value)); - if(safemode_or_autounlink) - BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert)); - iterator ret(node_algorithms::insert_equal_upper_bound - (this->priv_header_ptr(), to_insert, key_node_comp, key_node_pcomp), this); - this->priv_size_traits().increment(); - return ret; - } - - //! <b>Requires</b>: value must be an lvalue, and "hint" must be - //! a valid iterator. - //! - //! <b>Effects</b>: Inserts x into the treap, using "hint" as a hint to - //! where it will be inserted. If "hint" is the upper_bound - //! the insertion takes constant time (two comparisons in the worst case) - //! - //! <b>Complexity</b>: Logarithmic in general, but it is amortized - //! constant time if t is inserted immediately before hint. - //! - //! <b>Throws</b>: If the internal value_compare or priority_compare functions throw. Strong guarantee. - //! - //! <b>Note</b>: Does not affect the validity of iterators and references. - //! No copy-constructors are called. - iterator insert_equal(const_iterator hint, reference value) - { - detail::key_nodeptr_comp<value_compare, treap_impl> - key_node_comp(priv_comp(), this); - detail::key_nodeptr_comp<priority_compare, treap_impl> - key_node_pcomp(priv_pcomp(), this); - node_ptr to_insert(get_real_value_traits().to_node_ptr(value)); - if(safemode_or_autounlink) - BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert)); - iterator ret (node_algorithms::insert_equal - (this->priv_header_ptr(), hint.pointed_node(), to_insert, key_node_comp, key_node_pcomp), this); - this->priv_size_traits().increment(); - return ret; - } - - //! <b>Requires</b>: Dereferencing iterator must yield an lvalue - //! of type value_type. - //! - //! <b>Effects</b>: Inserts a each element of a range into the treap - //! before the upper bound of the key of each element. - //! - //! <b>Complexity</b>: Insert range is in general O(N * log(N)), where N is the - //! size of the range. However, it is linear in N if the range is already sorted - //! by value_comp(). - //! - //! <b>Throws</b>: If the internal value_compare or priority_compare functions throw. - //! Strong guarantee. - //! - //! <b>Note</b>: Does not affect the validity of iterators and references. - //! No copy-constructors are called. - template<class Iterator> - void insert_equal(Iterator b, Iterator e) - { - iterator end(this->end()); - for (; b != e; ++b) - this->insert_equal(end, *b); - } - - //! <b>Requires</b>: value must be an lvalue - //! - //! <b>Effects</b>: Inserts value into the treap if the value - //! is not already present. - //! - //! <b>Complexity</b>: Average complexity for insert element is at - //! most logarithmic. - //! - //! <b>Throws</b>: If the internal value_compare or priority_compare functions throw. - //! Strong guarantee. - //! - //! <b>Note</b>: Does not affect the validity of iterators and references. - //! No copy-constructors are called. - std::pair<iterator, bool> insert_unique(reference value) - { - insert_commit_data commit_data; - std::pair<iterator, bool> ret = insert_unique_check(value, priv_comp(), priv_pcomp(), commit_data); - if(!ret.second) - return ret; - return std::pair<iterator, bool> (insert_unique_commit(value, commit_data), true); - } - - //! <b>Requires</b>: value must be an lvalue, and "hint" must be - //! a valid iterator - //! - //! <b>Effects</b>: Tries to insert x into the treap, using "hint" as a hint - //! to where it will be inserted. - //! - //! <b>Complexity</b>: Logarithmic in general, but it is amortized - //! constant time (two comparisons in the worst case) - //! if t is inserted immediately before hint. - //! - //! <b>Throws</b>: If the internal value_compare or priority_compare functions throw. - //! Strong guarantee. - //! - //! <b>Note</b>: Does not affect the validity of iterators and references. - //! No copy-constructors are called. - iterator insert_unique(const_iterator hint, reference value) - { - insert_commit_data commit_data; - std::pair<iterator, bool> ret = insert_unique_check(hint, value, priv_comp(), priv_pcomp(), commit_data); - if(!ret.second) - return ret.first; - return insert_unique_commit(value, commit_data); - } - - //! <b>Requires</b>: Dereferencing iterator must yield an lvalue - //! of type value_type. - //! - //! <b>Effects</b>: Tries to insert each element of a range into the treap. - //! - //! <b>Complexity</b>: Insert range is in general O(N * log(N)), where N is the - //! size of the range. However, it is linear in N if the range is already sorted - //! by value_comp(). - //! - //! <b>Throws</b>: If the internal value_compare or priority_compare functions throw. - //! Strong guarantee. - //! - //! <b>Note</b>: Does not affect the validity of iterators and references. - //! No copy-constructors are called. - template<class Iterator> - void insert_unique(Iterator b, Iterator e) - { - if(this->empty()){ - iterator end(this->end()); - for (; b != e; ++b) - this->insert_unique(end, *b); - } - else{ - for (; b != e; ++b) - this->insert_unique(*b); - } - } - - //! <b>Requires</b>: key_value_comp must be a comparison function that induces - //! the same strict weak ordering as value_compare. - //! key_value_pcomp must be a comparison function that induces - //! the same strict weak ordering as priority_compare. The difference is that - //! key_value_pcomp and key_value_comp compare an arbitrary key with the contained values. - //! - //! <b>Effects</b>: Checks if a value can be inserted in the container, using - //! a user provided key instead of the value itself. - //! - //! <b>Returns</b>: If there is an equivalent value - //! returns a pair containing an iterator to the already present value - //! and false. If the value can be inserted returns true in the returned - //! pair boolean and fills "commit_data" that is meant to be used with - //! the "insert_commit" function. - //! - //! <b>Complexity</b>: Average complexity is at most logarithmic. - //! - //! <b>Throws</b>: If the key_value_comp or key_value_pcomp - //! ordering functions throw. Strong guarantee. - //! - //! <b>Notes</b>: This function is used to improve performance when constructing - //! a value_type is expensive: if there is an equivalent value - //! the constructed object must be discarded. Many times, the part of the - //! node that is used to impose the order is much cheaper to construct - //! than the value_type and this function offers the possibility to use that - //! part to check if the insertion will be successful. - //! - //! If the check is successful, the user can construct the value_type and use - //! "insert_commit" to insert the object in constant-time. This gives a total - //! logarithmic complexity to the insertion: check(O(log(N)) + commit(O(1)). - //! - //! "commit_data" remains valid for a subsequent "insert_commit" only if no more - //! objects are inserted or erased from the container. - template<class KeyType, class KeyValueCompare, class KeyValuePrioCompare> - std::pair<iterator, bool> insert_unique_check - ( const KeyType &key, KeyValueCompare key_value_comp - , KeyValuePrioCompare key_value_pcomp, insert_commit_data &commit_data) - { - detail::key_nodeptr_comp<KeyValueCompare, treap_impl> - comp(key_value_comp, this); - detail::key_nodeptr_comp<KeyValuePrioCompare, treap_impl> - pcomp(key_value_pcomp, this); - std::pair<node_ptr, bool> ret = - (node_algorithms::insert_unique_check - (this->priv_header_ptr(), key, comp, pcomp, commit_data)); - return std::pair<iterator, bool>(iterator(ret.first, this), ret.second); - } - - //! <b>Requires</b>: key_value_comp must be a comparison function that induces - //! the same strict weak ordering as value_compare. - //! key_value_pcomp must be a comparison function that induces - //! the same strict weak ordering as priority_compare. The difference is that - //! key_value_pcomp and key_value_comp compare an arbitrary key with the contained values. - //! - //! <b>Effects</b>: Checks if a value can be inserted in the container, using - //! a user provided key instead of the value itself, using "hint" - //! as a hint to where it will be inserted. - //! - //! <b>Returns</b>: If there is an equivalent value - //! returns a pair containing an iterator to the already present value - //! and false. If the value can be inserted returns true in the returned - //! pair boolean and fills "commit_data" that is meant to be used with - //! the "insert_commit" function. - //! - //! <b>Complexity</b>: Logarithmic in general, but it's amortized - //! constant time if t is inserted immediately before hint. - //! - //! <b>Throws</b>: If the key_value_comp or key_value_pcomp - //! ordering functions throw. Strong guarantee. - //! - //! <b>Notes</b>: This function is used to improve performance when constructing - //! a value_type is expensive: if there is an equivalent value - //! the constructed object must be discarded. Many times, the part of the - //! constructing that is used to impose the order is much cheaper to construct - //! than the value_type and this function offers the possibility to use that key - //! to check if the insertion will be successful. - //! - //! If the check is successful, the user can construct the value_type and use - //! "insert_commit" to insert the object in constant-time. This can give a total - //! constant-time complexity to the insertion: check(O(1)) + commit(O(1)). - //! - //! "commit_data" remains valid for a subsequent "insert_commit" only if no more - //! objects are inserted or erased from the container. - template<class KeyType, class KeyValueCompare, class KeyValuePrioCompare> - std::pair<iterator, bool> insert_unique_check - ( const_iterator hint, const KeyType &key - , KeyValueCompare key_value_comp - , KeyValuePrioCompare key_value_pcomp - , insert_commit_data &commit_data) - { - detail::key_nodeptr_comp<KeyValueCompare, treap_impl> - comp(key_value_comp, this); - detail::key_nodeptr_comp<KeyValuePrioCompare, treap_impl> - pcomp(key_value_pcomp, this); - std::pair<node_ptr, bool> ret = - (node_algorithms::insert_unique_check - (this->priv_header_ptr(), hint.pointed_node(), key, comp, pcomp, commit_data)); - return std::pair<iterator, bool>(iterator(ret.first, this), ret.second); - } - - //! <b>Requires</b>: value must be an lvalue of type value_type. commit_data - //! must have been obtained from a previous call to "insert_check". - //! No objects should have been inserted or erased from the container between - //! the "insert_check" that filled "commit_data" and the call to "insert_commit". - //! - //! <b>Effects</b>: Inserts the value in the avl_set using the information obtained - //! from the "commit_data" that a previous "insert_check" filled. - //! - //! <b>Returns</b>: An iterator to the newly inserted object. - //! - //! <b>Complexity</b>: Constant time. - //! - //! <b>Throws</b>: Nothing - //! - //! <b>Notes</b>: This function has only sense if a "insert_check" has been - //! previously executed to fill "commit_data". No value should be inserted or - //! erased between the "insert_check" and "insert_commit" calls. - iterator insert_unique_commit(reference value, const insert_commit_data &commit_data) - { - node_ptr to_insert(get_real_value_traits().to_node_ptr(value)); - if(safemode_or_autounlink) - BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert)); - node_algorithms::insert_unique_commit(this->priv_header_ptr(), to_insert, commit_data); - this->priv_size_traits().increment(); - return iterator(to_insert, this); - } - - //! <b>Requires</b>: value must be an lvalue, "pos" must be - //! a valid iterator (or end) and must be the succesor of value - //! once inserted according to the predicate - //! - //! <b>Effects</b>: Inserts x into the treap before "pos". - //! - //! <b>Complexity</b>: Constant time. - //! - //! <b>Throws</b>: If the internal priority_compare function throws. Strong guarantee. - //! - //! <b>Note</b>: This function does not check preconditions so if "pos" is not - //! the successor of "value" treap ordering invariant will be broken. - //! This is a low-level function to be used only for performance reasons - //! by advanced users. - iterator insert_before(const_iterator pos, reference value) - { - node_ptr to_insert(get_real_value_traits().to_node_ptr(value)); - if(safemode_or_autounlink) - BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert)); - detail::key_nodeptr_comp<priority_compare, treap_impl> - pcomp(priv_pcomp(), this); - iterator ret (node_algorithms::insert_before - (this->priv_header_ptr(), pos.pointed_node(), to_insert, pcomp), this); - this->priv_size_traits().increment(); - return ret; - } - - //! <b>Requires</b>: value must be an lvalue, and it must be no less - //! than the greatest inserted key - //! - //! <b>Effects</b>: Inserts x into the treap in the last position. - //! - //! <b>Complexity</b>: Constant time. - //! - //! <b>Throws</b>: If the internal priority_compare function throws. Strong guarantee. - //! - //! <b>Note</b>: This function does not check preconditions so if value is - //! less than the greatest inserted key treap ordering invariant will be broken. - //! This function is slightly more efficient than using "insert_before". - //! This is a low-level function to be used only for performance reasons - //! by advanced users. - void push_back(reference value) - { - node_ptr to_insert(get_real_value_traits().to_node_ptr(value)); - if(safemode_or_autounlink) - BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert)); - detail::key_nodeptr_comp<priority_compare, treap_impl> - pcomp(priv_pcomp(), this); - node_algorithms::push_back(this->priv_header_ptr(), to_insert, pcomp); - this->priv_size_traits().increment(); - } - - //! <b>Requires</b>: value must be an lvalue, and it must be no greater - //! than the minimum inserted key - //! - //! <b>Effects</b>: Inserts x into the treap in the first position. - //! - //! <b>Complexity</b>: Constant time. - //! - //! <b>Throws</b>: If the internal priority_compare function throws. Strong guarantee. - //! - //! <b>Note</b>: This function does not check preconditions so if value is - //! greater than the minimum inserted key treap ordering invariant will be broken. - //! This function is slightly more efficient than using "insert_before". - //! This is a low-level function to be used only for performance reasons - //! by advanced users. - void push_front(reference value) - { - node_ptr to_insert(get_real_value_traits().to_node_ptr(value)); - if(safemode_or_autounlink) - BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert)); - detail::key_nodeptr_comp<priority_compare, treap_impl> - pcomp(priv_pcomp(), this); - node_algorithms::push_front(this->priv_header_ptr(), to_insert, pcomp); - this->priv_size_traits().increment(); - } - - //! <b>Effects</b>: Erases the element pointed to by pos. - //! - //! <b>Complexity</b>: Average complexity for erase element is constant time. - //! - //! <b>Throws</b>: if the internal priority_compare function throws. Strong guarantee. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - iterator erase(const_iterator i) - { - const_iterator ret(i); - ++ret; - node_ptr to_erase(i.pointed_node()); - if(safemode_or_autounlink) - BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(!node_algorithms::unique(to_erase)); - detail::key_nodeptr_comp<priority_compare, treap_impl> - key_node_pcomp(priv_pcomp(), this); - node_algorithms::erase(this->priv_header_ptr(), to_erase, key_node_pcomp); - this->priv_size_traits().decrement(); - if(safemode_or_autounlink) - node_algorithms::init(to_erase); - return ret.unconst(); - } - - //! <b>Effects</b>: Erases the range pointed to by b end e. - //! - //! <b>Complexity</b>: Average complexity for erase range is at most - //! O(log(size() + N)), where N is the number of elements in the range. - //! - //! <b>Throws</b>: if the internal priority_compare function throws. Strong guarantee. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - iterator erase(const_iterator b, const_iterator e) - { size_type n; return private_erase(b, e, n); } - - //! <b>Effects</b>: Erases all the elements with the given value. - //! - //! <b>Returns</b>: The number of erased elements. - //! - //! <b>Complexity</b>: O(log(size() + N). - //! - //! <b>Throws</b>: if the internal priority_compare function throws. Strong guarantee. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - size_type erase(const_reference value) - { return this->erase(value, priv_comp()); } - - //! <b>Effects</b>: Erases all the elements with the given key. - //! according to the comparison functor "comp". - //! - //! <b>Returns</b>: The number of erased elements. - //! - //! <b>Complexity</b>: O(log(size() + N). - //! - //! <b>Throws</b>: if the internal priority_compare function throws. - //! Equivalent guarantee to <i>while(beg != end) erase(beg++);</i> - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - template<class KeyType, class KeyValueCompare> - size_type erase(const KeyType& key, KeyValueCompare comp - /// @cond - , typename detail::enable_if_c<!detail::is_convertible<KeyValueCompare, const_iterator>::value >::type * = 0 - /// @endcond - ) - { - std::pair<iterator,iterator> p = this->equal_range(key, comp); - size_type n; - private_erase(p.first, p.second, n); - return n; - } - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! - //! <b>Effects</b>: Erases the element pointed to by pos. - //! Disposer::operator()(pointer) is called for the removed element. - //! - //! <b>Complexity</b>: Average complexity for erase element is constant time. - //! - //! <b>Throws</b>: if the internal priority_compare function throws. Strong guarantee. - //! - //! <b>Note</b>: Invalidates the iterators - //! to the erased elements. - template<class Disposer> - iterator erase_and_dispose(const_iterator i, Disposer disposer) - { - node_ptr to_erase(i.pointed_node()); - iterator ret(this->erase(i)); - disposer(get_real_value_traits().to_value_ptr(to_erase)); - return ret; - } - - #if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) - template<class Disposer> - iterator erase_and_dispose(iterator i, Disposer disposer) - { return this->erase_and_dispose(const_iterator(i), disposer); } - #endif - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! - //! <b>Effects</b>: Erases the range pointed to by b end e. - //! Disposer::operator()(pointer) is called for the removed elements. - //! - //! <b>Complexity</b>: Average complexity for erase range is at most - //! O(log(size() + N)), where N is the number of elements in the range. - //! - //! <b>Throws</b>: if the internal priority_compare function throws. Strong guarantee. - //! - //! <b>Note</b>: Invalidates the iterators - //! to the erased elements. - template<class Disposer> - iterator erase_and_dispose(const_iterator b, const_iterator e, Disposer disposer) - { size_type n; return private_erase(b, e, n, disposer); } - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! - //! <b>Effects</b>: Erases all the elements with the given value. - //! Disposer::operator()(pointer) is called for the removed elements. - //! - //! <b>Returns</b>: The number of erased elements. - //! - //! <b>Complexity</b>: O(log(size() + N). - //! - //! <b>Throws</b>: if the priority_compare function throws then weak guarantee and heap invariants are broken. - //! The safest thing would be to clear or destroy the container. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - template<class Disposer> - size_type erase_and_dispose(const_reference value, Disposer disposer) - { - std::pair<iterator,iterator> p = this->equal_range(value); - size_type n; - private_erase(p.first, p.second, n, disposer); - return n; - } - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! - //! <b>Effects</b>: Erases all the elements with the given key. - //! according to the comparison functor "comp". - //! Disposer::operator()(pointer) is called for the removed elements. - //! - //! <b>Returns</b>: The number of erased elements. - //! - //! <b>Complexity</b>: O(log(size() + N). - //! - //! <b>Throws</b>: if the priority_compare function throws then weak guarantee and heap invariants are broken. - //! The safest thing would be to clear or destroy the container. - //! - //! <b>Note</b>: Invalidates the iterators - //! to the erased elements. - template<class KeyType, class KeyValueCompare, class Disposer> - size_type erase_and_dispose(const KeyType& key, KeyValueCompare comp, Disposer disposer - /// @cond - , typename detail::enable_if_c<!detail::is_convertible<KeyValueCompare, const_iterator>::value >::type * = 0 - /// @endcond - ) - { - std::pair<iterator,iterator> p = this->equal_range(key, comp); - size_type n; - private_erase(p.first, p.second, n, disposer); - return n; - } - - //! <b>Effects</b>: Erases all of the elements. - //! - //! <b>Complexity</b>: Linear to the number of elements on the container. - //! if it's a safe-mode or auto-unlink value_type. Constant time otherwise. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - void clear() - { - if(safemode_or_autounlink){ - this->clear_and_dispose(detail::null_disposer()); - } - else{ - node_algorithms::init_header(priv_header_ptr()); - this->priv_size_traits().set_size(0); - } - } - - //! <b>Effects</b>: Erases all of the elements calling disposer(p) for - //! each node to be erased. - //! <b>Complexity</b>: Average complexity for is at most O(log(size() + N)), - //! where N is the number of elements in the container. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. Calls N times to disposer functor. - template<class Disposer> - void clear_and_dispose(Disposer disposer) - { - node_algorithms::clear_and_dispose(this->priv_header_ptr() - , detail::node_disposer<Disposer, treap_impl>(disposer, this)); - node_algorithms::init_header(this->priv_header_ptr()); - this->priv_size_traits().set_size(0); - } - - //! <b>Effects</b>: Returns the number of contained elements with the given value - //! - //! <b>Complexity</b>: Logarithmic to the number of elements contained plus lineal - //! to number of objects with the given value. - //! - //! <b>Throws</b>: Nothing. - size_type count(const_reference value) const - { return this->count(value, priv_comp()); } - - //! <b>Effects</b>: Returns the number of contained elements with the given key - //! - //! <b>Complexity</b>: Logarithmic to the number of elements contained plus lineal - //! to number of objects with the given key. - //! - //! <b>Throws</b>: Nothing. - template<class KeyType, class KeyValueCompare> - size_type count(const KeyType &key, KeyValueCompare comp) const - { - std::pair<const_iterator, const_iterator> ret = this->equal_range(key, comp); - return std::distance(ret.first, ret.second); - } - - //! <b>Effects</b>: Returns an iterator to the first element whose - //! key is not less than k or end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: Nothing. - iterator lower_bound(const_reference value) - { return this->lower_bound(value, priv_comp()); } - - //! <b>Effects</b>: Returns an iterator to the first element whose - //! key is not less than k or end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: Nothing. - const_iterator lower_bound(const_reference value) const - { return this->lower_bound(value, priv_comp()); } - - //! <b>Effects</b>: Returns an iterator to the first element whose - //! key is not less than k or end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: Nothing. - template<class KeyType, class KeyValueCompare> - iterator lower_bound(const KeyType &key, KeyValueCompare comp) - { - detail::key_nodeptr_comp<KeyValueCompare, treap_impl> - key_node_comp(comp, this); - return iterator(node_algorithms::lower_bound - (this->priv_header_ptr(), key, key_node_comp), this); - } - - //! <b>Effects</b>: Returns a const iterator to the first element whose - //! key is not less than k or end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: Nothing. - template<class KeyType, class KeyValueCompare> - const_iterator lower_bound(const KeyType &key, KeyValueCompare comp) const - { - detail::key_nodeptr_comp<KeyValueCompare, treap_impl> - key_node_comp(comp, this); - return const_iterator(node_algorithms::lower_bound - (this->priv_header_ptr(), key, key_node_comp), this); - } - - //! <b>Effects</b>: Returns an iterator to the first element whose - //! key is greater than k or end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: Nothing. - iterator upper_bound(const_reference value) - { return this->upper_bound(value, priv_comp()); } - - //! <b>Effects</b>: Returns an iterator to the first element whose - //! key is greater than k according to comp or end() if that element - //! does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: Nothing. - template<class KeyType, class KeyValueCompare> - iterator upper_bound(const KeyType &key, KeyValueCompare comp) - { - detail::key_nodeptr_comp<KeyValueCompare, treap_impl> - key_node_comp(comp, this); - return iterator(node_algorithms::upper_bound - (this->priv_header_ptr(), key, key_node_comp), this); - } - - //! <b>Effects</b>: Returns an iterator to the first element whose - //! key is greater than k or end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: Nothing. - const_iterator upper_bound(const_reference value) const - { return this->upper_bound(value, priv_comp()); } - - //! <b>Effects</b>: Returns an iterator to the first element whose - //! key is greater than k according to comp or end() if that element - //! does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: Nothing. - template<class KeyType, class KeyValueCompare> - const_iterator upper_bound(const KeyType &key, KeyValueCompare comp) const - { - detail::key_nodeptr_comp<KeyValueCompare, treap_impl> - key_node_comp(comp, this); - return const_iterator(node_algorithms::upper_bound - (this->priv_header_ptr(), key, key_node_comp), this); - } - - //! <b>Effects</b>: Finds an iterator to the first element whose key is - //! k or end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: Nothing. - iterator find(const_reference value) - { return this->find(value, priv_comp()); } - - //! <b>Effects</b>: Finds an iterator to the first element whose key is - //! k or end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: Nothing. - template<class KeyType, class KeyValueCompare> - iterator find(const KeyType &key, KeyValueCompare comp) - { - detail::key_nodeptr_comp<KeyValueCompare, treap_impl> - key_node_comp(comp, this); - return iterator - (node_algorithms::find(this->priv_header_ptr(), key, key_node_comp), this); - } - - //! <b>Effects</b>: Finds a const_iterator to the first element whose key is - //! k or end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: Nothing. - const_iterator find(const_reference value) const - { return this->find(value, priv_comp()); } - - //! <b>Effects</b>: Finds a const_iterator to the first element whose key is - //! k or end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: Nothing. - template<class KeyType, class KeyValueCompare> - const_iterator find(const KeyType &key, KeyValueCompare comp) const - { - detail::key_nodeptr_comp<KeyValueCompare, treap_impl> - key_node_comp(comp, this); - return const_iterator - (node_algorithms::find(this->priv_header_ptr(), key, key_node_comp), this); - } - - //! <b>Effects</b>: Finds a range containing all elements whose key is k or - //! an empty range that indicates the position where those elements would be - //! if they there is no elements with key k. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: Nothing. - std::pair<iterator,iterator> equal_range(const_reference value) - { return this->equal_range(value, priv_comp()); } - - //! <b>Effects</b>: Finds a range containing all elements whose key is k or - //! an empty range that indicates the position where those elements would be - //! if they there is no elements with key k. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: Nothing. - template<class KeyType, class KeyValueCompare> - std::pair<iterator,iterator> equal_range(const KeyType &key, KeyValueCompare comp) - { - detail::key_nodeptr_comp<KeyValueCompare, treap_impl> - key_node_comp(comp, this); - std::pair<node_ptr, node_ptr> ret - (node_algorithms::equal_range(this->priv_header_ptr(), key, key_node_comp)); - return std::pair<iterator, iterator>(iterator(ret.first, this), iterator(ret.second, this)); - } - - //! <b>Effects</b>: Finds a range containing all elements whose key is k or - //! an empty range that indicates the position where those elements would be - //! if they there is no elements with key k. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: Nothing. - std::pair<const_iterator, const_iterator> - equal_range(const_reference value) const - { return this->equal_range(value, priv_comp()); } - - //! <b>Effects</b>: Finds a range containing all elements whose key is k or - //! an empty range that indicates the position where those elements would be - //! if they there is no elements with key k. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: Nothing. - template<class KeyType, class KeyValueCompare> - std::pair<const_iterator, const_iterator> - equal_range(const KeyType &key, KeyValueCompare comp) const - { - detail::key_nodeptr_comp<KeyValueCompare, treap_impl> - key_node_comp(comp, this); - std::pair<node_ptr, node_ptr> ret - (node_algorithms::equal_range(this->priv_header_ptr(), key, key_node_comp)); - return std::pair<const_iterator, const_iterator>(const_iterator(ret.first, this), const_iterator(ret.second, this)); - } - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! Cloner should yield to nodes equivalent to the original nodes. - //! - //! <b>Effects</b>: Erases all the elements from *this - //! calling Disposer::operator()(pointer), clones all the - //! elements from src calling Cloner::operator()(const_reference ) - //! and inserts them on *this. Copies the predicate from the source container. - //! - //! If cloner throws, all cloned elements are unlinked and disposed - //! calling Disposer::operator()(pointer). - //! - //! <b>Complexity</b>: Linear to erased plus inserted elements. - //! - //! <b>Throws</b>: If cloner throws or predicate copy assignment throws. Basic guarantee. - template <class Cloner, class Disposer> - void clone_from(const treap_impl &src, Cloner cloner, Disposer disposer) - { - this->clear_and_dispose(disposer); - if(!src.empty()){ - detail::exception_disposer<treap_impl, Disposer> - rollback(*this, disposer); - node_algorithms::clone - (src.priv_header_ptr() - ,this->priv_header_ptr() - ,detail::node_cloner<Cloner, treap_impl>(cloner, this) - ,detail::node_disposer<Disposer, treap_impl>(disposer, this)); - this->priv_size_traits().set_size(src.priv_size_traits().get_size()); - this->priv_comp() = src.priv_comp(); - rollback.release(); - } - } - - //! <b>Effects</b>: Unlinks the leftmost node from the treap. - //! - //! <b>Complexity</b>: Average complexity is constant time. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Notes</b>: This function breaks the treap and the treap can - //! only be used for more unlink_leftmost_without_rebalance calls. - //! This function is normally used to achieve a step by step - //! controlled destruction of the treap. - pointer unlink_leftmost_without_rebalance() - { - node_ptr to_be_disposed(node_algorithms::unlink_leftmost_without_rebalance - (this->priv_header_ptr())); - if(!to_be_disposed) - return 0; - this->priv_size_traits().decrement(); - if(safemode_or_autounlink)//If this is commented does not work with normal_link - node_algorithms::init(to_be_disposed); - return get_real_value_traits().to_value_ptr(to_be_disposed); - } - - //! <b>Requires</b>: replace_this must be a valid iterator of *this - //! and with_this must not be inserted in any treap. - //! - //! <b>Effects</b>: Replaces replace_this in its position in the - //! treap with with_this. The treap does not need to be rebalanced. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: This function will break container ordering invariants if - //! with_this is not equivalent to *replace_this according to the - //! ordering and priority rules. This function is faster than erasing and inserting - //! the node, since no rebalancing or comparison is needed. - void replace_node(iterator replace_this, reference with_this) - { - node_algorithms::replace_node( get_real_value_traits().to_node_ptr(*replace_this) - , this->priv_header_ptr() - , get_real_value_traits().to_node_ptr(with_this)); - if(safemode_or_autounlink) - node_algorithms::init(replace_this.pointed_node()); - } - - //! <b>Requires</b>: value must be an lvalue and shall be in a set of - //! appropriate type. Otherwise the behavior is undefined. - //! - //! <b>Effects</b>: Returns: a valid iterator i belonging to the set - //! that points to the value - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: This static function is available only if the <i>value traits</i> - //! is stateless. - static iterator s_iterator_to(reference value) - { - BOOST_STATIC_ASSERT((!stateful_value_traits)); - return iterator (value_traits::to_node_ptr(value), 0); - } - - //! <b>Requires</b>: value must be an lvalue and shall be in a set of - //! appropriate type. Otherwise the behavior is undefined. - //! - //! <b>Effects</b>: Returns: a valid const_iterator i belonging to the - //! set that points to the value - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: This static function is available only if the <i>value traits</i> - //! is stateless. - static const_iterator s_iterator_to(const_reference value) - { - BOOST_STATIC_ASSERT((!stateful_value_traits)); - return const_iterator (value_traits::to_node_ptr(const_cast<reference> (value)), 0); - } - - //! <b>Requires</b>: value must be an lvalue and shall be in a set of - //! appropriate type. Otherwise the behavior is undefined. - //! - //! <b>Effects</b>: Returns: a valid iterator i belonging to the set - //! that points to the value - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - iterator iterator_to(reference value) - { return iterator (value_traits::to_node_ptr(value), this); } - - //! <b>Requires</b>: value must be an lvalue and shall be in a set of - //! appropriate type. Otherwise the behavior is undefined. - //! - //! <b>Effects</b>: Returns: a valid const_iterator i belonging to the - //! set that points to the value - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_iterator iterator_to(const_reference value) const - { return const_iterator (value_traits::to_node_ptr(const_cast<reference> (value)), this); } - - //! <b>Requires</b>: value shall not be in a treap. - //! - //! <b>Effects</b>: init_node puts the hook of a value in a well-known default - //! state. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant time. - //! - //! <b>Note</b>: This function puts the hook in the well-known default state - //! used by auto_unlink and safe hooks. - static void init_node(reference value) - { node_algorithms::init(value_traits::to_node_ptr(value)); } - - /// @cond - private: - template<class Disposer> - iterator private_erase(const_iterator b, const_iterator e, size_type &n, Disposer disposer) - { - for(n = 0; b != e; ++n) - this->erase_and_dispose(b++, disposer); - return b.unconst(); - } - - iterator private_erase(const_iterator b, const_iterator e, size_type &n) - { - for(n = 0; b != e; ++n) - this->erase(b++); - return b.unconst(); - } - /// @endcond - - private: - static treap_impl &priv_container_from_end_iterator(const const_iterator &end_iterator) - { - header_plus_size *r = detail::parent_from_member<header_plus_size, node> - ( boost::intrusive::detail::to_raw_pointer(end_iterator.pointed_node()), &header_plus_size::header_); - typename node_plus_pred_t::header_plus_priority_size *n = - detail::parent_from_member - < typename node_plus_pred_t::header_plus_priority_size - , header_plus_size> - (r, &node_plus_pred_t::header_plus_priority_size::header_plus_size_); - node_plus_pred_t *pn = detail::parent_from_member - < node_plus_pred_t - , typename node_plus_pred_t::header_plus_priority_size> - (n, &node_plus_pred_t::header_plus_priority_size_); - data_t *d = detail::parent_from_member<data_t, node_plus_pred_t>(pn, &data_t::node_plus_pred_); - treap_impl *tr = detail::parent_from_member<treap_impl, data_t>(d, &treap_impl::data_); - return *tr; - } - - static treap_impl &priv_container_from_iterator(const const_iterator &it) - { return priv_container_from_end_iterator(it.end_iterator_from_it()); } -}; - -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -inline bool operator< -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -(const treap_impl<T, Options...> &x, const treap_impl<T, Options...> &y) -#else -(const treap_impl<Config> &x, const treap_impl<Config> &y) -#endif -{ return std::lexicographical_compare(x.begin(), x.end(), y.begin(), y.end()); } - -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -bool operator== -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -(const treap_impl<T, Options...> &x, const treap_impl<T, Options...> &y) -#else -(const treap_impl<Config> &x, const treap_impl<Config> &y) -#endif -{ - typedef treap_impl<Config> tree_type; - typedef typename tree_type::const_iterator const_iterator; - - if(tree_type::constant_time_size && x.size() != y.size()){ - return false; - } - const_iterator end1 = x.end(); - const_iterator i1 = x.begin(); - const_iterator i2 = y.begin(); - if(tree_type::constant_time_size){ - while (i1 != end1 && *i1 == *i2) { - ++i1; - ++i2; - } - return i1 == end1; - } - else{ - const_iterator end2 = y.end(); - while (i1 != end1 && i2 != end2 && *i1 == *i2) { - ++i1; - ++i2; - } - return i1 == end1 && i2 == end2; - } -} - -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -inline bool operator!= -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -(const treap_impl<T, Options...> &x, const treap_impl<T, Options...> &y) -#else -(const treap_impl<Config> &x, const treap_impl<Config> &y) -#endif -{ return !(x == y); } - -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -inline bool operator> -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -(const treap_impl<T, Options...> &x, const treap_impl<T, Options...> &y) -#else -(const treap_impl<Config> &x, const treap_impl<Config> &y) -#endif -{ return y < x; } - -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -inline bool operator<= -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -(const treap_impl<T, Options...> &x, const treap_impl<T, Options...> &y) -#else -(const treap_impl<Config> &x, const treap_impl<Config> &y) -#endif -{ return !(y < x); } - -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -inline bool operator>= -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -(const treap_impl<T, Options...> &x, const treap_impl<T, Options...> &y) -#else -(const treap_impl<Config> &x, const treap_impl<Config> &y) -#endif -{ return !(x < y); } - -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -inline void swap -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -(treap_impl<T, Options...> &x, treap_impl<T, Options...> &y) -#else -(treap_impl<Config> &x, treap_impl<Config> &y) -#endif -{ x.swap(y); } - -/// @cond -#if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template<class T, class O1 = none, class O2 = none - , class O3 = none, class O4 = none - > -#else -template<class T, class ...Options> -#endif -struct make_treap_opt -{ - typedef typename pack_options - < treap_set_defaults<T>, - #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) - O1, O2, O3, O4 - #else - Options... - #endif - >::type packed_options; - typedef typename detail::get_value_traits - <T, typename packed_options::value_traits>::type value_traits; - - typedef treap_setopt - < value_traits - , typename packed_options::compare - , typename packed_options::priority - , typename packed_options::size_type - , packed_options::constant_time_size - > type; -}; -/// @endcond - -//! Helper metafunction to define a \c treap that yields to the same type when the -//! same options (either explicitly or implicitly) are used. -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) || defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template<class T, class ...Options> -#else -template<class T, class O1 = none, class O2 = none - , class O3 = none, class O4 = none> -#endif -struct make_trie -{ - /// @cond - typedef treap_impl - < typename make_treap_opt<T, - #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) - O1, O2, O3, O4 - #else - Options... - #endif - >::type - > implementation_defined; - /// @endcond - typedef implementation_defined type; -}; - -#ifndef BOOST_INTRUSIVE_DOXYGEN_INVOKED - -#if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template<class T, class O1, class O2, class O3, class O4> -#else -template<class T, class ...Options> -#endif -class treap - : public make_trie<T, - #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) - O1, O2, O3, O4 - #else - Options... - #endif - >::type -{ - typedef typename make_trie - <T, - #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) - O1, O2, O3, O4 - #else - Options... - #endif - >::type Base; - BOOST_MOVABLE_BUT_NOT_COPYABLE(treap) - - public: - typedef typename Base::value_compare value_compare; - typedef typename Base::priority_compare priority_compare; - typedef typename Base::value_traits value_traits; - typedef typename Base::real_value_traits real_value_traits; - typedef typename Base::iterator iterator; - typedef typename Base::const_iterator const_iterator; - - //Assert if passed value traits are compatible with the type - BOOST_STATIC_ASSERT((detail::is_same<typename real_value_traits::value_type, T>::value)); - - treap( const value_compare &cmp = value_compare() - , const priority_compare &pcmp = priority_compare() - , const value_traits &v_traits = value_traits()) - : Base(cmp, pcmp, v_traits) - {} - - template<class Iterator> - treap( bool unique, Iterator b, Iterator e - , const value_compare &cmp = value_compare() - , const priority_compare &pcmp = priority_compare() - , const value_traits &v_traits = value_traits()) - : Base(unique, b, e, cmp, pcmp, v_traits) - {} - - treap(BOOST_RV_REF(treap) x) - : Base(::boost::move(static_cast<Base&>(x))) - {} - - treap& operator=(BOOST_RV_REF(treap) x) - { this->Base::operator=(::boost::move(static_cast<Base&>(x))); return *this; } - - static treap &container_from_end_iterator(iterator end_iterator) - { return static_cast<treap &>(Base::container_from_end_iterator(end_iterator)); } - - static const treap &container_from_end_iterator(const_iterator end_iterator) - { return static_cast<const treap &>(Base::container_from_end_iterator(end_iterator)); } - - static treap &container_from_it(iterator it) - { return static_cast<treap &>(Base::container_from_iterator(it)); } - - static const treap &container_from_it(const_iterator it) - { return static_cast<const treap &>(Base::container_from_iterator(it)); } -}; - -#endif - - -} //namespace intrusive -} //namespace boost - -#include <boost/intrusive/detail/config_end.hpp> - -#endif //BOOST_INTRUSIVE_TRIE_HPP diff --git a/src/third_party/boost/boost/intrusive/treap_algorithms.hpp b/src/third_party/boost/boost/intrusive/treap_algorithms.hpp deleted file mode 100644 index 128e7ce2271..00000000000 --- a/src/third_party/boost/boost/intrusive/treap_algorithms.hpp +++ /dev/null @@ -1,895 +0,0 @@ -///////////////////////////////////////////////////////////////////////////// -// -// (C) Copyright Ion Gaztanaga 2006-2009. -// -// Distributed under the Boost Software License, Version 1.0. -// (See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) -// -// See http://www.boost.org/libs/intrusive for documentation. -// -///////////////////////////////////////////////////////////////////////////// - -#ifndef BOOST_INTRUSIVE_TREAP_ALGORITHMS_HPP -#define BOOST_INTRUSIVE_TREAP_ALGORITHMS_HPP - -#include <boost/intrusive/detail/config_begin.hpp> - -#include <cstddef> -#include <boost/intrusive/intrusive_fwd.hpp> - -#include <boost/intrusive/detail/assert.hpp> -#include <boost/intrusive/pointer_traits.hpp> -#include <boost/intrusive/detail/utilities.hpp> -#include <boost/intrusive/detail/tree_algorithms.hpp> -#include <algorithm> - - -namespace boost { -namespace intrusive { - -//! treap_algorithms provides basic algorithms to manipulate -//! nodes forming a treap. -//! -//! (1) the header node is maintained with links not only to the root -//! but also to the leftmost node of the tree, to enable constant time -//! begin(), and to the rightmost node of the tree, to enable linear time -//! performance when used with the generic set algorithms (set_union, -//! etc.); -//! -//! (2) when a node being deleted has two children its successor node is -//! relinked into its place, rather than copied, so that the only -//! pointers invalidated are those referring to the deleted node. -//! -//! treap_algorithms is configured with a NodeTraits class, which encapsulates the -//! information about the node to be manipulated. NodeTraits must support the -//! following interface: -//! -//! <b>Typedefs</b>: -//! -//! <tt>node</tt>: The type of the node that forms the circular list -//! -//! <tt>node_ptr</tt>: A pointer to a node -//! -//! <tt>const_node_ptr</tt>: A pointer to a const node -//! -//! <b>Static functions</b>: -//! -//! <tt>static node_ptr get_parent(const_node_ptr n);</tt> -//! -//! <tt>static void set_parent(node_ptr n, node_ptr parent);</tt> -//! -//! <tt>static node_ptr get_left(const_node_ptr n);</tt> -//! -//! <tt>static void set_left(node_ptr n, node_ptr left);</tt> -//! -//! <tt>static node_ptr get_right(const_node_ptr n);</tt> -//! -//! <tt>static void set_right(node_ptr n, node_ptr right);</tt> -template<class NodeTraits> -class treap_algorithms -{ - public: - typedef NodeTraits node_traits; - typedef typename NodeTraits::node node; - typedef typename NodeTraits::node_ptr node_ptr; - typedef typename NodeTraits::const_node_ptr const_node_ptr; - - /// @cond - private: - - class remove_on_destroy - { - remove_on_destroy(const remove_on_destroy&); - remove_on_destroy& operator=(const remove_on_destroy&); - public: - remove_on_destroy(const node_ptr & header, const node_ptr & z) - : header_(header), z_(z), remove_it_(true) - {} - ~remove_on_destroy() - { - if(remove_it_){ - tree_algorithms::erase(header_, z_); - } - } - - void release() - { remove_it_ = false; } - - const node_ptr header_; - const node_ptr z_; - bool remove_it_; - }; - - class rerotate_on_destroy - { - rerotate_on_destroy(const remove_on_destroy&); - rerotate_on_destroy& operator=(const rerotate_on_destroy&); - - public: - rerotate_on_destroy(const node_ptr & header, const node_ptr & p, std::size_t &n) - : header_(header), p_(p), n_(n), remove_it_(true) - {} - - ~rerotate_on_destroy() - { - if(remove_it_){ - rotate_up_n(header_, p_, n_); - } - } - - void release() - { remove_it_ = false; } - - const node_ptr header_; - const node_ptr p_; - std::size_t &n_; - bool remove_it_; - }; - - static void rotate_up_n(const node_ptr header, const node_ptr p, std::size_t n) - { - for( node_ptr p_parent = NodeTraits::get_parent(p) - ; n-- - ; p_parent = NodeTraits::get_parent(p)){ - //Check if left child - if(p == NodeTraits::get_left(p_parent)){ - tree_algorithms::rotate_right(p_parent, header); - } - else{ //Right child - tree_algorithms::rotate_left(p_parent, header); - } - } - } - - typedef detail::tree_algorithms<NodeTraits> tree_algorithms; - - static node_ptr uncast(const const_node_ptr & ptr) - { return pointer_traits<node_ptr>::const_cast_from(ptr); } - - /// @endcond - - public: - static node_ptr begin_node(const const_node_ptr & header) - { return tree_algorithms::begin_node(header); } - - static node_ptr end_node(const const_node_ptr & header) - { return tree_algorithms::end_node(header); } - - //! This type is the information that will be - //! filled by insert_unique_check - struct insert_commit_data - /// @cond - : public tree_algorithms::insert_commit_data - /// @endcond - { - /// @cond - std::size_t rotations; - /// @endcond - }; - - //! <b>Requires</b>: header1 and header2 must be the header nodes - //! of two trees. - //! - //! <b>Effects</b>: Swaps two trees. After the function header1 will contain - //! links to the second tree and header2 will have links to the first tree. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - static void swap_tree(const node_ptr & header1, const node_ptr & header2) - { return tree_algorithms::swap_tree(header1, header2); } - - //! <b>Requires</b>: node1 and node2 can't be header nodes - //! of two trees. - //! - //! <b>Effects</b>: Swaps two nodes. After the function node1 will be inserted - //! in the position node2 before the function. node2 will be inserted in the - //! position node1 had before the function. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: This function will break container ordering invariants if - //! node1 and node2 are not equivalent according to the ordering rules. - //! - //!Experimental function - static void swap_nodes(const node_ptr & node1, const node_ptr & node2) - { - if(node1 == node2) - return; - - node_ptr header1(tree_algorithms::get_header(node1)), header2(tree_algorithms::get_header(node2)); - swap_nodes(node1, header1, node2, header2); - } - - //! <b>Requires</b>: node1 and node2 can't be header nodes - //! of two trees with header header1 and header2. - //! - //! <b>Effects</b>: Swaps two nodes. After the function node1 will be inserted - //! in the position node2 before the function. node2 will be inserted in the - //! position node1 had before the function. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: This function will break container ordering invariants if - //! node1 and node2 are not equivalent according to the ordering rules. - //! - //!Experimental function - static void swap_nodes(const node_ptr & node1, const node_ptr & header1, const node_ptr & node2, const node_ptr & header2) - { tree_algorithms::swap_nodes(node1, header1, node2, header2); } - - //! <b>Requires</b>: node_to_be_replaced must be inserted in a tree - //! and new_node must not be inserted in a tree. - //! - //! <b>Effects</b>: Replaces node_to_be_replaced in its position in the - //! tree with new_node. The tree does not need to be rebalanced - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: This function will break container ordering invariants if - //! 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 - static void replace_node(const node_ptr & node_to_be_replaced, const node_ptr & new_node) - { - if(node_to_be_replaced == new_node) - return; - replace_node(node_to_be_replaced, tree_algorithms::get_header(node_to_be_replaced), new_node); - } - - //! <b>Requires</b>: node_to_be_replaced must be inserted in a tree - //! with header "header" and new_node must not be inserted in a tree. - //! - //! <b>Effects</b>: Replaces node_to_be_replaced in its position in the - //! tree with new_node. The tree does not need to be rebalanced - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: This function will break container ordering invariants if - //! 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 or comparison is needed. - //! - //!Experimental function - static void replace_node(const node_ptr & node_to_be_replaced, const node_ptr & header, const node_ptr & new_node) - { tree_algorithms::replace_node(node_to_be_replaced, header, new_node); } - - //! <b>Requires</b>: node is a tree node but not the header. - //! - //! <b>Effects</b>: Unlinks the node and rebalances the tree. - //! - //! <b>Complexity</b>: Average complexity is constant time. - //! - //! <b>Throws</b>: If "pcomp" throws, strong guarantee - template<class NodePtrPriorityCompare> - static void unlink(const node_ptr & node, NodePtrPriorityCompare pcomp) - { - node_ptr x = NodeTraits::get_parent(node); - if(x){ - while(!is_header(x)) - x = NodeTraits::get_parent(x); - erase(x, node, pcomp); - } - } - - //! <b>Requires</b>: header is the header of a tree. - //! - //! <b>Effects</b>: Unlinks the leftmost node from the tree, and - //! updates the header link to the new leftmost node. - //! - //! <b>Complexity</b>: Average complexity is constant time. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Notes</b>: This function breaks the tree and the tree can - //! only be used for more unlink_leftmost_without_rebalance calls. - //! This function is normally used to achieve a step by step - //! controlled destruction of the tree. - static node_ptr unlink_leftmost_without_rebalance(const node_ptr & header) - { return tree_algorithms::unlink_leftmost_without_rebalance(header); } - - //! <b>Requires</b>: node is a node of the tree or an node initialized - //! by init(...). - //! - //! <b>Effects</b>: Returns true if the node is initialized by init(). - //! - //! <b>Complexity</b>: Constant time. - //! - //! <b>Throws</b>: Nothing. - static bool unique(const const_node_ptr & node) - { return tree_algorithms::unique(node); } - - //! <b>Requires</b>: node is a node of the tree but it's not the header. - //! - //! <b>Effects</b>: Returns the number of nodes of the subtree. - //! - //! <b>Complexity</b>: Linear time. - //! - //! <b>Throws</b>: Nothing. - static std::size_t count(const const_node_ptr & node) - { return tree_algorithms::count(node); } - - //! <b>Requires</b>: header is the header node of the tree. - //! - //! <b>Effects</b>: Returns the number of nodes above the header. - //! - //! <b>Complexity</b>: Linear time. - //! - //! <b>Throws</b>: Nothing. - static std::size_t size(const const_node_ptr & header) - { return tree_algorithms::size(header); } - - //! <b>Requires</b>: p is a node from the tree except the header. - //! - //! <b>Effects</b>: Returns the next node of the tree. - //! - //! <b>Complexity</b>: Average constant time. - //! - //! <b>Throws</b>: Nothing. - static node_ptr next_node(const node_ptr & p) - { return tree_algorithms::next_node(p); } - - //! <b>Requires</b>: p is a node from the tree except the leftmost node. - //! - //! <b>Effects</b>: Returns the previous node of the tree. - //! - //! <b>Complexity</b>: Average constant time. - //! - //! <b>Throws</b>: Nothing. - static node_ptr prev_node(const node_ptr & p) - { return tree_algorithms::prev_node(p); } - - //! <b>Requires</b>: node must not be part of any tree. - //! - //! <b>Effects</b>: After the function unique(node) == true. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Nodes</b>: If node is inserted in a tree, this function corrupts the tree. - static void init(const node_ptr & node) - { tree_algorithms::init(node); } - - //! <b>Requires</b>: node must not be part of any tree. - //! - //! <b>Effects</b>: Initializes the header to represent an empty tree. - //! unique(header) == true. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Nodes</b>: If node is inserted in a tree, this function corrupts the tree. - static void init_header(const node_ptr & header) - { - tree_algorithms::init_header(header); - } - - //! <b>Requires</b>: header must be the header of a tree, z a node - //! of that tree and z != header. - //! - //! <b>Effects</b>: Erases node "z" from the tree with header "header". - //! - //! <b>Complexity</b>: Amortized constant time. - //! - //! <b>Throws</b>: If "pcomp" throws, strong guarantee. - template<class NodePtrPriorityCompare> - static node_ptr erase(const node_ptr & header, const node_ptr & z, NodePtrPriorityCompare pcomp) - { - rebalance_for_erasure(header, z, pcomp); - tree_algorithms::erase(header, z); -// assert(check_invariant(header, pcomp)); - return z; - } - - //! <b>Requires</b>: "cloner" must be a function - //! object taking a node_ptr and returning a new cloned node of it. "disposer" must - //! take a node_ptr and shouldn't throw. - //! - //! <b>Effects</b>: First empties target tree calling - //! <tt>void disposer::operator()(const node_ptr &)</tt> for every node of the tree - //! except the header. - //! - //! Then, duplicates the entire tree pointed by "source_header" cloning each - //! source node with <tt>node_ptr Cloner::operator()(const node_ptr &)</tt> to obtain - //! the nodes of the target tree. If "cloner" throws, the cloned target nodes - //! are disposed using <tt>void disposer(const node_ptr &)</tt>. - //! - //! <b>Complexity</b>: Linear to the number of element of the source tree plus the. - //! number of elements of tree target tree when calling this function. - //! - //! <b>Throws</b>: If cloner functor throws. If this happens target nodes are disposed. - template <class Cloner, class Disposer> - static void clone - (const const_node_ptr & source_header, const node_ptr & target_header, Cloner cloner, Disposer disposer) - { - tree_algorithms::clone(source_header, target_header, cloner, disposer); - } - - //! <b>Requires</b>: "disposer" must be an object function - //! taking a node_ptr parameter and shouldn't throw. - //! - //! <b>Effects</b>: Empties the target tree calling - //! <tt>void disposer::operator()(const node_ptr &)</tt> for every node of the tree - //! except the header. - //! - //! <b>Complexity</b>: Linear to the number of element of the source tree plus the. - //! number of elements of tree target tree when calling this function. - //! - //! <b>Throws</b>: If cloner functor throws. If this happens target nodes are disposed. - template<class Disposer> - static void clear_and_dispose(const node_ptr & header, Disposer disposer) - { tree_algorithms::clear_and_dispose(header, disposer); } - - //! <b>Requires</b>: "header" must be the header node of a tree. - //! KeyNodePtrCompare is a function object that induces a strict weak - //! ordering compatible with the strict weak ordering used to create the - //! the tree. KeyNodePtrCompare can compare KeyType with tree's node_ptrs. - //! - //! <b>Effects</b>: Returns an node_ptr to the first element that is - //! not less than "key" according to "comp" or "header" if that element does - //! not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If "comp" throws. - template<class KeyType, class KeyNodePtrCompare> - static node_ptr lower_bound - (const const_node_ptr & header, const KeyType &key, KeyNodePtrCompare comp) - { return tree_algorithms::lower_bound(header, key, comp); } - - //! <b>Requires</b>: "header" must be the header node of a tree. - //! KeyNodePtrCompare is a function object that induces a strict weak - //! ordering compatible with the strict weak ordering used to create the - //! the tree. KeyNodePtrCompare can compare KeyType with tree's node_ptrs. - //! - //! <b>Effects</b>: Returns an node_ptr to the first element that is greater - //! than "key" according to "comp" or "header" if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If "comp" throws. - template<class KeyType, class KeyNodePtrCompare> - static node_ptr upper_bound - (const const_node_ptr & header, const KeyType &key, KeyNodePtrCompare comp) - { return tree_algorithms::upper_bound(header, key, comp); } - - //! <b>Requires</b>: "header" must be the header node of a tree. - //! KeyNodePtrCompare is a function object that induces a strict weak - //! ordering compatible with the strict weak ordering used to create the - //! the tree. KeyNodePtrCompare can compare KeyType with tree's node_ptrs. - //! - //! <b>Effects</b>: Returns an node_ptr to the element that is equivalent to - //! "key" according to "comp" or "header" if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If "comp" throws. - template<class KeyType, class KeyNodePtrCompare> - static node_ptr find - (const const_node_ptr & header, const KeyType &key, KeyNodePtrCompare comp) - { return tree_algorithms::find(header, key, comp); } - - //! <b>Requires</b>: "header" must be the header node of a tree. - //! KeyNodePtrCompare is a function object that induces a strict weak - //! ordering compatible with the strict weak ordering used to create the - //! the tree. KeyNodePtrCompare can compare KeyType with tree's node_ptrs. - //! - //! <b>Effects</b>: Returns an a pair of node_ptr delimiting a range containing - //! all elements that are equivalent to "key" according to "comp" or an - //! empty range that indicates the position where those elements would be - //! if they there are no equivalent elements. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If "comp" throws. - template<class KeyType, class KeyNodePtrCompare> - static std::pair<node_ptr, node_ptr> equal_range - (const const_node_ptr & header, const KeyType &key, KeyNodePtrCompare comp) - { return tree_algorithms::equal_range(header, key, comp); } - - //! <b>Requires</b>: "h" must be the header node of a tree. - //! NodePtrCompare is a function object that induces a strict weak - //! ordering compatible with the strict weak ordering used to create the - //! the tree. NodePtrCompare compares two node_ptrs. - //! NodePtrPriorityCompare is a priority function object that induces a strict weak - //! ordering compatible with the one used to create the - //! the tree. NodePtrPriorityCompare compares two node_ptrs. - //! - //! <b>Effects</b>: Inserts new_node into the tree before the upper bound - //! according to "comp" and rotates the tree according to "pcomp". - //! - //! <b>Complexity</b>: Average complexity for insert element is at - //! most logarithmic. - //! - //! <b>Throws</b>: If "comp" throw or "pcomp" throw. - template<class NodePtrCompare, class NodePtrPriorityCompare> - static node_ptr insert_equal_upper_bound - (const node_ptr & h, const node_ptr & new_node, NodePtrCompare comp, NodePtrPriorityCompare pcomp) - { - insert_commit_data commit_data; - tree_algorithms::insert_equal_upper_bound_check(h, new_node, comp, commit_data); - rebalance_check_and_commit(h, new_node, pcomp, commit_data); - return new_node; - } - - //! <b>Requires</b>: "h" must be the header node of a tree. - //! NodePtrCompare is a function object that induces a strict weak - //! ordering compatible with the strict weak ordering used to create the - //! the tree. NodePtrCompare compares two node_ptrs. - //! NodePtrPriorityCompare is a priority function object that induces a strict weak - //! ordering compatible with the one used to create the - //! the tree. NodePtrPriorityCompare compares two node_ptrs. - //! - //! <b>Effects</b>: Inserts new_node into the tree before the upper bound - //! according to "comp" and rotates the tree according to "pcomp". - //! - //! <b>Complexity</b>: Average complexity for insert element is at - //! most logarithmic. - //! - //! <b>Throws</b>: If "comp" throws. - template<class NodePtrCompare, class NodePtrPriorityCompare> - static node_ptr insert_equal_lower_bound - (const node_ptr & h, const node_ptr & new_node, NodePtrCompare comp, NodePtrPriorityCompare pcomp) - { - insert_commit_data commit_data; - tree_algorithms::insert_equal_lower_bound_check(h, new_node, comp, commit_data); - rebalance_check_and_commit(h, new_node, pcomp, commit_data); - return new_node; - } - - //! <b>Requires</b>: "header" must be the header node of a tree. - //! NodePtrCompare is a function object that induces a strict weak - //! ordering compatible with the strict weak ordering used to create the - //! the tree. NodePtrCompare compares two node_ptrs. "hint" is node from - //! the "header"'s tree. - //! NodePtrPriorityCompare is a priority function object that induces a strict weak - //! ordering compatible with the one used to create the - //! the tree. NodePtrPriorityCompare compares two node_ptrs. - //! - //! <b>Effects</b>: Inserts new_node into the tree, using "hint" as a hint to - //! where it will be inserted. If "hint" is the upper_bound - //! the insertion takes constant time (two comparisons in the worst case). - //! Rotates the tree according to "pcomp". - //! - //! <b>Complexity</b>: Logarithmic in general, but it is amortized - //! constant time if new_node is inserted immediately before "hint". - //! - //! <b>Throws</b>: If "comp" throw or "pcomp" throw. - template<class NodePtrCompare, class NodePtrPriorityCompare> - static node_ptr insert_equal - (const node_ptr & h, const node_ptr & hint, const node_ptr & new_node, NodePtrCompare comp, NodePtrPriorityCompare pcomp) - { - insert_commit_data commit_data; - tree_algorithms::insert_equal_check(h, hint, new_node, comp, commit_data); - rebalance_check_and_commit(h, new_node, pcomp, commit_data); - return new_node; - } - - //! <b>Requires</b>: "header" must be the header node of a tree. - //! "pos" must be a valid node of the tree (including header end) node. - //! "pos" must be a node pointing to the successor to "new_node" - //! once inserted according to the order of already inserted nodes. This function does not - //! check "pos" and this precondition must be guaranteed by the caller. - //! NodePtrPriorityCompare is a priority function object that induces a strict weak - //! ordering compatible with the one used to create the - //! the tree. NodePtrPriorityCompare compares two node_ptrs. - //! - //! <b>Effects</b>: Inserts new_node into the tree before "pos" - //! and rotates the tree according to "pcomp". - //! - //! <b>Complexity</b>: Constant-time. - //! - //! <b>Throws</b>: If "pcomp" throws, strong guarantee. - //! - //! <b>Note</b>: If "pos" is not the successor of the newly inserted "new_node" - //! tree invariants might be broken. - template<class NodePtrPriorityCompare> - static node_ptr insert_before - (const node_ptr & header, const node_ptr & pos, const node_ptr & new_node, NodePtrPriorityCompare pcomp) - { - insert_commit_data commit_data; - tree_algorithms::insert_before_check(header, pos, commit_data); - rebalance_check_and_commit(header, new_node, pcomp, commit_data); - return new_node; - } - - //! <b>Requires</b>: "header" must be the header node of a tree. - //! "new_node" must be, according to the used ordering no less than the - //! greatest inserted key. - //! NodePtrPriorityCompare is a priority function object that induces a strict weak - //! ordering compatible with the one used to create the - //! the tree. NodePtrPriorityCompare compares two node_ptrs. - //! - //! <b>Effects</b>: Inserts x into the tree in the last position - //! and rotates the tree according to "pcomp". - //! - //! <b>Complexity</b>: Constant-time. - //! - //! <b>Throws</b>: If "pcomp" throws, strong guarantee. - //! - //! <b>Note</b>: If "new_node" is less than the greatest inserted key - //! tree invariants are broken. This function is slightly faster than - //! using "insert_before". - template<class NodePtrPriorityCompare> - static void push_back(const node_ptr & header, const node_ptr & new_node, NodePtrPriorityCompare pcomp) - { - insert_commit_data commit_data; - tree_algorithms::push_back_check(header, commit_data); - rebalance_check_and_commit(header, new_node, pcomp, commit_data); - } - - //! <b>Requires</b>: "header" must be the header node of a tree. - //! "new_node" must be, according to the used ordering, no greater than the - //! lowest inserted key. - //! NodePtrPriorityCompare is a priority function object that induces a strict weak - //! ordering compatible with the one used to create the - //! the tree. NodePtrPriorityCompare compares two node_ptrs. - //! - //! <b>Effects</b>: Inserts x into the tree in the first position - //! and rotates the tree according to "pcomp". - //! - //! <b>Complexity</b>: Constant-time. - //! - //! <b>Throws</b>: If "pcomp" throws, strong guarantee. - //! - //! <b>Note</b>: If "new_node" is greater than the lowest inserted key - //! tree invariants are broken. This function is slightly faster than - //! using "insert_before". - template<class NodePtrPriorityCompare> - static void push_front(const node_ptr & header, const node_ptr & new_node, NodePtrPriorityCompare pcomp) - { - insert_commit_data commit_data; - tree_algorithms::push_front_check(header, commit_data); - rebalance_check_and_commit(header, new_node, pcomp, commit_data); - } - - //! <b>Requires</b>: "header" must be the header node of a tree. - //! KeyNodePtrCompare is a function object that induces a strict weak - //! ordering compatible with the strict weak ordering used to create the - //! the tree. NodePtrCompare compares KeyType with a node_ptr. - //! - //! <b>Effects</b>: Checks if there is an equivalent node to "key" in the - //! tree according to "comp" and obtains the needed information to realize - //! a constant-time node insertion if there is no equivalent node. - //! - //! <b>Returns</b>: If there is an equivalent value - //! returns a pair containing a node_ptr to the already present node - //! and false. If there is not equivalent key can be inserted returns true - //! in the returned pair's boolean and fills "commit_data" that is meant to - //! be used with the "insert_commit" function to achieve a constant-time - //! insertion function. - //! - //! <b>Complexity</b>: Average complexity is at most logarithmic. - //! - //! <b>Throws</b>: If "comp" throws. - //! - //! <b>Notes</b>: This function is used to improve performance when constructing - //! a node is expensive and the user does not want to have two equivalent nodes - //! in the tree: if there is an equivalent value - //! the constructed object must be discarded. Many times, the part of the - //! node that is used to impose the order is much cheaper to construct - //! than the node and this function offers the possibility to use that part - //! to check if the insertion will be successful. - //! - //! If the check is successful, the user can construct the node and use - //! "insert_commit" to insert the node in constant-time. This gives a total - //! logarithmic complexity to the insertion: check(O(log(N)) + commit(O(1)). - //! - //! "commit_data" remains valid for a subsequent "insert_unique_commit" only - //! if no more objects are inserted or erased from the set. - template<class KeyType, class KeyNodePtrCompare, class KeyNodePtrPrioCompare> - static std::pair<node_ptr, bool> insert_unique_check - (const const_node_ptr & header, const KeyType &key - ,KeyNodePtrCompare comp, KeyNodePtrPrioCompare pcomp - ,insert_commit_data &commit_data) - { - std::pair<node_ptr, bool> ret = - tree_algorithms::insert_unique_check(header, key, comp, commit_data); - if(ret.second) - rebalance_after_insertion_check(header, commit_data.node, key, pcomp, commit_data.rotations); - return ret; - } - - //! <b>Requires</b>: "header" must be the header node of a tree. - //! KeyNodePtrCompare is a function object that induces a strict weak - //! ordering compatible with the strict weak ordering used to create the - //! the tree. NodePtrCompare compares KeyType with a node_ptr. - //! "hint" is node from the "header"'s tree. - //! - //! <b>Effects</b>: Checks if there is an equivalent node to "key" in the - //! tree according to "comp" using "hint" as a hint to where it should be - //! inserted and obtains the needed information to realize - //! a constant-time node insertion if there is no equivalent node. - //! If "hint" is the upper_bound the function has constant time - //! complexity (two comparisons in the worst case). - //! - //! <b>Returns</b>: If there is an equivalent value - //! returns a pair containing a node_ptr to the already present node - //! and false. If there is not equivalent key can be inserted returns true - //! in the returned pair's boolean and fills "commit_data" that is meant to - //! be used with the "insert_commit" function to achieve a constant-time - //! insertion function. - //! - //! <b>Complexity</b>: Average complexity is at most logarithmic, but it is - //! amortized constant time if new_node should be inserted immediately before "hint". - //! - //! <b>Throws</b>: If "comp" throws. - //! - //! <b>Notes</b>: This function is used to improve performance when constructing - //! a node is expensive and the user does not want to have two equivalent nodes - //! in the tree: if there is an equivalent value - //! the constructed object must be discarded. Many times, the part of the - //! node that is used to impose the order is much cheaper to construct - //! than the node and this function offers the possibility to use that part - //! to check if the insertion will be successful. - //! - //! If the check is successful, the user can construct the node and use - //! "insert_commit" to insert the node in constant-time. This gives a total - //! logarithmic complexity to the insertion: check(O(log(N)) + commit(O(1)). - //! - //! "commit_data" remains valid for a subsequent "insert_unique_commit" only - //! if no more objects are inserted or erased from the set. - template<class KeyType, class KeyNodePtrCompare, class KeyNodePtrPrioCompare> - static std::pair<node_ptr, bool> insert_unique_check - (const const_node_ptr & header, const node_ptr & hint, const KeyType &key - ,KeyNodePtrCompare comp, KeyNodePtrPrioCompare pcomp, insert_commit_data &commit_data) - { - std::pair<node_ptr, bool> ret = - tree_algorithms::insert_unique_check(header, hint, key, comp, commit_data); - if(ret.second) - rebalance_after_insertion_check(header, commit_data.node, key, pcomp, commit_data.rotations); - return ret; - } - - //! <b>Requires</b>: "header" must be the header node of a tree. - //! "commit_data" must have been obtained from a previous call to - //! "insert_unique_check". No objects should have been inserted or erased - //! from the set between the "insert_unique_check" that filled "commit_data" - //! and the call to "insert_commit". - //! - //! - //! <b>Effects</b>: Inserts new_node in the set using the information obtained - //! from the "commit_data" that a previous "insert_check" filled. - //! - //! <b>Complexity</b>: Constant time. - //! - //! <b>Throws</b>: Nothing. - //! - //! <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. - static void insert_unique_commit - (const node_ptr & header, const node_ptr & new_node, const insert_commit_data &commit_data) - { - tree_algorithms::insert_unique_commit(header, new_node, commit_data); - rebalance_after_insertion_commit(header, new_node, commit_data.rotations); - } - - //! <b>Requires</b>: "n" must be a node inserted in a tree. - //! - //! <b>Effects</b>: Returns a pointer to the header node of the tree. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: Nothing. - static node_ptr get_header(const node_ptr & n) - { return tree_algorithms::get_header(n); } - - /// @cond - private: - - //! <b>Requires</b>: p is a node of a tree. - //! - //! <b>Effects</b>: Returns true if p is the header of the tree. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - static bool is_header(const const_node_ptr & p) - { - return tree_algorithms::is_header(p); - } - - template<class NodePtrPriorityCompare> - static void rebalance_for_erasure(const node_ptr & header, const node_ptr & z, NodePtrPriorityCompare pcomp) - { - std::size_t n = 0; - rerotate_on_destroy rb(header, z, n); - - node_ptr z_left = NodeTraits::get_left(z); - node_ptr z_right = NodeTraits::get_right(z); - while(z_left || z_right){ - if(!z_right || (z_left && pcomp(z_left, z_right))){ - tree_algorithms::rotate_right(z, header); - } - else{ - tree_algorithms::rotate_left(z, header); - } - ++n; - z_left = NodeTraits::get_left(z); - z_right = NodeTraits::get_right(z); - } - rb.release(); - } - - template<class NodePtrPriorityCompare> - static void rebalance_check_and_commit - (const node_ptr & h, const node_ptr & new_node, NodePtrPriorityCompare pcomp, insert_commit_data &commit_data) - { - rebalance_after_insertion_check(h, commit_data.node, new_node, pcomp, commit_data.rotations); - //No-throw - tree_algorithms::insert_unique_commit(h, new_node, commit_data); - rebalance_after_insertion_commit(h, new_node, commit_data.rotations); - } - - - template<class Key, class KeyNodePriorityCompare> - static void rebalance_after_insertion_check - (const const_node_ptr &header, const const_node_ptr & up, const Key &k - , KeyNodePriorityCompare pcomp, std::size_t &num_rotations) - { - const_node_ptr upnode(up); - //First check rotations since pcomp can throw - num_rotations = 0; - std::size_t n = 0; - while(upnode != header && pcomp(k, upnode)){ - ++n; - upnode = NodeTraits::get_parent(upnode); - } - num_rotations = n; - } - - static void rebalance_after_insertion_commit(const node_ptr & header, const node_ptr & p, std::size_t n) - { - // Now execute n rotations - for( node_ptr p_parent = NodeTraits::get_parent(p) - ; n-- - ; p_parent = NodeTraits::get_parent(p)){ - //Check if left child - if(p == NodeTraits::get_left(p_parent)){ - tree_algorithms::rotate_right(p_parent, header); - } - else{ //Right child - tree_algorithms::rotate_left(p_parent, header); - } - } - } - - template<class NodePtrPriorityCompare> - static bool check_invariant(const const_node_ptr & header, NodePtrPriorityCompare pcomp) - { - node_ptr beg = begin_node(header); - node_ptr end = end_node(header); - - while(beg != end){ - node_ptr p = NodeTraits::get_parent(beg); - if(p != header){ - if(pcomp(beg, p)) - return false; - } - beg = next_node(beg); - } - return true; - } - - /// @endcond -}; - -} //namespace intrusive -} //namespace boost - -#include <boost/intrusive/detail/config_end.hpp> - -#endif //BOOST_INTRUSIVE_TREAP_ALGORITHMS_HPP diff --git a/src/third_party/boost/boost/intrusive/treap_set.hpp b/src/third_party/boost/boost/intrusive/treap_set.hpp deleted file mode 100644 index 01dfcd8b30f..00000000000 --- a/src/third_party/boost/boost/intrusive/treap_set.hpp +++ /dev/null @@ -1,2581 +0,0 @@ -///////////////////////////////////////////////////////////////////////////// -// -// (C) Copyright Ion Gaztanaga 2007-2009 -// -// Distributed under the Boost Software License, Version 1.0. -// (See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) -// -// See http://www.boost.org/libs/intrusive for documentation. -// -///////////////////////////////////////////////////////////////////////////// -#ifndef BOOST_INTRUSIVE_TRIE_SET_HPP -#define BOOST_INTRUSIVE_TRIE_SET_HPP - -#include <boost/intrusive/detail/config_begin.hpp> -#include <boost/intrusive/intrusive_fwd.hpp> -#include <boost/intrusive/treap.hpp> -#include <boost/intrusive/detail/mpl.hpp> -#include <boost/move/move.hpp> -#include <iterator> - -namespace boost { -namespace intrusive { - -//! The class template treap_set is an intrusive container, that mimics most of -//! the interface of std::set as described in the C++ standard. -//! -//! The template parameter \c T is the type to be managed by the container. -//! The user can specify additional options and if no options are provided -//! default options are used. -//! -//! The container supports the following options: -//! \c base_hook<>/member_hook<>/value_traits<>, -//! \c constant_time_size<>, \c size_type<>, -//! \c compare<> and \c priority_compare<> -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -class treap_set_impl -{ - /// @cond - typedef treap_impl<Config> tree_type; - //! This class is - //! movable - BOOST_MOVABLE_BUT_NOT_COPYABLE(treap_set_impl) - - typedef tree_type implementation_defined; - /// @endcond - - public: - typedef typename implementation_defined::value_type value_type; - typedef typename implementation_defined::value_traits value_traits; - typedef typename implementation_defined::pointer pointer; - typedef typename implementation_defined::const_pointer const_pointer; - typedef typename implementation_defined::reference reference; - typedef typename implementation_defined::const_reference const_reference; - typedef typename implementation_defined::difference_type difference_type; - typedef typename implementation_defined::size_type size_type; - typedef typename implementation_defined::value_compare value_compare; - typedef typename implementation_defined::priority_compare priority_compare; - typedef typename implementation_defined::key_compare key_compare; - typedef typename implementation_defined::iterator iterator; - typedef typename implementation_defined::const_iterator const_iterator; - typedef typename implementation_defined::reverse_iterator reverse_iterator; - typedef typename implementation_defined::const_reverse_iterator const_reverse_iterator; - typedef typename implementation_defined::insert_commit_data insert_commit_data; - typedef typename implementation_defined::node_traits node_traits; - typedef typename implementation_defined::node node; - typedef typename implementation_defined::node_ptr node_ptr; - typedef typename implementation_defined::const_node_ptr const_node_ptr; - typedef typename implementation_defined::node_algorithms node_algorithms; - - static const bool constant_time_size = Config::constant_time_size; - - /// @cond - private: - tree_type tree_; - /// @endcond - - public: - //! <b>Effects</b>: Constructs an empty treap_set. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: If value_traits::node_traits::node - //! constructor throws (this does not happen with predefined Boost.Intrusive hooks) - //! or the copy constructor of the value_compare object throws. - treap_set_impl( const value_compare &cmp = value_compare() - , const priority_compare &pcmp = priority_compare() - , const value_traits &v_traits = value_traits()) - : tree_(cmp, pcmp, v_traits) - {} - - //! <b>Requires</b>: Dereferencing iterator must yield an lvalue of type value_type. - //! cmp must be a comparison function that induces a strict weak ordering. - //! - //! <b>Effects</b>: Constructs an empty treap_set and inserts elements from - //! [b, e). - //! - //! <b>Complexity</b>: Linear in N if [b, e) is already sorted using - //! comp and otherwise N * log N, where N is std::distance(last, first). - //! - //! <b>Throws</b>: If value_traits::node_traits::node - //! constructor throws (this does not happen with predefined Boost.Intrusive hooks) - //! or the copy constructor/operator() of the value_compare object throws. - template<class Iterator> - treap_set_impl( Iterator b, Iterator e - , const value_compare &cmp = value_compare() - , const priority_compare &pcmp = priority_compare() - , const value_traits &v_traits = value_traits()) - : tree_(true, b, e, cmp, pcmp, v_traits) - {} - - //! <b>Effects</b>: to-do - //! - treap_set_impl(BOOST_RV_REF(treap_set_impl) x) - : tree_(::boost::move(x.tree_)) - {} - - //! <b>Effects</b>: to-do - //! - treap_set_impl& operator=(BOOST_RV_REF(treap_set_impl) x) - { tree_ = ::boost::move(x.tree_); return *this; } - - //! <b>Effects</b>: Detaches all elements from this. The objects in the treap_set - //! are not deleted (i.e. no destructors are called). - //! - //! <b>Complexity</b>: Linear to the number of elements on the container. - //! if it's a safe-mode or auto-unlink value_type. Constant time otherwise. - //! - //! <b>Throws</b>: Nothing. - ~treap_set_impl() - {} - - //! <b>Effects</b>: Returns an iterator pointing to the beginning of the treap_set. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - iterator begin() - { return tree_.begin(); } - - //! <b>Effects</b>: Returns a const_iterator pointing to the beginning of the treap_set. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_iterator begin() const - { return tree_.begin(); } - - //! <b>Effects</b>: Returns a const_iterator pointing to the beginning of the treap_set. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_iterator cbegin() const - { return tree_.cbegin(); } - - //! <b>Effects</b>: Returns an iterator pointing to the end of the treap_set. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - iterator end() - { return tree_.end(); } - - //! <b>Effects</b>: Returns a const_iterator pointing to the end of the treap_set. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_iterator end() const - { return tree_.end(); } - - //! <b>Effects</b>: Returns an iterator pointing to the highest priority object of the tree. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - iterator top() - { return tree_.top(); } - - //! <b>Effects</b>: Returns a const_iterator pointing to the highest priority object of the tree.. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_iterator top() const - { return this->ctop(); } - - //! <b>Effects</b>: Returns a const_iterator pointing to the highest priority object of the tree.. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_iterator ctop() const - { return tree_.ctop(); } - - //! <b>Effects</b>: Returns a const_iterator pointing to the end of the treap_set. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_iterator cend() const - { return tree_.cend(); } - - //! <b>Effects</b>: Returns a reverse_iterator pointing to the beginning of the - //! reversed treap_set. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - reverse_iterator rbegin() - { return tree_.rbegin(); } - - //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning - //! of the reversed treap_set. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_reverse_iterator rbegin() const - { return tree_.rbegin(); } - - //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning - //! of the reversed treap_set. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_reverse_iterator crbegin() const - { return tree_.crbegin(); } - - //! <b>Effects</b>: Returns a reverse_iterator pointing to the end - //! of the reversed treap_set. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - reverse_iterator rend() - { return tree_.rend(); } - - //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the end - //! of the reversed treap_set. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_reverse_iterator rend() const - { return tree_.rend(); } - - //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the end - //! of the reversed treap_set. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_reverse_iterator crend() const - { return tree_.crend(); } - - //! <b>Effects</b>: Returns a reverse_iterator pointing to the highest priority object of the - //! reversed tree. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - reverse_iterator rtop() - { return tree_.rtop(); } - - //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the highest priority objec - //! of the reversed tree. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_reverse_iterator rtop() const - { return tree_.crtop(); } - - //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the highest priority object - //! of the reversed tree. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_reverse_iterator crtop() const - { return tree_.crtop(); } - - //! <b>Precondition</b>: end_iterator must be a valid end iterator - //! of treap_set. - //! - //! <b>Effects</b>: Returns a const reference to the treap_set associated to the end iterator - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - static treap_set_impl &container_from_end_iterator(iterator end_iterator) - { - return *detail::parent_from_member<treap_set_impl, tree_type> - ( &tree_type::container_from_end_iterator(end_iterator) - , &treap_set_impl::tree_); - } - - //! <b>Precondition</b>: end_iterator must be a valid end const_iterator - //! of treap_set. - //! - //! <b>Effects</b>: Returns a const reference to the treap_set associated to the end iterator - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - static const treap_set_impl &container_from_end_iterator(const_iterator end_iterator) - { - return *detail::parent_from_member<treap_set_impl, tree_type> - ( &tree_type::container_from_end_iterator(end_iterator) - , &treap_set_impl::tree_); - } - - //! <b>Precondition</b>: it must be a valid iterator of set. - //! - //! <b>Effects</b>: Returns a reference to the set associated to the iterator - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Logarithmic. - static treap_set_impl &container_from_iterator(iterator it) - { - return *detail::parent_from_member<treap_set_impl, tree_type> - ( &tree_type::container_from_iterator(it) - , &treap_set_impl::tree_); - } - - //! <b>Precondition</b>: it must be a valid const_iterator of set. - //! - //! <b>Effects</b>: Returns a const reference to the set associated to the iterator - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Logarithmic. - static const treap_set_impl &container_from_iterator(const_iterator it) - { - return *detail::parent_from_member<treap_set_impl, tree_type> - ( &tree_type::container_from_iterator(it) - , &treap_set_impl::tree_); - } - - //! <b>Effects</b>: Returns the key_compare object used by the treap_set. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: If key_compare copy-constructor throws. - key_compare key_comp() const - { return tree_.value_comp(); } - - //! <b>Effects</b>: Returns the value_compare object used by the treap_set. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: If value_compare copy-constructor throws. - value_compare value_comp() const - { return tree_.value_comp(); } - - //! <b>Effects</b>: Returns the priority_compare object used by the treap_set. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: If priority_compare copy-constructor throws. - priority_compare priority_comp() const - { return tree_.priority_comp(); } - - //! <b>Effects</b>: Returns true if the container is empty. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - bool empty() const - { return tree_.empty(); } - - //! <b>Effects</b>: Returns the number of elements stored in the treap_set. - //! - //! <b>Complexity</b>: Linear to elements contained in *this if, - //! constant-time size option is enabled. Constant-time otherwise. - //! - //! <b>Throws</b>: Nothing. - size_type size() const - { return tree_.size(); } - - //! <b>Effects</b>: Swaps the contents of two sets. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: If the swap() call for the comparison functor - //! found using ADL throws. Strong guarantee. - void swap(treap_set_impl& other) - { tree_.swap(other.tree_); } - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! Cloner should yield to nodes equivalent to the original nodes. - //! - //! <b>Effects</b>: Erases all the elements from *this - //! calling Disposer::operator()(pointer), clones all the - //! elements from src calling Cloner::operator()(const_reference ) - //! and inserts them on *this. Copies the predicate from the source container. - //! - //! If cloner throws, all cloned elements are unlinked and disposed - //! calling Disposer::operator()(pointer). - //! - //! <b>Complexity</b>: Linear to erased plus inserted elements. - //! - //! <b>Throws</b>: If cloner throws or predicate copy assignment throws. Basic guarantee. - template <class Cloner, class Disposer> - void clone_from(const treap_set_impl &src, Cloner cloner, Disposer disposer) - { tree_.clone_from(src.tree_, cloner, disposer); } - - //! <b>Requires</b>: value must be an lvalue - //! - //! <b>Effects</b>: Tries to inserts value into the treap_set. - //! - //! <b>Returns</b>: If the value - //! is not already present inserts it and returns a pair containing the - //! iterator to the new value and true. If there is an equivalent value - //! returns a pair containing an iterator to the already present value - //! and false. - //! - //! <b>Complexity</b>: Average complexity for insert element is at - //! most logarithmic. - //! - //! <b>Throws</b>: If the internal value_compare or priority_compare ordering function throw. - //! Strong guarantee. - //! - //! <b>Note</b>: Does not affect the validity of iterators and references. - //! No copy-constructors are called. - std::pair<iterator, bool> insert(reference value) - { return tree_.insert_unique(value); } - - //! <b>Requires</b>: value must be an lvalue - //! - //! <b>Effects</b>: Tries to to insert x into the treap_set, using "hint" - //! as a hint to where it will be inserted. - //! - //! <b>Returns</b>: An iterator that points to the position where the - //! new element was inserted into the treap_set. - //! - //! <b>Complexity</b>: Logarithmic in general, but it's amortized - //! constant time if t is inserted immediately before hint. - //! - //! <b>Throws</b>: If the internal value_compare or priority_compare ordering - //! functions throw. Strong guarantee. - //! - //! <b>Note</b>: Does not affect the validity of iterators and references. - //! No copy-constructors are called. - iterator insert(const_iterator hint, reference value) - { return tree_.insert_unique(hint, value); } - - //! <b>Requires</b>: key_value_comp must be a comparison function that induces - //! the same strict weak ordering as value_compare. - //! key_value_pcomp must be a comparison function that induces - //! the same strict weak ordering as priority_compare. The difference is that - //! key_value_pcomp and key_value_comp compare an arbitrary key with the contained values. - //! - //! <b>Effects</b>: Checks if a value can be inserted in the treap_set, using - //! a user provided key instead of the value itself. - //! - //! <b>Returns</b>: If there is an equivalent value - //! returns a pair containing an iterator to the already present value - //! and false. If the value can be inserted returns true in the returned - //! pair boolean and fills "commit_data" that is meant to be used with - //! the "insert_commit" function. - //! - //! <b>Complexity</b>: Average complexity is at most logarithmic. - //! - //! <b>Throws</b>: If key_value_comp or key_value_pcomp ordering function throw. - //! Strong guarantee. - //! - //! <b>Notes</b>: This function is used to improve performance when constructing - //! a value_type is expensive: if there is an equivalent value - //! the constructed object must be discarded. Many times, the part of the - //! node that is used to impose the order is much cheaper to construct - //! than the value_type and this function offers the possibility to use that - //! part to check if the insertion will be successful. - //! - //! If the check is successful, the user can construct the value_type and use - //! "insert_commit" to insert the object in constant-time. This gives a total - //! logarithmic complexity to the insertion: check(O(log(N)) + commit(O(1)). - //! - //! "commit_data" remains valid for a subsequent "insert_commit" only if no more - //! objects are inserted or erased from the treap_set. - template<class KeyType, class KeyValueCompare, class KeyValuePriorityCompare> - std::pair<iterator, bool> insert_check - ( const KeyType &key, KeyValueCompare key_value_comp, KeyValuePriorityCompare key_value_pcomp - , insert_commit_data &commit_data) - { return tree_.insert_unique_check(key, key_value_comp, key_value_pcomp, commit_data); } - - //! <b>Requires</b>: key_value_comp must be a comparison function that induces - //! the same strict weak ordering as value_compare. - //! key_value_pcomp must be a comparison function that induces - //! the same strict weak ordering as priority_compare. The difference is that - //! key_value_pcomp and key_value_comp compare an arbitrary key with the contained values. - //! - //! <b>Effects</b>: Checks if a value can be inserted in the treap_set, using - //! a user provided key instead of the value itself, using "hint" - //! as a hint to where it will be inserted. - //! - //! <b>Returns</b>: If there is an equivalent value - //! returns a pair containing an iterator to the already present value - //! and false. If the value can be inserted returns true in the returned - //! pair boolean and fills "commit_data" that is meant to be used with - //! the "insert_commit" function. - //! - //! <b>Complexity</b>: Logarithmic in general, but it's amortized - //! constant time if t is inserted immediately before hint. - //! - //! <b>Throws</b>: If key_value_comp or key_value_pcomp ordering function throw. - //! Strong guarantee. - //! - //! <b>Notes</b>: This function is used to improve performance when constructing - //! a value_type is expensive: if there is an equivalent value - //! the constructed object must be discarded. Many times, the part of the - //! constructing that is used to impose the order is much cheaper to construct - //! than the value_type and this function offers the possibility to use that key - //! to check if the insertion will be successful. - //! - //! If the check is successful, the user can construct the value_type and use - //! "insert_commit" to insert the object in constant-time. This can give a total - //! constant-time complexity to the insertion: check(O(1)) + commit(O(1)). - //! - //! "commit_data" remains valid for a subsequent "insert_commit" only if no more - //! objects are inserted or erased from the treap_set. - template<class KeyType, class KeyValueCompare, class KeyValuePriorityCompare> - std::pair<iterator, bool> insert_check - ( const_iterator hint, const KeyType &key - , KeyValueCompare key_value_comp, KeyValuePriorityCompare key_value_pcomp - , insert_commit_data &commit_data) - { return tree_.insert_unique_check(hint, key, key_value_comp, key_value_pcomp, commit_data); } - - //! <b>Requires</b>: value must be an lvalue of type value_type. commit_data - //! must have been obtained from a previous call to "insert_check". - //! No objects should have been inserted or erased from the treap_set between - //! the "insert_check" that filled "commit_data" and the call to "insert_commit". - //! - //! <b>Effects</b>: Inserts the value in the treap_set using the information obtained - //! from the "commit_data" that a previous "insert_check" filled. - //! - //! <b>Returns</b>: An iterator to the newly inserted object. - //! - //! <b>Complexity</b>: Constant time. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Notes</b>: This function has only sense if a "insert_check" has been - //! previously executed to fill "commit_data". No value should be inserted or - //! erased between the "insert_check" and "insert_commit" calls. - iterator insert_commit(reference value, const insert_commit_data &commit_data) - { return tree_.insert_unique_commit(value, commit_data); } - - //! <b>Requires</b>: Dereferencing iterator must yield an lvalue - //! of type value_type. - //! - //! <b>Effects</b>: Inserts a range into the treap_set. - //! - //! <b>Complexity</b>: Insert range is in general O(N * log(N)), where N is the - //! size of the range. However, it is linear in N if the range is already sorted - //! by value_comp(). - //! - //! <b>Throws</b>: If the internal value_compare or priority_compare ordering function - //! throw. Basic guarantee. - //! - //! <b>Note</b>: Does not affect the validity of iterators and references. - //! No copy-constructors are called. - template<class Iterator> - void insert(Iterator b, Iterator e) - { tree_.insert_unique(b, e); } - - //! <b>Requires</b>: value must be an lvalue, "pos" must be - //! a valid iterator (or end) and must be the succesor of value - //! once inserted according to the predicate. "value" must not be equal to any - //! inserted key according to the predicate. - //! - //! <b>Effects</b>: Inserts x into the treap before "pos". - //! - //! <b>Complexity</b>: Constant time. - //! - //! <b>Throws</b>: If the internal priority_compare function throws. Strong guarantee. - //! - //! <b>Note</b>: This function does not check preconditions so if "pos" is not - //! the successor of "value" treap ordering invariant will be broken. - //! This is a low-level function to be used only for performance reasons - //! by advanced users. - iterator insert_before(const_iterator pos, reference value) - { return tree_.insert_before(pos, value); } - - //! <b>Requires</b>: value must be an lvalue, and it must be greater than - //! any inserted key according to the predicate. - //! - //! <b>Effects</b>: Inserts x into the treap in the last position. - //! - //! <b>Complexity</b>: Constant time. - //! - //! <b>Throws</b>: If the internal priority_compare function throws. Strong guarantee. - //! - //! <b>Note</b>: This function does not check preconditions so if value is - //! less than the greatest inserted key treap ordering invariant will be broken. - //! This function is slightly more efficient than using "insert_before". - //! This is a low-level function to be used only for performance reasons - //! by advanced users. - void push_back(reference value) - { tree_.push_back(value); } - - //! <b>Requires</b>: value must be an lvalue, and it must be less - //! than any inserted key according to the predicate. - //! - //! <b>Effects</b>: Inserts x into the treap in the first position. - //! - //! <b>Complexity</b>: Constant time. - //! - //! <b>Throws</b>: If the internal priority_compare function throws. Strong guarantee. - //! - //! <b>Note</b>: This function does not check preconditions so if value is - //! greater than the minimum inserted key treap ordering invariant will be broken. - //! This function is slightly more efficient than using "insert_before". - //! This is a low-level function to be used only for performance reasons - //! by advanced users. - void push_front(reference value) - { tree_.push_front(value); } - - //! <b>Effects</b>: Erases the element pointed to by pos. - //! - //! <b>Complexity</b>: Average complexity is constant time. - //! - //! <b>Returns</b>: An iterator to the element after the erased element. - //! - //! <b>Throws</b>: If the internal priority_compare function throws. Strong guarantee. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - iterator erase(const_iterator i) - { return tree_.erase(i); } - - //! <b>Effects</b>: Erases the range pointed to by b end e. - //! - //! <b>Complexity</b>: Average complexity for erase range is at most - //! O(log(size() + N)), where N is the number of elements in the range. - //! - //! <b>Returns</b>: An iterator to the element after the erased elements. - //! - //! <b>Throws</b>: If the internal priority_compare function throws. Basic guarantee. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - iterator erase(const_iterator b, const_iterator e) - { return tree_.erase(b, e); } - - //! <b>Effects</b>: Erases all the elements with the given value. - //! - //! <b>Returns</b>: The number of erased elements. - //! - //! <b>Complexity</b>: O(log(size()) + this->count(value)). - //! - //! <b>Throws</b>: If internal value_compare or priority_compare - //! ordering functions throw. Basic guarantee. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - size_type erase(const_reference value) - { return tree_.erase(value); } - - //! <b>Effects</b>: Erases all the elements that compare equal with - //! the given key and the given comparison functor. - //! - //! <b>Returns</b>: The number of erased elements. - //! - //! <b>Complexity</b>: O(log(size() + this->count(key, comp)). - //! - //! <b>Throws</b>: If comp or internal priority_compare - //! ordering functions throw. Basic guarantee. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - template<class KeyType, class KeyValueCompare> - size_type erase(const KeyType& key, KeyValueCompare comp - /// @cond - , typename detail::enable_if_c<!detail::is_convertible<KeyValueCompare, const_iterator>::value >::type * = 0 - /// @endcond - ) - { return tree_.erase(key, comp); } - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! - //! <b>Effects</b>: Erases the element pointed to by pos. - //! Disposer::operator()(pointer) is called for the removed element. - //! - //! <b>Complexity</b>: Average complexity for erase element is constant time. - //! - //! <b>Returns</b>: An iterator to the element after the erased element. - //! - //! <b>Throws</b>: If the internal priority_compare function throws. Strong guarantee. - //! - //! <b>Note</b>: Invalidates the iterators - //! to the erased elements. - template<class Disposer> - iterator erase_and_dispose(const_iterator i, Disposer disposer) - { return tree_.erase_and_dispose(i, disposer); } - - #if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) - template<class Disposer> - iterator erase_and_dispose(iterator i, Disposer disposer) - { return this->erase_and_dispose(const_iterator(i), disposer); } - #endif - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! - //! <b>Effects</b>: Erases the range pointed to by b end e. - //! Disposer::operator()(pointer) is called for the removed elements. - //! - //! <b>Complexity</b>: Average complexity for erase range is at most - //! O(log(size() + N)), where N is the number of elements in the range. - //! - //! <b>Returns</b>: An iterator to the element after the erased elements. - //! - //! <b>Throws</b>: If the internal priority_compare function throws. Basic guarantee. - //! - //! <b>Note</b>: Invalidates the iterators - //! to the erased elements. - template<class Disposer> - iterator erase_and_dispose(const_iterator b, const_iterator e, Disposer disposer) - { return tree_.erase_and_dispose(b, e, disposer); } - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! - //! <b>Effects</b>: Erases all the elements with the given value. - //! Disposer::operator()(pointer) is called for the removed elements. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. - //! - //! <b>Complexity</b>: O(log(size() + this->count(value)). Basic guarantee. - //! - //! <b>Throws</b>: If the internal priority_compare function throws. Strong guarantee. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - template<class Disposer> - size_type erase_and_dispose(const_reference value, Disposer disposer) - { return tree_.erase_and_dispose(value, disposer); } - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! - //! <b>Effects</b>: Erases all the elements with the given key. - //! according to the comparison functor "comp". - //! Disposer::operator()(pointer) is called for the removed elements. - //! - //! <b>Returns</b>: The number of erased elements. - //! - //! <b>Complexity</b>: O(log(size() + this->count(key, comp)). - //! - //! <b>Throws</b>: If comp or internal priority_compare ordering functions throw. - //! Basic guarantee. - //! - //! <b>Note</b>: Invalidates the iterators - //! to the erased elements. - template<class KeyType, class KeyValueCompare, class Disposer> - size_type erase_and_dispose(const KeyType& key, KeyValueCompare comp, Disposer disposer - /// @cond - , typename detail::enable_if_c<!detail::is_convertible<KeyValueCompare, const_iterator>::value >::type * = 0 - /// @endcond - ) - { return tree_.erase_and_dispose(key, comp, disposer); } - - //! <b>Effects</b>: Erases all the elements of the container. - //! - //! <b>Complexity</b>: Linear to the number of elements on the container. - //! if it's a safe-mode or auto-unlink value_type. Constant time otherwise. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - void clear() - { return tree_.clear(); } - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! - //! <b>Effects</b>: Erases all the elements of the container. - //! - //! <b>Complexity</b>: Linear to the number of elements on the container. - //! Disposer::operator()(pointer) is called for the removed elements. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - template<class Disposer> - void clear_and_dispose(Disposer disposer) - { return tree_.clear_and_dispose(disposer); } - - //! <b>Effects</b>: Returns the number of contained elements with the given key - //! - //! <b>Complexity</b>: Logarithmic to the number of elements contained plus lineal - //! to number of objects with the given key. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. - size_type count(const_reference value) const - { return tree_.find(value) != end(); } - - //! <b>Effects</b>: Returns the number of contained elements with the same key - //! compared with the given comparison functor. - //! - //! <b>Complexity</b>: Logarithmic to the number of elements contained plus lineal - //! to number of objects with the given key. - //! - //! <b>Throws</b>: If comp ordering function throws. - template<class KeyType, class KeyValueCompare> - size_type count(const KeyType& key, KeyValueCompare comp) const - { return tree_.find(key, comp) != end(); } - - //! <b>Effects</b>: Returns an iterator to the first element whose - //! key is not less than k or end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. - iterator lower_bound(const_reference value) - { return tree_.lower_bound(value); } - - //! <b>Requires</b>: comp must imply the same element order as - //! value_compare. Usually key is the part of the value_type - //! that is used in the ordering functor. - //! - //! <b>Effects</b>: Returns an iterator to the first element whose - //! key according to the comparison functor is not less than k or - //! end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If comp ordering function throws. - //! - //! <b>Note</b>: This function is used when constructing a value_type - //! is expensive and the value_type can be compared with a cheaper - //! key type. Usually this key is part of the value_type. - template<class KeyType, class KeyValueCompare> - iterator lower_bound(const KeyType& key, KeyValueCompare comp) - { return tree_.lower_bound(key, comp); } - - //! <b>Effects</b>: Returns a const iterator to the first element whose - //! key is not less than k or end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. - const_iterator lower_bound(const_reference value) const - { return tree_.lower_bound(value); } - - //! <b>Requires</b>: comp must imply the same element order as - //! value_compare. Usually key is the part of the value_type - //! that is used in the ordering functor. - //! - //! <b>Effects</b>: Returns a const_iterator to the first element whose - //! key according to the comparison functor is not less than k or - //! end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If comp ordering function throws. - //! - //! <b>Note</b>: This function is used when constructing a value_type - //! is expensive and the value_type can be compared with a cheaper - //! key type. Usually this key is part of the value_type. - template<class KeyType, class KeyValueCompare> - const_iterator lower_bound(const KeyType& key, KeyValueCompare comp) const - { return tree_.lower_bound(key, comp); } - - //! <b>Effects</b>: Returns an iterator to the first element whose - //! key is greater than k or end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. - iterator upper_bound(const_reference value) - { return tree_.upper_bound(value); } - - //! <b>Requires</b>: comp must imply the same element order as - //! value_compare. Usually key is the part of the value_type - //! that is used in the ordering functor. - //! - //! <b>Effects</b>: Returns an iterator to the first element whose - //! key according to the comparison functor is greater than key or - //! end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If comp ordering function throws. - //! - //! <b>Note</b>: This function is used when constructing a value_type - //! is expensive and the value_type can be compared with a cheaper - //! key type. Usually this key is part of the value_type. - template<class KeyType, class KeyValueCompare> - iterator upper_bound(const KeyType& key, KeyValueCompare comp) - { return tree_.upper_bound(key, comp); } - - //! <b>Effects</b>: Returns an iterator to the first element whose - //! key is greater than k or end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. - const_iterator upper_bound(const_reference value) const - { return tree_.upper_bound(value); } - - //! <b>Requires</b>: comp must imply the same element order as - //! value_compare. Usually key is the part of the value_type - //! that is used in the ordering functor. - //! - //! <b>Effects</b>: Returns a const_iterator to the first element whose - //! key according to the comparison functor is greater than key or - //! end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If comp ordering function throws. - //! - //! <b>Note</b>: This function is used when constructing a value_type - //! is expensive and the value_type can be compared with a cheaper - //! key type. Usually this key is part of the value_type. - template<class KeyType, class KeyValueCompare> - const_iterator upper_bound(const KeyType& key, KeyValueCompare comp) const - { return tree_.upper_bound(key, comp); } - - //! <b>Effects</b>: Finds an iterator to the first element whose value is - //! "value" or end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. - iterator find(const_reference value) - { return tree_.find(value); } - - //! <b>Requires</b>: comp must imply the same element order as - //! value_compare. Usually key is the part of the value_type - //! that is used in the ordering functor. - //! - //! <b>Effects</b>: Finds an iterator to the first element whose key is - //! "key" according to the comparison functor or end() if that element - //! does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If comp ordering function throws. - //! - //! <b>Note</b>: This function is used when constructing a value_type - //! is expensive and the value_type can be compared with a cheaper - //! key type. Usually this key is part of the value_type. - template<class KeyType, class KeyValueCompare> - iterator find(const KeyType& key, KeyValueCompare comp) - { return tree_.find(key, comp); } - - //! <b>Effects</b>: Finds a const_iterator to the first element whose value is - //! "value" or end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. - const_iterator find(const_reference value) const - { return tree_.find(value); } - - //! <b>Requires</b>: comp must imply the same element order as - //! value_compare. Usually key is the part of the value_type - //! that is used in the ordering functor. - //! - //! <b>Effects</b>: Finds a const_iterator to the first element whose key is - //! "key" according to the comparison functor or end() if that element - //! does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If comp ordering function throws. - //! - //! <b>Note</b>: This function is used when constructing a value_type - //! is expensive and the value_type can be compared with a cheaper - //! key type. Usually this key is part of the value_type. - template<class KeyType, class KeyValueCompare> - const_iterator find(const KeyType& key, KeyValueCompare comp) const - { return tree_.find(key, comp); } - - //! <b>Effects</b>: Finds a range containing all elements whose key is k or - //! an empty range that indicates the position where those elements would be - //! if they there is no elements with key k. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. - std::pair<iterator,iterator> equal_range(const_reference value) - { return tree_.equal_range(value); } - - //! <b>Requires</b>: comp must imply the same element order as - //! value_compare. Usually key is the part of the value_type - //! that is used in the ordering functor. - //! - //! <b>Effects</b>: Finds a range containing all elements whose key is k - //! according to the comparison functor or an empty range - //! that indicates the position where those elements would be - //! if they there is no elements with key k. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If comp ordering function throws. - //! - //! <b>Note</b>: This function is used when constructing a value_type - //! is expensive and the value_type can be compared with a cheaper - //! key type. Usually this key is part of the value_type. - template<class KeyType, class KeyValueCompare> - std::pair<iterator,iterator> equal_range(const KeyType& key, KeyValueCompare comp) - { return tree_.equal_range(key, comp); } - - //! <b>Effects</b>: Finds a range containing all elements whose key is k or - //! an empty range that indicates the position where those elements would be - //! if they there is no elements with key k. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. - std::pair<const_iterator, const_iterator> - equal_range(const_reference value) const - { return tree_.equal_range(value); } - - //! <b>Requires</b>: comp must imply the same element order as - //! value_compare. Usually key is the part of the value_type - //! that is used in the ordering functor. - //! - //! <b>Effects</b>: Finds a range containing all elements whose key is k - //! according to the comparison functor or an empty range - //! that indicates the position where those elements would be - //! if they there is no elements with key k. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If comp ordering function throws. - //! - //! <b>Note</b>: This function is used when constructing a value_type - //! is expensive and the value_type can be compared with a cheaper - //! key type. Usually this key is part of the value_type. - template<class KeyType, class KeyValueCompare> - std::pair<const_iterator, const_iterator> - equal_range(const KeyType& key, KeyValueCompare comp) const - { return tree_.equal_range(key, comp); } - - //! <b>Requires</b>: value must be an lvalue and shall be in a treap_set of - //! appropriate type. Otherwise the behavior is undefined. - //! - //! <b>Effects</b>: Returns: a valid iterator i belonging to the treap_set - //! that points to the value - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: This static function is available only if the <i>value traits</i> - //! is stateless. - static iterator s_iterator_to(reference value) - { return tree_type::s_iterator_to(value); } - - //! <b>Requires</b>: value must be an lvalue and shall be in a treap_set of - //! appropriate type. Otherwise the behavior is undefined. - //! - //! <b>Effects</b>: Returns: a valid const_iterator i belonging to the - //! treap_set that points to the value - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: This static function is available only if the <i>value traits</i> - //! is stateless. - static const_iterator s_iterator_to(const_reference value) - { return tree_type::s_iterator_to(value); } - - //! <b>Requires</b>: value must be an lvalue and shall be in a treap_set of - //! appropriate type. Otherwise the behavior is undefined. - //! - //! <b>Effects</b>: Returns: a valid iterator i belonging to the treap_set - //! that points to the value - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - iterator iterator_to(reference value) - { return tree_.iterator_to(value); } - - //! <b>Requires</b>: value must be an lvalue and shall be in a treap_set of - //! appropriate type. Otherwise the behavior is undefined. - //! - //! <b>Effects</b>: Returns: a valid const_iterator i belonging to the - //! treap_set that points to the value - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_iterator iterator_to(const_reference value) const - { return tree_.iterator_to(value); } - - //! <b>Requires</b>: value shall not be in a treap_set/treap_multiset. - //! - //! <b>Effects</b>: init_node puts the hook of a value in a well-known default - //! state. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant time. - //! - //! <b>Note</b>: This function puts the hook in the well-known default state - //! used by auto_unlink and safe hooks. - static void init_node(reference value) - { tree_type::init_node(value); } - - //! <b>Effects</b>: Unlinks the leftmost node from the tree. - //! - //! <b>Complexity</b>: Average complexity is constant time. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Notes</b>: This function breaks the tree and the tree can - //! only be used for more unlink_leftmost_without_rebalance calls. - //! This function is normally used to achieve a step by step - //! controlled destruction of the tree. - pointer unlink_leftmost_without_rebalance() - { return tree_.unlink_leftmost_without_rebalance(); } - - //! <b>Requires</b>: replace_this must be a valid iterator of *this - //! and with_this must not be inserted in any tree. - //! - //! <b>Effects</b>: Replaces replace_this in its position in the - //! tree with with_this. The tree does not need to be rebalanced. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: This function will break container ordering invariants if - //! with_this is not equivalent to *replace_this according to the - //! ordering rules. This function is faster than erasing and inserting - //! the node, since no rebalancing or comparison is needed. - void replace_node(iterator replace_this, reference with_this) - { tree_.replace_node(replace_this, with_this); } - - //! <b>Effects</b>: Rebalances the tree. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Linear. - void rebalance() - { tree_.rebalance(); } - - //! <b>Requires</b>: old_root is a node of a tree. - //! - //! <b>Effects</b>: Rebalances the subtree rooted at old_root. - //! - //! <b>Returns</b>: The new root of the subtree. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Linear to the elements in the subtree. - iterator rebalance_subtree(iterator root) - { return tree_.rebalance_subtree(root); } - - //! <b>Returns</b>: The balance factor (alpha) used in this tree - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - float balance_factor() const - { return tree_.balance_factor(); } - - //! <b>Requires</b>: new_alpha must be a value between 0.5 and 1.0 - //! - //! <b>Effects</b>: Establishes a new balance factor (alpha) and rebalances - //! the tree if the new balance factor is stricter (less) than the old factor. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Linear to the elements in the subtree. - void balance_factor(float new_alpha) - { tree_.balance_factor(new_alpha); } - - /// @cond - friend bool operator==(const treap_set_impl &x, const treap_set_impl &y) - { return x.tree_ == y.tree_; } - - friend bool operator<(const treap_set_impl &x, const treap_set_impl &y) - { return x.tree_ < y.tree_; } - /// @endcond -}; - -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -inline bool operator!= -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -(const treap_set_impl<T, Options...> &x, const treap_set_impl<T, Options...> &y) -#else -(const treap_set_impl<Config> &x, const treap_set_impl<Config> &y) -#endif -{ return !(x == y); } - -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -inline bool operator> -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -(const treap_set_impl<T, Options...> &x, const treap_set_impl<T, Options...> &y) -#else -(const treap_set_impl<Config> &x, const treap_set_impl<Config> &y) -#endif -{ return y < x; } - -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -inline bool operator<= -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -(const treap_set_impl<T, Options...> &x, const treap_set_impl<T, Options...> &y) -#else -(const treap_set_impl<Config> &x, const treap_set_impl<Config> &y) -#endif -{ return !(y < x); } - -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -inline bool operator>= -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -(const treap_set_impl<T, Options...> &x, const treap_set_impl<T, Options...> &y) -#else -(const treap_set_impl<Config> &x, const treap_set_impl<Config> &y) -#endif -{ return !(x < y); } - -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -inline void swap -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -(treap_set_impl<T, Options...> &x, treap_set_impl<T, Options...> &y) -#else -(treap_set_impl<Config> &x, treap_set_impl<Config> &y) -#endif -{ x.swap(y); } - -//! Helper metafunction to define a \c treap_set that yields to the same type when the -//! same options (either explicitly or implicitly) are used. -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) || defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template<class T, class ...Options> -#else -template<class T, class O1 = none, class O2 = none - , class O3 = none, class O4 = none> -#endif -struct make_treap_set -{ - /// @cond - typedef treap_set_impl - < typename make_treap_opt<T, - #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) - O1, O2, O3, O4 - #else - Options... - #endif - >::type - > implementation_defined; - /// @endcond - typedef implementation_defined type; -}; - -#ifndef BOOST_INTRUSIVE_DOXYGEN_INVOKED - -#if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template<class T, class O1, class O2, class O3, class O4> -#else -template<class T, class ...Options> -#endif -class treap_set - : public make_treap_set<T, - #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) - O1, O2, O3, O4 - #else - Options... - #endif - >::type -{ - typedef typename make_treap_set - <T, - #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) - O1, O2, O3, O4 - #else - Options... - #endif - >::type Base; - BOOST_MOVABLE_BUT_NOT_COPYABLE(treap_set) - - public: - typedef typename Base::value_compare value_compare; - typedef typename Base::priority_compare priority_compare; - typedef typename Base::value_traits value_traits; - typedef typename Base::iterator iterator; - typedef typename Base::const_iterator const_iterator; - - //Assert if passed value traits are compatible with the type - BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value)); - - treap_set( const value_compare &cmp = value_compare() - , const priority_compare &pcmp = priority_compare() - , const value_traits &v_traits = value_traits()) - : Base(cmp, pcmp, v_traits) - {} - - template<class Iterator> - treap_set( Iterator b, Iterator e - , const value_compare &cmp = value_compare() - , const priority_compare &pcmp = priority_compare() - , const value_traits &v_traits = value_traits()) - : Base(b, e, cmp, pcmp, v_traits) - {} - - treap_set(BOOST_RV_REF(treap_set) x) - : Base(::boost::move(static_cast<Base&>(x))) - {} - - treap_set& operator=(BOOST_RV_REF(treap_set) x) - { this->Base::operator=(::boost::move(static_cast<Base&>(x))); return *this; } - - static treap_set &container_from_end_iterator(iterator end_iterator) - { return static_cast<treap_set &>(Base::container_from_end_iterator(end_iterator)); } - - static const treap_set &container_from_end_iterator(const_iterator end_iterator) - { return static_cast<const treap_set &>(Base::container_from_end_iterator(end_iterator)); } - - static treap_set &container_from_iterator(iterator it) - { return static_cast<treap_set &>(Base::container_from_iterator(it)); } - - static const treap_set &container_from_iterator(const_iterator it) - { return static_cast<const treap_set &>(Base::container_from_iterator(it)); } -}; - -#endif - -//! The class template treap_multiset is an intrusive container, that mimics most of -//! the interface of std::treap_multiset as described in the C++ standard. -//! -//! The template parameter \c T is the type to be managed by the container. -//! The user can specify additional options and if no options are provided -//! default options are used. -//! -//! The container supports the following options: -//! \c base_hook<>/member_hook<>/value_traits<>, -//! \c constant_time_size<>, \c size_type<>, -//! \c compare<> and \c priority_compare<> -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -class treap_multiset_impl -{ - /// @cond - typedef treap_impl<Config> tree_type; - - BOOST_MOVABLE_BUT_NOT_COPYABLE(treap_multiset_impl) - typedef tree_type implementation_defined; - /// @endcond - - public: - typedef typename implementation_defined::value_type value_type; - typedef typename implementation_defined::value_traits value_traits; - typedef typename implementation_defined::pointer pointer; - typedef typename implementation_defined::const_pointer const_pointer; - typedef typename implementation_defined::reference reference; - typedef typename implementation_defined::const_reference const_reference; - typedef typename implementation_defined::difference_type difference_type; - typedef typename implementation_defined::size_type size_type; - typedef typename implementation_defined::value_compare value_compare; - typedef typename implementation_defined::priority_compare priority_compare; - typedef typename implementation_defined::key_compare key_compare; - typedef typename implementation_defined::iterator iterator; - typedef typename implementation_defined::const_iterator const_iterator; - typedef typename implementation_defined::reverse_iterator reverse_iterator; - typedef typename implementation_defined::const_reverse_iterator const_reverse_iterator; - typedef typename implementation_defined::insert_commit_data insert_commit_data; - typedef typename implementation_defined::node_traits node_traits; - typedef typename implementation_defined::node node; - typedef typename implementation_defined::node_ptr node_ptr; - typedef typename implementation_defined::const_node_ptr const_node_ptr; - typedef typename implementation_defined::node_algorithms node_algorithms; - - static const bool constant_time_size = Config::constant_time_size; - - /// @cond - private: - tree_type tree_; - /// @endcond - - public: - //! <b>Effects</b>: Constructs an empty treap_multiset. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: If value_traits::node_traits::node - //! constructor throws (this does not happen with predefined Boost.Intrusive hooks) - //! or the copy constructor of the value_compare/priority_compare objects throw. - treap_multiset_impl( const value_compare &cmp = value_compare() - , const priority_compare &pcmp = priority_compare() - , const value_traits &v_traits = value_traits()) - : tree_(cmp, pcmp, v_traits) - {} - - //! <b>Requires</b>: Dereferencing iterator must yield an lvalue of type value_type. - //! cmp must be a comparison function that induces a strict weak ordering. - //! - //! <b>Effects</b>: Constructs an empty treap_multiset and inserts elements from - //! [b, e). - //! - //! <b>Complexity</b>: Linear in N if [b, e) is already sorted using - //! comp and otherwise N * log N, where N is the distance between first and last - //! - //! <b>Throws</b>: If value_traits::node_traits::node - //! constructor throws (this does not happen with predefined Boost.Intrusive hooks) - //! or the copy constructor/operator() of the value_compare/priority_compare objects throw. - template<class Iterator> - treap_multiset_impl( Iterator b, Iterator e - , const value_compare &cmp = value_compare() - , const priority_compare &pcmp = priority_compare() - , const value_traits &v_traits = value_traits()) - : tree_(false, b, e, cmp, pcmp, v_traits) - {} - - //! <b>Effects</b>: to-do - //! - treap_multiset_impl(BOOST_RV_REF(treap_multiset_impl) x) - : tree_(::boost::move(x.tree_)) - {} - - //! <b>Effects</b>: to-do - //! - treap_multiset_impl& operator=(BOOST_RV_REF(treap_multiset_impl) x) - { tree_ = ::boost::move(x.tree_); return *this; } - - //! <b>Effects</b>: Detaches all elements from this. The objects in the treap_multiset - //! are not deleted (i.e. no destructors are called). - //! - //! <b>Complexity</b>: Linear to the number of elements on the container. - //! if it's a safe-mode or auto-unlink value_type. Constant time otherwise. - //! - //! <b>Throws</b>: Nothing. - ~treap_multiset_impl() - {} - - //! <b>Effects</b>: Returns an iterator pointing to the beginning of the treap_multiset. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - iterator begin() - { return tree_.begin(); } - - //! <b>Effects</b>: Returns a const_iterator pointing to the beginning of the treap_multiset. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_iterator begin() const - { return tree_.begin(); } - - //! <b>Effects</b>: Returns a const_iterator pointing to the beginning of the treap_multiset. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_iterator cbegin() const - { return tree_.cbegin(); } - - //! <b>Effects</b>: Returns an iterator pointing to the end of the treap_multiset. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - iterator end() - { return tree_.end(); } - - //! <b>Effects</b>: Returns a const_iterator pointing to the end of the treap_multiset. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_iterator end() const - { return tree_.end(); } - - //! <b>Effects</b>: Returns a const_iterator pointing to the end of the treap_multiset. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_iterator cend() const - { return tree_.cend(); } - - //! <b>Effects</b>: Returns an iterator pointing to the highest priority object of the tree. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - iterator top() - { return tree_.top(); } - - //! <b>Effects</b>: Returns a const_iterator pointing to the highest priority object of the tree.. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_iterator top() const - { return this->ctop(); } - - //! <b>Effects</b>: Returns a const_iterator pointing to the highest priority object of the tree.. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_iterator ctop() const - { return tree_.ctop(); } - - //! <b>Effects</b>: Returns a reverse_iterator pointing to the beginning of the - //! reversed treap_multiset. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - reverse_iterator rbegin() - { return tree_.rbegin(); } - - //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning - //! of the reversed treap_multiset. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_reverse_iterator rbegin() const - { return tree_.rbegin(); } - - //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning - //! of the reversed treap_multiset. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_reverse_iterator crbegin() const - { return tree_.crbegin(); } - - //! <b>Effects</b>: Returns a reverse_iterator pointing to the end - //! of the reversed treap_multiset. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - reverse_iterator rend() - { return tree_.rend(); } - - //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the end - //! of the reversed treap_multiset. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_reverse_iterator rend() const - { return tree_.rend(); } - - //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the end - //! of the reversed treap_multiset. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_reverse_iterator crend() const - { return tree_.crend(); } - - //! <b>Effects</b>: Returns a reverse_iterator pointing to the highest priority object of the - //! reversed tree. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - reverse_iterator rtop() - { return tree_.rtop(); } - - //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the highest priority objec - //! of the reversed tree. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_reverse_iterator rtop() const - { return tree_.crtop(); } - - //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the highest priority object - //! of the reversed tree. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_reverse_iterator crtop() const - { return tree_.crtop(); } - - //! <b>Precondition</b>: end_iterator must be a valid end iterator - //! of treap_multiset. - //! - //! <b>Effects</b>: Returns a const reference to the treap_multiset associated to the end iterator - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - static treap_multiset_impl &container_from_end_iterator(iterator end_iterator) - { - return *detail::parent_from_member<treap_multiset_impl, tree_type> - ( &tree_type::container_from_end_iterator(end_iterator) - , &treap_multiset_impl::tree_); - } - - //! <b>Precondition</b>: end_iterator must be a valid end const_iterator - //! of treap_multiset. - //! - //! <b>Effects</b>: Returns a const reference to the treap_multiset associated to the end iterator - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - static const treap_multiset_impl &container_from_end_iterator(const_iterator end_iterator) - { - return *detail::parent_from_member<treap_multiset_impl, tree_type> - ( &tree_type::container_from_end_iterator(end_iterator) - , &treap_multiset_impl::tree_); - } - - //! <b>Precondition</b>: it must be a valid iterator of multiset. - //! - //! <b>Effects</b>: Returns a const reference to the multiset associated to the iterator - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - static treap_multiset_impl &container_from_iterator(iterator it) - { - return *detail::parent_from_member<treap_multiset_impl, tree_type> - ( &tree_type::container_from_iterator(it) - , &treap_multiset_impl::tree_); - } - - //! <b>Precondition</b>: it must be a valid const_iterator of multiset. - //! - //! <b>Effects</b>: Returns a const reference to the multiset associated to the iterator - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - static const treap_multiset_impl &container_from_iterator(const_iterator it) - { - return *detail::parent_from_member<treap_multiset_impl, tree_type> - ( &tree_type::container_from_iterator(it) - , &treap_multiset_impl::tree_); - } - - //! <b>Effects</b>: Returns the key_compare object used by the treap_multiset. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: If key_compare copy-constructor throws. - key_compare key_comp() const - { return tree_.value_comp(); } - - //! <b>Effects</b>: Returns the value_compare object used by the treap_multiset. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: If value_compare copy-constructor throws. - value_compare value_comp() const - { return tree_.value_comp(); } - - //! <b>Effects</b>: Returns the priority_compare object used by the treap_multiset. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: If priority_compare copy-constructor throws. - priority_compare priority_comp() const - { return tree_.priority_comp(); } - - //! <b>Effects</b>: Returns true if the container is empty. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - bool empty() const - { return tree_.empty(); } - - //! <b>Effects</b>: Returns the number of elements stored in the treap_multiset. - //! - //! <b>Complexity</b>: Linear to elements contained in *this if, - //! constant-time size option is enabled. Constant-time otherwise. - //! - //! <b>Throws</b>: Nothing. - size_type size() const - { return tree_.size(); } - - //! <b>Effects</b>: Swaps the contents of two treap_multisets. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: If the swap() call for the comparison functor - //! found using ADL throws. Strong guarantee. - void swap(treap_multiset_impl& other) - { tree_.swap(other.tree_); } - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! Cloner should yield to nodes equivalent to the original nodes. - //! - //! <b>Effects</b>: Erases all the elements from *this - //! calling Disposer::operator()(pointer), clones all the - //! elements from src calling Cloner::operator()(const_reference ) - //! and inserts them on *this. Copies the predicate from the source container. - //! - //! If cloner throws, all cloned elements are unlinked and disposed - //! calling Disposer::operator()(pointer). - //! - //! <b>Complexity</b>: Linear to erased plus inserted elements. - //! - //! <b>Throws</b>: If cloner throws or predicate copy assignment throws. Basic guarantee. - template <class Cloner, class Disposer> - void clone_from(const treap_multiset_impl &src, Cloner cloner, Disposer disposer) - { tree_.clone_from(src.tree_, cloner, disposer); } - - //! <b>Requires</b>: value must be an lvalue - //! - //! <b>Effects</b>: Inserts value into the treap_multiset. - //! - //! <b>Returns</b>: An iterator that points to the position where the new - //! element was inserted. - //! - //! <b>Complexity</b>: Average complexity for insert element is at - //! most logarithmic. - //! - //! <b>Throws</b>: If the internal value_compare or priority_compare ordering - //! function throws. Strong guarantee. - //! - //! <b>Note</b>: Does not affect the validity of iterators and references. - //! No copy-constructors are called. - iterator insert(reference value) - { return tree_.insert_equal(value); } - - //! <b>Requires</b>: value must be an lvalue - //! - //! <b>Effects</b>: Inserts x into the treap_multiset, using pos as a hint to - //! where it will be inserted. - //! - //! <b>Returns</b>: An iterator that points to the position where the new - //! element was inserted. - //! - //! <b>Complexity</b>: Logarithmic in general, but it is amortized - //! constant time if t is inserted immediately before hint. - //! - //! <b>Throws</b>: If internal value_compare or priority_compare ordering functions throw. - //! Strong guarantee. - //! - //! <b>Note</b>: Does not affect the validity of iterators and references. - //! No copy-constructors are called. - iterator insert(const_iterator hint, reference value) - { return tree_.insert_equal(hint, value); } - - //! <b>Requires</b>: Dereferencing iterator must yield an lvalue - //! of type value_type. - //! - //! <b>Effects</b>: Inserts a range into the treap_multiset. - //! - //! <b>Returns</b>: An iterator that points to the position where the new - //! element was inserted. - //! - //! <b>Complexity</b>: Insert range is in general O(N * log(N)), where N is the - //! size of the range. However, it is linear in N if the range is already sorted - //! by value_comp(). - //! - //! <b>Throws</b>: If internal value_compare or priority_compare ordering functions throw. - //! Basic guarantee. - //! - //! <b>Note</b>: Does not affect the validity of iterators and references. - //! No copy-constructors are called. - template<class Iterator> - void insert(Iterator b, Iterator e) - { tree_.insert_equal(b, e); } - - //! <b>Requires</b>: value must be an lvalue, "pos" must be - //! a valid iterator (or end) and must be the succesor of value - //! once inserted according to the predicate - //! - //! <b>Effects</b>: Inserts x into the treap before "pos". - //! - //! <b>Complexity</b>: Constant time. - //! - //! <b>Throws</b>: If the internal priority_compare function throws. Strong guarantee. - //! - //! <b>Note</b>: This function does not check preconditions so if "pos" is not - //! the successor of "value" treap ordering invariant will be broken. - //! This is a low-level function to be used only for performance reasons - //! by advanced users. - iterator insert_before(const_iterator pos, reference value) - { return tree_.insert_before(pos, value); } - - //! <b>Requires</b>: value must be an lvalue, and it must be no less - //! than the greatest inserted key. - //! - //! <b>Effects</b>: Inserts x into the treap in the last position. - //! - //! <b>Complexity</b>: Constant time. - //! - //! <b>Throws</b>: If the internal priority_compare function throws. Strong guarantee. - //! - //! <b>Note</b>: This function does not check preconditions so if value is - //! less than the greatest inserted key treap ordering invariant will be broken. - //! This function is slightly more efficient than using "insert_before". - //! This is a low-level function to be used only for performance reasons - //! by advanced users. - void push_back(reference value) - { tree_.push_back(value); } - - //! <b>Requires</b>: value must be an lvalue, and it must be no greater - //! than the minimum inserted key - //! - //! <b>Effects</b>: Inserts x into the treap in the first position. - //! - //! <b>Complexity</b>: Constant time. - //! - //! <b>Throws</b>: If the internal priority_compare function throws. Strong guarantee. - //! - //! <b>Note</b>: This function does not check preconditions so if value is - //! greater than the minimum inserted key treap ordering invariant will be broken. - //! This function is slightly more efficient than using "insert_before". - //! This is a low-level function to be used only for performance reasons - //! by advanced users. - void push_front(reference value) - { tree_.push_front(value); } - - //! <b>Effects</b>: Erases the element pointed to by pos. - //! - //! <b>Complexity</b>: Average complexity is constant time. - //! - //! <b>Returns</b>: An iterator to the element after the erased element. - //! - //! <b>Throws</b>: If the internal priority_compare function throws. Strong guarantee. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - iterator erase(const_iterator i) - { return tree_.erase(i); } - - //! <b>Effects</b>: Erases the range pointed to by b end e. - //! - //! <b>Returns</b>: An iterator to the element after the erased elements. - //! - //! <b>Complexity</b>: Average complexity for erase range is at most - //! O(log(size() + N)), where N is the number of elements in the range. - //! - //! <b>Throws</b>: If the internal priority_compare function throws. Basic guarantee. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - iterator erase(const_iterator b, const_iterator e) - { return tree_.erase(b, e); } - - //! <b>Effects</b>: Erases all the elements with the given value. - //! - //! <b>Returns</b>: The number of erased elements. - //! - //! <b>Complexity</b>: O(log(size() + this->count(value)). - //! - //! <b>Throws</b>: If the internal value_compare or priority_compare ordering - //! functiona throw. Basic guarantee. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - size_type erase(const_reference value) - { return tree_.erase(value); } - - //! <b>Effects</b>: Erases all the elements that compare equal with - //! the given key and the given comparison functor. - //! - //! <b>Returns</b>: The number of erased elements. - //! - //! <b>Complexity</b>: O(log(size() + this->count(key, comp)). - //! - //! <b>Throws</b>: If comp or internal priority_compare ordering functions throw. Basic guarantee. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - template<class KeyType, class KeyValueCompare> - size_type erase(const KeyType& key, KeyValueCompare comp - /// @cond - , typename detail::enable_if_c<!detail::is_convertible<KeyValueCompare, const_iterator>::value >::type * = 0 - /// @endcond - ) - { return tree_.erase(key, comp); } - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! - //! <b>Returns</b>: An iterator to the element after the erased element. - //! - //! <b>Effects</b>: Erases the element pointed to by pos. - //! Disposer::operator()(pointer) is called for the removed element. - //! - //! <b>Complexity</b>: Average complexity for erase element is constant time. - //! - //! <b>Throws</b>: If the internal priority_compare function throws. Strong guarantee. - //! - //! <b>Note</b>: Invalidates the iterators - //! to the erased elements. - template<class Disposer> - iterator erase_and_dispose(const_iterator i, Disposer disposer) - { return tree_.erase_and_dispose(i, disposer); } - - #if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) - template<class Disposer> - iterator erase_and_dispose(iterator i, Disposer disposer) - { return this->erase_and_dispose(const_iterator(i), disposer); } - #endif - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! - //! <b>Returns</b>: An iterator to the element after the erased elements. - //! - //! <b>Effects</b>: Erases the range pointed to by b end e. - //! Disposer::operator()(pointer) is called for the removed elements. - //! - //! <b>Complexity</b>: Average complexity for erase range is at most - //! O(log(size() + N)), where N is the number of elements in the range. - //! - //! <b>Throws</b>: If the internal priority_compare function throws. Basic guarantee. - //! - //! <b>Note</b>: Invalidates the iterators - //! to the erased elements. - template<class Disposer> - iterator erase_and_dispose(const_iterator b, const_iterator e, Disposer disposer) - { return tree_.erase_and_dispose(b, e, disposer); } - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! - //! <b>Effects</b>: Erases all the elements with the given value. - //! Disposer::operator()(pointer) is called for the removed elements. - //! - //! <b>Returns</b>: The number of erased elements. - //! - //! <b>Complexity</b>: O(log(size() + this->count(value)). - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. Basic guarantee. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - template<class Disposer> - size_type erase_and_dispose(const_reference value, Disposer disposer) - { return tree_.erase_and_dispose(value, disposer); } - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! - //! <b>Effects</b>: Erases all the elements with the given key. - //! according to the comparison functor "comp". - //! Disposer::operator()(pointer) is called for the removed elements. - //! - //! <b>Returns</b>: The number of erased elements. - //! - //! <b>Complexity</b>: O(log(size() + this->count(key, comp)). - //! - //! <b>Throws</b>: If comp or internal priority_compare ordering functions throw. Basic guarantee. - //! - //! <b>Note</b>: Invalidates the iterators - //! to the erased elements. - template<class KeyType, class KeyValueCompare, class Disposer> - size_type erase_and_dispose(const KeyType& key, KeyValueCompare comp, Disposer disposer - /// @cond - , typename detail::enable_if_c<!detail::is_convertible<KeyValueCompare, const_iterator>::value >::type * = 0 - /// @endcond - ) - { return tree_.erase_and_dispose(key, comp, disposer); } - - //! <b>Effects</b>: Erases all the elements of the container. - //! - //! <b>Complexity</b>: Linear to the number of elements on the container. - //! if it's a safe-mode or auto-unlink value_type. Constant time otherwise. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - void clear() - { return tree_.clear(); } - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! - //! <b>Effects</b>: Erases all the elements of the container. - //! - //! <b>Complexity</b>: Linear to the number of elements on the container. - //! Disposer::operator()(pointer) is called for the removed elements. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - template<class Disposer> - void clear_and_dispose(Disposer disposer) - { return tree_.clear_and_dispose(disposer); } - - //! <b>Effects</b>: Returns the number of contained elements with the given key - //! - //! <b>Complexity</b>: Logarithmic to the number of elements contained plus lineal - //! to number of objects with the given key. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. - size_type count(const_reference value) const - { return tree_.count(value); } - - //! <b>Effects</b>: Returns the number of contained elements with the same key - //! compared with the given comparison functor. - //! - //! <b>Complexity</b>: Logarithmic to the number of elements contained plus lineal - //! to number of objects with the given key. - //! - //! <b>Throws</b>: If comp ordering function throws. - template<class KeyType, class KeyValueCompare> - size_type count(const KeyType& key, KeyValueCompare comp) const - { return tree_.count(key, comp); } - - //! <b>Effects</b>: Returns an iterator to the first element whose - //! key is not less than k or end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. - iterator lower_bound(const_reference value) - { return tree_.lower_bound(value); } - - //! <b>Requires</b>: comp must imply the same element order as - //! value_compare. Usually key is the part of the value_type - //! that is used in the ordering functor. - //! - //! <b>Effects</b>: Returns an iterator to the first element whose - //! key according to the comparison functor is not less than k or - //! end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If comp ordering function throws. - //! - //! <b>Note</b>: This function is used when constructing a value_type - //! is expensive and the value_type can be compared with a cheaper - //! key type. Usually this key is part of the value_type. - template<class KeyType, class KeyValueCompare> - iterator lower_bound(const KeyType& key, KeyValueCompare comp) - { return tree_.lower_bound(key, comp); } - - //! <b>Effects</b>: Returns a const iterator to the first element whose - //! key is not less than k or end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. - const_iterator lower_bound(const_reference value) const - { return tree_.lower_bound(value); } - - //! <b>Requires</b>: comp must imply the same element order as - //! value_compare. Usually key is the part of the value_type - //! that is used in the ordering functor. - //! - //! <b>Effects</b>: Returns a const_iterator to the first element whose - //! key according to the comparison functor is not less than k or - //! end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If comp ordering function throws. - //! - //! <b>Note</b>: This function is used when constructing a value_type - //! is expensive and the value_type can be compared with a cheaper - //! key type. Usually this key is part of the value_type. - template<class KeyType, class KeyValueCompare> - const_iterator lower_bound(const KeyType& key, KeyValueCompare comp) const - { return tree_.lower_bound(key, comp); } - - //! <b>Effects</b>: Returns an iterator to the first element whose - //! key is greater than k or end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. - iterator upper_bound(const_reference value) - { return tree_.upper_bound(value); } - - //! <b>Requires</b>: comp must imply the same element order as - //! value_compare. Usually key is the part of the value_type - //! that is used in the ordering functor. - //! - //! <b>Effects</b>: Returns an iterator to the first element whose - //! key according to the comparison functor is greater than key or - //! end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If comp ordering function throws. - //! - //! <b>Note</b>: This function is used when constructing a value_type - //! is expensive and the value_type can be compared with a cheaper - //! key type. Usually this key is part of the value_type. - template<class KeyType, class KeyValueCompare> - iterator upper_bound(const KeyType& key, KeyValueCompare comp) - { return tree_.upper_bound(key, comp); } - - //! <b>Effects</b>: Returns an iterator to the first element whose - //! key is greater than k or end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. - const_iterator upper_bound(const_reference value) const - { return tree_.upper_bound(value); } - - //! <b>Requires</b>: comp must imply the same element order as - //! value_compare. Usually key is the part of the value_type - //! that is used in the ordering functor. - //! - //! <b>Effects</b>: Returns a const_iterator to the first element whose - //! key according to the comparison functor is greater than key or - //! end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If comp ordering function throws. - //! - //! <b>Note</b>: This function is used when constructing a value_type - //! is expensive and the value_type can be compared with a cheaper - //! key type. Usually this key is part of the value_type. - template<class KeyType, class KeyValueCompare> - const_iterator upper_bound(const KeyType& key, KeyValueCompare comp) const - { return tree_.upper_bound(key, comp); } - - //! <b>Effects</b>: Finds an iterator to the first element whose value is - //! "value" or end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. - iterator find(const_reference value) - { return tree_.find(value); } - - //! <b>Requires</b>: comp must imply the same element order as - //! value_compare. Usually key is the part of the value_type - //! that is used in the ordering functor. - //! - //! <b>Effects</b>: Finds an iterator to the first element whose key is - //! "key" according to the comparison functor or end() if that element - //! does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If comp ordering function throws. - //! - //! <b>Note</b>: This function is used when constructing a value_type - //! is expensive and the value_type can be compared with a cheaper - //! key type. Usually this key is part of the value_type. - template<class KeyType, class KeyValueCompare> - iterator find(const KeyType& key, KeyValueCompare comp) - { return tree_.find(key, comp); } - - //! <b>Effects</b>: Finds a const_iterator to the first element whose value is - //! "value" or end() if that element does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. - const_iterator find(const_reference value) const - { return tree_.find(value); } - - //! <b>Requires</b>: comp must imply the same element order as - //! value_compare. Usually key is the part of the value_type - //! that is used in the ordering functor. - //! - //! <b>Effects</b>: Finds a const_iterator to the first element whose key is - //! "key" according to the comparison functor or end() if that element - //! does not exist. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If comp ordering function throws. - //! - //! <b>Note</b>: This function is used when constructing a value_type - //! is expensive and the value_type can be compared with a cheaper - //! key type. Usually this key is part of the value_type. - template<class KeyType, class KeyValueCompare> - const_iterator find(const KeyType& key, KeyValueCompare comp) const - { return tree_.find(key, comp); } - - //! <b>Effects</b>: Finds a range containing all elements whose key is k or - //! an empty range that indicates the position where those elements would be - //! if they there is no elements with key k. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. - std::pair<iterator,iterator> equal_range(const_reference value) - { return tree_.equal_range(value); } - - //! <b>Requires</b>: comp must imply the same element order as - //! value_compare. Usually key is the part of the value_type - //! that is used in the ordering functor. - //! - //! <b>Effects</b>: Finds a range containing all elements whose key is k - //! according to the comparison functor or an empty range - //! that indicates the position where those elements would be - //! if they there is no elements with key k. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If comp ordering function throws. - //! - //! <b>Note</b>: This function is used when constructing a value_type - //! is expensive and the value_type can be compared with a cheaper - //! key type. Usually this key is part of the value_type. - template<class KeyType, class KeyValueCompare> - std::pair<iterator,iterator> equal_range(const KeyType& key, KeyValueCompare comp) - { return tree_.equal_range(key, comp); } - - //! <b>Effects</b>: Finds a range containing all elements whose key is k or - //! an empty range that indicates the position where those elements would be - //! if they there is no elements with key k. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If the internal value_compare ordering function throws. - std::pair<const_iterator, const_iterator> - equal_range(const_reference value) const - { return tree_.equal_range(value); } - - //! <b>Requires</b>: comp must imply the same element order as - //! value_compare. Usually key is the part of the value_type - //! that is used in the ordering functor. - //! - //! <b>Effects</b>: Finds a range containing all elements whose key is k - //! according to the comparison functor or an empty range - //! that indicates the position where those elements would be - //! if they there is no elements with key k. - //! - //! <b>Complexity</b>: Logarithmic. - //! - //! <b>Throws</b>: If comp ordering function throws. - //! - //! <b>Note</b>: This function is used when constructing a value_type - //! is expensive and the value_type can be compared with a cheaper - //! key type. Usually this key is part of the value_type. - template<class KeyType, class KeyValueCompare> - std::pair<const_iterator, const_iterator> - equal_range(const KeyType& key, KeyValueCompare comp) const - { return tree_.equal_range(key, comp); } - - //! <b>Requires</b>: value must be an lvalue and shall be in a treap_multiset of - //! appropriate type. Otherwise the behavior is undefined. - //! - //! <b>Effects</b>: Returns: a valid iterator i belonging to the treap_multiset - //! that points to the value - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: This static function is available only if the <i>value traits</i> - //! is stateless. - static iterator s_iterator_to(reference value) - { return tree_type::s_iterator_to(value); } - - //! <b>Requires</b>: value must be an lvalue and shall be in a treap_multiset of - //! appropriate type. Otherwise the behavior is undefined. - //! - //! <b>Effects</b>: Returns: a valid const_iterator i belonging to the - //! treap_multiset that points to the value - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: This static function is available only if the <i>value traits</i> - //! is stateless. - static const_iterator s_iterator_to(const_reference value) - { return tree_type::s_iterator_to(value); } - - //! <b>Requires</b>: value must be an lvalue and shall be in a treap_multiset of - //! appropriate type. Otherwise the behavior is undefined. - //! - //! <b>Effects</b>: Returns: a valid iterator i belonging to the treap_multiset - //! that points to the value - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - iterator iterator_to(reference value) - { return tree_.iterator_to(value); } - - //! <b>Requires</b>: value must be an lvalue and shall be in a treap_multiset of - //! appropriate type. Otherwise the behavior is undefined. - //! - //! <b>Effects</b>: Returns: a valid const_iterator i belonging to the - //! treap_multiset that points to the value - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_iterator iterator_to(const_reference value) const - { return tree_.iterator_to(value); } - - //! <b>Requires</b>: value shall not be in a treap_multiset/treap_multiset. - //! - //! <b>Effects</b>: init_node puts the hook of a value in a well-known default - //! state. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant time. - //! - //! <b>Note</b>: This function puts the hook in the well-known default state - //! used by auto_unlink and safe hooks. - static void init_node(reference value) - { tree_type::init_node(value); } - - //! <b>Effects</b>: Unlinks the leftmost node from the tree. - //! - //! <b>Complexity</b>: Average complexity is constant time. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Notes</b>: This function breaks the tree and the tree can - //! only be used for more unlink_leftmost_without_rebalance calls. - //! This function is normally used to achieve a step by step - //! controlled destruction of the tree. - pointer unlink_leftmost_without_rebalance() - { return tree_.unlink_leftmost_without_rebalance(); } - - //! <b>Requires</b>: replace_this must be a valid iterator of *this - //! and with_this must not be inserted in any tree. - //! - //! <b>Effects</b>: Replaces replace_this in its position in the - //! tree with with_this. The tree does not need to be rebalanced. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: This function will break container ordering invariants if - //! with_this is not equivalent to *replace_this according to the - //! ordering rules. This function is faster than erasing and inserting - //! the node, since no rebalancing or comparison is needed. - void replace_node(iterator replace_this, reference with_this) - { tree_.replace_node(replace_this, with_this); } - - //! <b>Effects</b>: Rebalances the tree. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Linear. - void rebalance() - { tree_.rebalance(); } - - //! <b>Requires</b>: old_root is a node of a tree. - //! - //! <b>Effects</b>: Rebalances the subtree rooted at old_root. - //! - //! <b>Returns</b>: The new root of the subtree. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Linear to the elements in the subtree. - iterator rebalance_subtree(iterator root) - { return tree_.rebalance_subtree(root); } - - //! <b>Returns</b>: The balance factor (alpha) used in this tree - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - float balance_factor() const - { return tree_.balance_factor(); } - - //! <b>Requires</b>: new_alpha must be a value between 0.5 and 1.0 - //! - //! <b>Effects</b>: Establishes a new balance factor (alpha) and rebalances - //! the tree if the new balance factor is stricter (less) than the old factor. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Linear to the elements in the subtree. - void balance_factor(float new_alpha) - { tree_.balance_factor(new_alpha); } - - /// @cond - friend bool operator==(const treap_multiset_impl &x, const treap_multiset_impl &y) - { return x.tree_ == y.tree_; } - - friend bool operator<(const treap_multiset_impl &x, const treap_multiset_impl &y) - { return x.tree_ < y.tree_; } - /// @endcond -}; - -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -inline bool operator!= -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -(const treap_multiset_impl<T, Options...> &x, const treap_multiset_impl<T, Options...> &y) -#else -(const treap_multiset_impl<Config> &x, const treap_multiset_impl<Config> &y) -#endif -{ return !(x == y); } - -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -inline bool operator> -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -(const treap_multiset_impl<T, Options...> &x, const treap_multiset_impl<T, Options...> &y) -#else -(const treap_multiset_impl<Config> &x, const treap_multiset_impl<Config> &y) -#endif -{ return y < x; } - -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -inline bool operator<= -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -(const treap_multiset_impl<T, Options...> &x, const treap_multiset_impl<T, Options...> &y) -#else -(const treap_multiset_impl<Config> &x, const treap_multiset_impl<Config> &y) -#endif -{ return !(y < x); } - -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -inline bool operator>= -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -(const treap_multiset_impl<T, Options...> &x, const treap_multiset_impl<T, Options...> &y) -#else -(const treap_multiset_impl<Config> &x, const treap_multiset_impl<Config> &y) -#endif -{ return !(x < y); } - -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -inline void swap -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -(treap_multiset_impl<T, Options...> &x, treap_multiset_impl<T, Options...> &y) -#else -(treap_multiset_impl<Config> &x, treap_multiset_impl<Config> &y) -#endif -{ x.swap(y); } - -//! Helper metafunction to define a \c treap_multiset that yields to the same type when the -//! same options (either explicitly or implicitly) are used. -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) || defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template<class T, class ...Options> -#else -template<class T, class O1 = none, class O2 = none - , class O3 = none, class O4 = none> -#endif -struct make_treap_multiset -{ - /// @cond - typedef treap_multiset_impl - < typename make_treap_opt<T, - #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) - O1, O2, O3, O4 - #else - Options... - #endif - >::type - > implementation_defined; - /// @endcond - typedef implementation_defined type; -}; - -#ifndef BOOST_INTRUSIVE_DOXYGEN_INVOKED - -#if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template<class T, class O1, class O2, class O3, class O4> -#else -template<class T, class ...Options> -#endif -class treap_multiset - : public make_treap_multiset<T, - #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) - O1, O2, O3, O4 - #else - Options... - #endif - >::type -{ - typedef typename make_treap_multiset - <T, - #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) - O1, O2, O3, O4 - #else - Options... - #endif - >::type Base; - //Movable - BOOST_MOVABLE_BUT_NOT_COPYABLE(treap_multiset) - - public: - typedef typename Base::value_compare value_compare; - typedef typename Base::priority_compare priority_compare; - typedef typename Base::value_traits value_traits; - typedef typename Base::iterator iterator; - typedef typename Base::const_iterator const_iterator; - - //Assert if passed value traits are compatible with the type - BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value)); - - treap_multiset( const value_compare &cmp = value_compare() - , const priority_compare &pcmp = priority_compare() - , const value_traits &v_traits = value_traits()) - : Base(cmp, pcmp, v_traits) - {} - - template<class Iterator> - treap_multiset( Iterator b, Iterator e - , const value_compare &cmp = value_compare() - , const priority_compare &pcmp = priority_compare() - , const value_traits &v_traits = value_traits()) - : Base(b, e, cmp, pcmp, v_traits) - {} - - treap_multiset(BOOST_RV_REF(treap_multiset) x) - : Base(::boost::move(static_cast<Base&>(x))) - {} - - treap_multiset& operator=(BOOST_RV_REF(treap_multiset) x) - { this->Base::operator=(::boost::move(static_cast<Base&>(x))); return *this; } - - static treap_multiset &container_from_end_iterator(iterator end_iterator) - { return static_cast<treap_multiset &>(Base::container_from_end_iterator(end_iterator)); } - - static const treap_multiset &container_from_end_iterator(const_iterator end_iterator) - { return static_cast<const treap_multiset &>(Base::container_from_end_iterator(end_iterator)); } - - static treap_multiset &container_from_iterator(iterator it) - { return static_cast<treap_multiset &>(Base::container_from_iterator(it)); } - - static const treap_multiset &container_from_iterator(const_iterator it) - { return static_cast<const treap_multiset &>(Base::container_from_iterator(it)); } -}; - -#endif - -} //namespace intrusive -} //namespace boost - -#include <boost/intrusive/detail/config_end.hpp> - -#endif //BOOST_INTRUSIVE_TRIE_SET_HPP diff --git a/src/third_party/boost/boost/intrusive/trivial_value_traits.hpp b/src/third_party/boost/boost/intrusive/trivial_value_traits.hpp deleted file mode 100644 index c924022608f..00000000000 --- a/src/third_party/boost/boost/intrusive/trivial_value_traits.hpp +++ /dev/null @@ -1,46 +0,0 @@ -///////////////////////////////////////////////////////////////////////////// -// -// (C) Copyright Ion Gaztanaga 2006-2009 -// -// Distributed under the Boost Software License, Version 1.0. -// (See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) -// -// See http://www.boost.org/libs/intrusive for documentation. -// -///////////////////////////////////////////////////////////////////////////// - -#ifndef BOOST_INTRUSIVE_TRIVIAL_VALUE_TRAITS_HPP -#define BOOST_INTRUSIVE_TRIVIAL_VALUE_TRAITS_HPP - -#include <boost/intrusive/link_mode.hpp> -#include <boost/intrusive/pointer_traits.hpp> - -namespace boost { -namespace intrusive { - -//!This value traits template is used to create value traits -//!from user defined node traits where value_traits::value_type and -//!node_traits::node should be equal -template<class NodeTraits, link_mode_type LinkMode = normal_link> -struct trivial_value_traits -{ - typedef NodeTraits node_traits; - typedef typename node_traits::node_ptr node_ptr; - typedef typename node_traits::const_node_ptr const_node_ptr; - typedef typename node_traits::node value_type; - typedef node_ptr pointer; - typedef const_node_ptr const_pointer; - static const link_mode_type link_mode = LinkMode; - static node_ptr to_node_ptr (value_type &value) - { return pointer_traits<node_ptr>::pointer_to(value); } - static const_node_ptr to_node_ptr (const value_type &value) - { return pointer_traits<const_node_ptr>::pointer_to(value); } - static const pointer & to_value_ptr(const node_ptr &n) { return n; } - static const const_pointer &to_value_ptr(const const_node_ptr &n) { return n; } -}; - -} //namespace intrusive -} //namespace boost - -#endif //BOOST_INTRUSIVE_TRIVIAL_VALUE_TRAITS_HPP diff --git a/src/third_party/boost/boost/intrusive/unordered_set.hpp b/src/third_party/boost/boost/intrusive/unordered_set.hpp deleted file mode 100644 index 6407fcfa451..00000000000 --- a/src/third_party/boost/boost/intrusive/unordered_set.hpp +++ /dev/null @@ -1,2115 +0,0 @@ -///////////////////////////////////////////////////////////////////////////// -// -// (C) Copyright Olaf Krzikalla 2004-2006. -// (C) Copyright Ion Gaztanaga 2006-2009 -// -// Distributed under the Boost Software License, Version 1.0. -// (See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) -// -// See http://www.boost.org/libs/intrusive for documentation. -// -///////////////////////////////////////////////////////////////////////////// -#ifndef BOOST_INTRUSIVE_UNORDERED_SET_HPP -#define BOOST_INTRUSIVE_UNORDERED_SET_HPP - -#include <boost/intrusive/detail/config_begin.hpp> -#include <boost/intrusive/intrusive_fwd.hpp> -#include <boost/intrusive/hashtable.hpp> -#include <boost/move/move.hpp> -#include <iterator> - - -namespace boost { -namespace intrusive { - -//! The class template unordered_set is an intrusive container, that mimics most of -//! the interface of std::tr1::unordered_set as described in the C++ TR1. -//! -//! unordered_set is a semi-intrusive container: each object to be stored in the -//! container must contain a proper hook, but the container also needs -//! additional auxiliary memory to work: unordered_set needs a pointer to an array -//! of type `bucket_type` to be passed in the constructor. This bucket array must -//! have at least the same lifetime as the container. This makes the use of -//! unordered_set more complicated than purely intrusive containers. -//! `bucket_type` is default-constructible, copyable and assignable -//! -//! The template parameter \c T is the type to be managed by the container. -//! The user can specify additional options and if no options are provided -//! default options are used. -//! -//! The container supports the following options: -//! \c base_hook<>/member_hook<>/value_traits<>, -//! \c constant_time_size<>, \c size_type<>, \c hash<> and \c equal<> -//! \c bucket_traits<>, \c power_2_buckets<> and \c cache_begin<>. -//! -//! unordered_set only provides forward iterators but it provides 4 iterator types: -//! iterator and const_iterator to navigate through the whole container and -//! local_iterator and const_local_iterator to navigate through the values -//! stored in a single bucket. Local iterators are faster and smaller. -//! -//! It's not recommended to use non constant-time size unordered_sets because several -//! key functions, like "empty()", become non-constant time functions. Non -//! constant-time size unordered_sets are mainly provided to support auto-unlink hooks. -//! -//! unordered_set, unlike std::unordered_set, does not make automatic rehashings nor -//! offers functions related to a load factor. Rehashing can be explicitly requested -//! and the user must provide a new bucket array that will be used from that moment. -//! -//! Since no automatic rehashing is done, iterators are never invalidated when -//! inserting or erasing elements. Iterators are only invalidated when rehasing. -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -class unordered_set_impl -{ - /// @cond - private: - typedef hashtable_impl<Config> table_type; - - //! This class is - //! movable - BOOST_MOVABLE_BUT_NOT_COPYABLE(unordered_set_impl) - - typedef table_type implementation_defined; - /// @endcond - - public: - typedef typename implementation_defined::value_type value_type; - typedef typename implementation_defined::value_traits value_traits; - typedef typename implementation_defined::bucket_traits bucket_traits; - typedef typename implementation_defined::pointer pointer; - typedef typename implementation_defined::const_pointer const_pointer; - typedef typename implementation_defined::reference reference; - typedef typename implementation_defined::const_reference const_reference; - typedef typename implementation_defined::difference_type difference_type; - typedef typename implementation_defined::size_type size_type; - typedef typename implementation_defined::key_type key_type; - typedef typename implementation_defined::key_equal key_equal; - typedef typename implementation_defined::hasher hasher; - typedef typename implementation_defined::bucket_type bucket_type; - typedef typename implementation_defined::bucket_ptr bucket_ptr; - typedef typename implementation_defined::iterator iterator; - typedef typename implementation_defined::const_iterator const_iterator; - typedef typename implementation_defined::insert_commit_data insert_commit_data; - typedef typename implementation_defined::local_iterator local_iterator; - typedef typename implementation_defined::const_local_iterator const_local_iterator; - typedef typename implementation_defined::node_traits node_traits; - typedef typename implementation_defined::node node; - typedef typename implementation_defined::node_ptr node_ptr; - typedef typename implementation_defined::const_node_ptr const_node_ptr; - typedef typename implementation_defined::node_algorithms node_algorithms; - - /// @cond - private: - table_type table_; - /// @endcond - - public: - - //! <b>Requires</b>: buckets must not be being used by any other resource. - //! - //! <b>Effects</b>: Constructs an empty unordered_set_impl, storing a reference - //! to the bucket array and copies of the hasher and equal functors. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: If value_traits::node_traits::node - //! constructor throws (this does not happen with predefined Boost.Intrusive hooks) - //! or the copy constructor or invocation of Hash or Equal throws. - //! - //! <b>Notes</b>: buckets array must be disposed only after - //! *this is disposed. - unordered_set_impl( const bucket_traits &b_traits - , const hasher & hash_func = hasher() - , const key_equal &equal_func = key_equal() - , const value_traits &v_traits = value_traits()) - : table_(b_traits, hash_func, equal_func, v_traits) - {} - - //! <b>Requires</b>: buckets must not be being used by any other resource - //! and Dereferencing iterator must yield an lvalue of type value_type. - //! - //! <b>Effects</b>: Constructs an empty unordered_set and inserts elements from - //! [b, e). - //! - //! <b>Complexity</b>: If N is std::distance(b, e): Average case is O(N) - //! (with a good hash function and with buckets_len >= N),worst case O(N2). - //! - //! <b>Throws</b>: If value_traits::node_traits::node - //! constructor throws (this does not happen with predefined Boost.Intrusive hooks) - //! or the copy constructor or invocation of hasher or key_equal throws. - //! - //! <b>Notes</b>: buckets array must be disposed only after - //! *this is disposed. - template<class Iterator> - unordered_set_impl( Iterator b - , Iterator e - , const bucket_traits &b_traits - , const hasher & hash_func = hasher() - , const key_equal &equal_func = key_equal() - , const value_traits &v_traits = value_traits()) - : table_(b_traits, hash_func, equal_func, v_traits) - { table_.insert_unique(b, e); } - - //! <b>Effects</b>: to-do - //! - unordered_set_impl(BOOST_RV_REF(unordered_set_impl) x) - : table_(::boost::move(x.table_)) - {} - - //! <b>Effects</b>: to-do - //! - unordered_set_impl& operator=(BOOST_RV_REF(unordered_set_impl) x) - { table_ = ::boost::move(x.table_); return *this; } - - //! <b>Effects</b>: Detaches all elements from this. The objects in the unordered_set - //! are not deleted (i.e. no destructors are called). - //! - //! <b>Complexity</b>: Linear to the number of elements in the unordered_set, if - //! it's a safe-mode or auto-unlink value. Otherwise constant. - //! - //! <b>Throws</b>: Nothing. - ~unordered_set_impl() - {} - - //! <b>Effects</b>: Returns an iterator pointing to the beginning of the unordered_set. - //! - //! <b>Complexity</b>: Constant time if `cache_begin<>` is true. Amortized - //! constant time with worst case (empty unordered_set) O(this->bucket_count()) - //! - //! <b>Throws</b>: Nothing. - iterator begin() - { return table_.begin(); } - - //! <b>Effects</b>: Returns a const_iterator pointing to the beginning - //! of the unordered_set. - //! - //! <b>Complexity</b>: Constant time if `cache_begin<>` is true. Amortized - //! constant time with worst case (empty unordered_set) O(this->bucket_count()) - //! - //! <b>Throws</b>: Nothing. - const_iterator begin() const - { return table_.begin(); } - - //! <b>Effects</b>: Returns a const_iterator pointing to the beginning - //! of the unordered_set. - //! - //! <b>Complexity</b>: Constant time if `cache_begin<>` is true. Amortized - //! constant time with worst case (empty unordered_set) O(this->bucket_count()) - //! - //! <b>Throws</b>: Nothing. - const_iterator cbegin() const - { return table_.cbegin(); } - - //! <b>Effects</b>: Returns an iterator pointing to the end of the unordered_set. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - iterator end() - { return table_.end(); } - - //! <b>Effects</b>: Returns a const_iterator pointing to the end of the unordered_set. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_iterator end() const - { return table_.end(); } - - //! <b>Effects</b>: Returns a const_iterator pointing to the end of the unordered_set. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_iterator cend() const - { return table_.cend(); } - - //! <b>Effects</b>: Returns the hasher object used by the unordered_set. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: If hasher copy-constructor throws. - hasher hash_function() const - { return table_.hash_function(); } - - //! <b>Effects</b>: Returns the key_equal object used by the unordered_set. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: If key_equal copy-constructor throws. - key_equal key_eq() const - { return table_.key_eq(); } - - //! <b>Effects</b>: Returns true if the container is empty. - //! - //! <b>Complexity</b>: if constant-time size and cache_last options are disabled, - //! average constant time (worst case, with empty() == true: O(this->bucket_count()). - //! Otherwise constant. - //! - //! <b>Throws</b>: Nothing. - bool empty() const - { return table_.empty(); } - - //! <b>Effects</b>: Returns the number of elements stored in the unordered_set. - //! - //! <b>Complexity</b>: Linear to elements contained in *this if - //! constant-time size option is disabled. Constant-time otherwise. - //! - //! <b>Throws</b>: Nothing. - size_type size() const - { return table_.size(); } - - //! <b>Requires</b>: the hasher and the equality function unqualified swap - //! call should not throw. - //! - //! <b>Effects</b>: Swaps the contents of two unordered_sets. - //! Swaps also the contained bucket array and equality and hasher functors. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: If the swap() call for the comparison or hash functors - //! found using ADL throw. Basic guarantee. - void swap(unordered_set_impl& other) - { table_.swap(other.table_); } - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! Cloner should yield to nodes that compare equal and produce the same - //! hash than the original node. - //! - //! <b>Effects</b>: Erases all the elements from *this - //! calling Disposer::operator()(pointer), clones all the - //! elements from src calling Cloner::operator()(const_reference ) - //! and inserts them on *this. The hash function and the equality - //! predicate are copied from the source. - //! - //! If store_hash option is true, this method does not use the hash function. - //! - //! If any operation throws, all cloned elements are unlinked and disposed - //! calling Disposer::operator()(pointer). - //! - //! <b>Complexity</b>: Linear to erased plus inserted elements. - //! - //! <b>Throws</b>: If cloner or hasher throw or hash or equality predicate copying - //! throws. Basic guarantee. - template <class Cloner, class Disposer> - void clone_from(const unordered_set_impl &src, Cloner cloner, Disposer disposer) - { table_.clone_from(src.table_, cloner, disposer); } - - //! <b>Requires</b>: value must be an lvalue - //! - //! <b>Effects</b>: Tries to inserts value into the unordered_set. - //! - //! <b>Returns</b>: If the value - //! is not already present inserts it and returns a pair containing the - //! iterator to the new value and true. If there is an equivalent value - //! returns a pair containing an iterator to the already present value - //! and false. - //! - //! <b>Complexity</b>: Average case O(1), worst case O(this->size()). - //! - //! <b>Throws</b>: If the internal hasher or the equality functor throws. Strong guarantee. - //! - //! <b>Note</b>: Does not affect the validity of iterators and references. - //! No copy-constructors are called. - std::pair<iterator, bool> insert(reference value) - { return table_.insert_unique(value); } - - //! <b>Requires</b>: Dereferencing iterator must yield an lvalue - //! of type value_type. - //! - //! <b>Effects</b>: Equivalent to this->insert(t) for each element in [b, e). - //! - //! <b>Complexity</b>: Average case O(N), where N is std::distance(b, e). - //! Worst case O(N*this->size()). - //! - //! <b>Throws</b>: If the internal hasher or the equality functor throws. Basic guarantee. - //! - //! <b>Note</b>: Does not affect the validity of iterators and references. - //! No copy-constructors are called. - template<class Iterator> - void insert(Iterator b, Iterator e) - { table_.insert_unique(b, e); } - - //! <b>Requires</b>: "hasher" must be a hash function that induces - //! the same hash values as the stored hasher. The difference is that - //! "hasher" hashes the given key instead of the value_type. - //! - //! "key_value_equal" must be a equality function that induces - //! the same equality as key_equal. The difference is that - //! "key_value_equal" compares an arbitrary key with the contained values. - //! - //! <b>Effects</b>: Checks if a value can be inserted in the unordered_set, using - //! a user provided key instead of the value itself. - //! - //! <b>Returns</b>: If there is an equivalent value - //! returns a pair containing an iterator to the already present value - //! and false. If the value can be inserted returns true in the returned - //! pair boolean and fills "commit_data" that is meant to be used with - //! the "insert_commit" function. - //! - //! <b>Complexity</b>: Average case O(1), worst case O(this->size()). - //! - //! <b>Throws</b>: If hasher or key_value_equal throw. Strong guarantee. - //! - //! <b>Notes</b>: This function is used to improve performance when constructing - //! a value_type is expensive: if there is an equivalent value - //! the constructed object must be discarded. Many times, the part of the - //! node that is used to impose the hash or the equality is much cheaper to - //! construct than the value_type and this function offers the possibility to - //! use that the part to check if the insertion will be successful. - //! - //! If the check is successful, the user can construct the value_type and use - //! "insert_commit" to insert the object in constant-time. - //! - //! "commit_data" remains valid for a subsequent "insert_commit" only if no more - //! objects are inserted or erased from the unordered_set. - //! - //! After a successful rehashing insert_commit_data remains valid. - template<class KeyType, class KeyHasher, class KeyValueEqual> - std::pair<iterator, bool> insert_check - (const KeyType &key, KeyHasher hasher, KeyValueEqual key_value_equal, insert_commit_data &commit_data) - { return table_.insert_unique_check(key, hasher, key_value_equal, commit_data); } - - //! <b>Requires</b>: value must be an lvalue of type value_type. commit_data - //! must have been obtained from a previous call to "insert_check". - //! No objects should have been inserted or erased from the unordered_set between - //! the "insert_check" that filled "commit_data" and the call to "insert_commit". - //! - //! <b>Effects</b>: Inserts the value in the unordered_set using the information obtained - //! from the "commit_data" that a previous "insert_check" filled. - //! - //! <b>Returns</b>: An iterator to the newly inserted object. - //! - //! <b>Complexity</b>: Constant time. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Notes</b>: This function has only sense if a "insert_check" has been - //! previously executed to fill "commit_data". No value should be inserted or - //! erased between the "insert_check" and "insert_commit" calls. - //! - //! After a successful rehashing insert_commit_data remains valid. - iterator insert_commit(reference value, const insert_commit_data &commit_data) - { return table_.insert_unique_commit(value, commit_data); } - - //! <b>Effects</b>: Erases the element pointed to by i. - //! - //! <b>Complexity</b>: Average case O(1), worst case O(this->size()). - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased element. No destructors are called. - void erase(const_iterator i) - { table_.erase(i); } - - //! <b>Effects</b>: Erases the range pointed to by b end e. - //! - //! <b>Complexity</b>: Average case O(std::distance(b, e)), - //! worst case O(this->size()). - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - void erase(const_iterator b, const_iterator e) - { table_.erase(b, e); } - - //! <b>Effects</b>: Erases all the elements with the given value. - //! - //! <b>Returns</b>: The number of erased elements. - //! - //! <b>Complexity</b>: Average case O(this->count(value)). - //! Worst case O(this->size()). - //! - //! <b>Throws</b>: If the internal hasher or the equality functor throws. Basic guarantee. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - size_type erase(const_reference value) - { return table_.erase(value); } - - //! <b>Requires</b>: "hasher" must be a hash function that induces - //! the same hash values as the stored hasher. The difference is that - //! "hasher" hashes the given key instead of the value_type. - //! - //! "key_value_equal" must be a equality function that induces - //! the same equality as key_equal. The difference is that - //! "key_value_equal" compares an arbitrary key with the contained values. - //! - //! <b>Effects</b>: Erases all the elements that have the same hash and - //! compare equal with the given key. - //! - //! <b>Returns</b>: The number of erased elements. - //! - //! <b>Complexity</b>: Average case O(this->count(value)). - //! Worst case O(this->size()). - //! - //! <b>Throws</b>: If hash_func or equal_func throw. Basic guarantee. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - template<class KeyType, class KeyHasher, class KeyValueEqual> - size_type erase(const KeyType& key, KeyHasher hash_func, KeyValueEqual equal_func) - { return table_.erase(key, hash_func, equal_func); } - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! - //! <b>Effects</b>: Erases the element pointed to by i. - //! Disposer::operator()(pointer) is called for the removed element. - //! - //! <b>Complexity</b>: Average case O(1), worst case O(this->size()). - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators - //! to the erased elements. - template<class Disposer> - void erase_and_dispose(const_iterator i, Disposer disposer - /// @cond - , typename detail::enable_if_c<!detail::is_convertible<Disposer, const_iterator>::value >::type * = 0 - /// @endcond - ) - { table_.erase_and_dispose(i, disposer); } - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! - //! <b>Effects</b>: Erases the range pointed to by b end e. - //! Disposer::operator()(pointer) is called for the removed elements. - //! - //! <b>Complexity</b>: Average case O(std::distance(b, e)), - //! worst case O(this->size()). - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators - //! to the erased elements. - template<class Disposer> - void erase_and_dispose(const_iterator b, const_iterator e, Disposer disposer) - { table_.erase_and_dispose(b, e, disposer); } - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! - //! <b>Effects</b>: Erases all the elements with the given value. - //! Disposer::operator()(pointer) is called for the removed elements. - //! - //! <b>Returns</b>: The number of erased elements. - //! - //! <b>Complexity</b>: Average case O(this->count(value)). - //! Worst case O(this->size()). - //! - //! <b>Throws</b>: If the internal hasher or the equality functor throws. Basic guarantee. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - template<class Disposer> - size_type erase_and_dispose(const_reference value, Disposer disposer) - { return table_.erase_and_dispose(value, disposer); } - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! - //! <b>Effects</b>: Erases all the elements with the given key. - //! according to the comparison functor "equal_func". - //! Disposer::operator()(pointer) is called for the removed elements. - //! - //! <b>Returns</b>: The number of erased elements. - //! - //! <b>Complexity</b>: Average case O(this->count(value)). - //! Worst case O(this->size()). - //! - //! <b>Throws</b>: If hash_func or equal_func throw. Basic guarantee. - //! - //! <b>Note</b>: Invalidates the iterators - //! to the erased elements. - template<class KeyType, class KeyHasher, class KeyValueEqual, class Disposer> - size_type erase_and_dispose(const KeyType& key, KeyHasher hash_func, KeyValueEqual equal_func, Disposer disposer) - { return table_.erase_and_dispose(key, hash_func, equal_func, disposer); } - - //! <b>Effects</b>: Erases all of the elements. - //! - //! <b>Complexity</b>: Linear to the number of elements on the container. - //! if it's a safe-mode or auto-unlink value_type. Constant time otherwise. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - void clear() - { return table_.clear(); } - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! - //! <b>Effects</b>: Erases all of the elements. - //! - //! <b>Complexity</b>: Linear to the number of elements on the container. - //! Disposer::operator()(pointer) is called for the removed elements. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - template<class Disposer> - void clear_and_dispose(Disposer disposer) - { return table_.clear_and_dispose(disposer); } - - //! <b>Effects</b>: Returns the number of contained elements with the given value - //! - //! <b>Complexity</b>: Average case O(1), worst case O(this->size()). - //! - //! <b>Throws</b>: If the internal hasher or the equality functor throws. - size_type count(const_reference value) const - { return table_.find(value) != end(); } - - //! <b>Requires</b>: "hash_func" must be a hash function that induces - //! the same hash values as the stored hasher. The difference is that - //! "hash_func" hashes the given key instead of the value_type. - //! - //! "equal_func" must be a equality function that induces - //! the same equality as key_equal. The difference is that - //! "equal_func" compares an arbitrary key with the contained values. - //! - //! <b>Effects</b>: Returns the number of contained elements with the given key - //! - //! <b>Complexity</b>: Average case O(1), worst case O(this->size()). - //! - //! <b>Throws</b>: If hash_func or equal_func throw. - template<class KeyType, class KeyHasher, class KeyValueEqual> - size_type count(const KeyType& key, KeyHasher hash_func, KeyValueEqual equal_func) const - { return table_.find(key, hash_func, equal_func) != end(); } - - //! <b>Effects</b>: Finds an iterator to the first element is equal to - //! "value" or end() if that element does not exist. - //! - //! <b>Complexity</b>: Average case O(1), worst case O(this->size()). - //! - //! <b>Throws</b>: If the internal hasher or the equality functor throws. - iterator find(const_reference value) - { return table_.find(value); } - - //! <b>Requires</b>: "hash_func" must be a hash function that induces - //! the same hash values as the stored hasher. The difference is that - //! "hash_func" hashes the given key instead of the value_type. - //! - //! "equal_func" must be a equality function that induces - //! the same equality as key_equal. The difference is that - //! "equal_func" compares an arbitrary key with the contained values. - //! - //! <b>Effects</b>: Finds an iterator to the first element whose key is - //! "key" according to the given hasher and equality functor or end() if - //! that element does not exist. - //! - //! <b>Complexity</b>: Average case O(1), worst case O(this->size()). - //! - //! <b>Throws</b>: If hash_func or equal_func throw. - //! - //! <b>Note</b>: This function is used when constructing a value_type - //! is expensive and the value_type can be compared with a cheaper - //! key type. Usually this key is part of the value_type. - template<class KeyType, class KeyHasher, class KeyValueEqual> - iterator find(const KeyType& key, KeyHasher hash_func, KeyValueEqual equal_func) - { return table_.find(key, hash_func, equal_func); } - - //! <b>Effects</b>: Finds a const_iterator to the first element whose key is - //! "key" or end() if that element does not exist. - //! - //! <b>Complexity</b>: Average case O(1), worst case O(this->size()). - //! - //! <b>Throws</b>: If the internal hasher or the equality functor throws. - const_iterator find(const_reference value) const - { return table_.find(value); } - - //! <b>Requires</b>: "hash_func" must be a hash function that induces - //! the same hash values as the stored hasher. The difference is that - //! "hash_func" hashes the given key instead of the value_type. - //! - //! "equal_func" must be a equality function that induces - //! the same equality as key_equal. The difference is that - //! "equal_func" compares an arbitrary key with the contained values. - //! - //! <b>Effects</b>: Finds an iterator to the first element whose key is - //! "key" according to the given hasher and equality functor or end() if - //! that element does not exist. - //! - //! <b>Complexity</b>: Average case O(1), worst case O(this->size()). - //! - //! <b>Throws</b>: If hash_func or equal_func throw. - //! - //! <b>Note</b>: This function is used when constructing a value_type - //! is expensive and the value_type can be compared with a cheaper - //! key type. Usually this key is part of the value_type. - template<class KeyType, class KeyHasher, class KeyValueEqual> - const_iterator find(const KeyType& key, KeyHasher hash_func, KeyValueEqual equal_func) const - { return table_.find(key, hash_func, equal_func); } - - //! <b>Effects</b>: Returns a range containing all elements with values equivalent - //! to value. Returns std::make_pair(this->end(), this->end()) if no such - //! elements exist. - //! - //! <b>Complexity</b>: Average case O(this->count(value)). Worst case O(this->size()). - //! - //! <b>Throws</b>: If the internal hasher or the equality functor throws. - std::pair<iterator,iterator> equal_range(const_reference value) - { return table_.equal_range(value); } - - //! <b>Requires</b>: "hash_func" must be a hash function that induces - //! the same hash values as the stored hasher. The difference is that - //! "hash_func" hashes the given key instead of the value_type. - //! - //! "equal_func" must be a equality function that induces - //! the same equality as key_equal. The difference is that - //! "equal_func" compares an arbitrary key with the contained values. - //! - //! <b>Effects</b>: Returns a range containing all elements with equivalent - //! keys. Returns std::make_pair(this->end(), this->end()) if no such - //! elements exist. - //! - //! <b>Complexity</b>: Average case O(this->count(key, hash_func, hash_func)). - //! Worst case O(this->size()). - //! - //! <b>Throws</b>: If hash_func or the equal_func throw. - //! - //! <b>Note</b>: This function is used when constructing a value_type - //! is expensive and the value_type can be compared with a cheaper - //! key type. Usually this key is part of the value_type. - template<class KeyType, class KeyHasher, class KeyValueEqual> - std::pair<iterator,iterator> equal_range(const KeyType& key, KeyHasher hash_func, KeyValueEqual equal_func) - { return table_.equal_range(key, hash_func, equal_func); } - - //! <b>Effects</b>: Returns a range containing all elements with values equivalent - //! to value. Returns std::make_pair(this->end(), this->end()) if no such - //! elements exist. - //! - //! <b>Complexity</b>: Average case O(this->count(value)). Worst case O(this->size()). - //! - //! <b>Throws</b>: If the internal hasher or the equality functor throws. - std::pair<const_iterator, const_iterator> - equal_range(const_reference value) const - { return table_.equal_range(value); } - - //! <b>Requires</b>: "hash_func" must be a hash function that induces - //! the same hash values as the stored hasher. The difference is that - //! "hash_func" hashes the given key instead of the value_type. - //! - //! "equal_func" must be a equality function that induces - //! the same equality as key_equal. The difference is that - //! "equal_func" compares an arbitrary key with the contained values. - //! - //! <b>Effects</b>: Returns a range containing all elements with equivalent - //! keys. Returns std::make_pair(this->end(), this->end()) if no such - //! elements exist. - //! - //! <b>Complexity</b>: Average case O(this->count(key, hash_func, equal_func)). - //! Worst case O(this->size()). - //! - //! <b>Throws</b>: If the hash_func or equal_func throw. - //! - //! <b>Note</b>: This function is used when constructing a value_type - //! is expensive and the value_type can be compared with a cheaper - //! key type. Usually this key is part of the value_type. - template<class KeyType, class KeyHasher, class KeyValueEqual> - std::pair<const_iterator, const_iterator> - equal_range(const KeyType& key, KeyHasher hash_func, KeyValueEqual equal_func) const - { return table_.equal_range(key, hash_func, equal_func); } - - //! <b>Requires</b>: value must be an lvalue and shall be in a unordered_set of - //! appropriate type. Otherwise the behavior is undefined. - //! - //! <b>Effects</b>: Returns: a valid iterator belonging to the unordered_set - //! that points to the value - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: If the internal hash function throws. - iterator iterator_to(reference value) - { return table_.iterator_to(value); } - - //! <b>Requires</b>: value must be an lvalue and shall be in a unordered_set of - //! appropriate type. Otherwise the behavior is undefined. - //! - //! <b>Effects</b>: Returns: a valid const_iterator belonging to the - //! unordered_set that points to the value - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: If the internal hash function throws. - const_iterator iterator_to(const_reference value) const - { return table_.iterator_to(value); } - - //! <b>Requires</b>: value must be an lvalue and shall be in a unordered_set of - //! appropriate type. Otherwise the behavior is undefined. - //! - //! <b>Effects</b>: Returns: a valid local_iterator belonging to the unordered_set - //! that points to the value - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: This static function is available only if the <i>value traits</i> - //! is stateless. - static local_iterator s_local_iterator_to(reference value) - { return table_type::s_local_iterator_to(value); } - - //! <b>Requires</b>: value must be an lvalue and shall be in a unordered_set of - //! appropriate type. Otherwise the behavior is undefined. - //! - //! <b>Effects</b>: Returns: a valid const_local_iterator belonging to - //! the unordered_set that points to the value - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: This static function is available only if the <i>value traits</i> - //! is stateless. - static const_local_iterator s_local_iterator_to(const_reference value) - { return table_type::s_local_iterator_to(value); } - - //! <b>Requires</b>: value must be an lvalue and shall be in a unordered_set of - //! appropriate type. Otherwise the behavior is undefined. - //! - //! <b>Effects</b>: Returns: a valid local_iterator belonging to the unordered_set - //! that points to the value - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - local_iterator local_iterator_to(reference value) - { return table_.local_iterator_to(value); } - - //! <b>Requires</b>: value must be an lvalue and shall be in a unordered_set of - //! appropriate type. Otherwise the behavior is undefined. - //! - //! <b>Effects</b>: Returns: a valid const_local_iterator belonging to - //! the unordered_set that points to the value - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_local_iterator local_iterator_to(const_reference value) const - { return table_.local_iterator_to(value); } - - //! <b>Effects</b>: Returns the number of buckets passed in the constructor - //! or the last rehash function. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - size_type bucket_count() const - { return table_.bucket_count(); } - - //! <b>Requires</b>: n is in the range [0, this->bucket_count()). - //! - //! <b>Effects</b>: Returns the number of elements in the nth bucket. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - size_type bucket_size(size_type n) const - { return table_.bucket_size(n); } - - //! <b>Effects</b>: Returns the index of the bucket in which elements - //! with keys equivalent to k would be found, if any such element existed. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: If the hash functor throws. - //! - //! <b>Note</b>: the return value is in the range [0, this->bucket_count()). - size_type bucket(const value_type& k) const - { return table_.bucket(k); } - - //! <b>Requires</b>: "hash_func" must be a hash function that induces - //! the same hash values as the stored hasher. The difference is that - //! "hash_func" hashes the given key instead of the value_type. - //! - //! <b>Effects</b>: Returns the index of the bucket in which elements - //! with keys equivalent to k would be found, if any such element existed. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: If hash_func throws. - //! - //! <b>Note</b>: the return value is in the range [0, this->bucket_count()). - template<class KeyType, class KeyHasher> - size_type bucket(const KeyType& k, KeyHasher hash_func) const - { return table_.bucket(k, hash_func); } - - //! <b>Effects</b>: Returns the bucket array pointer passed in the constructor - //! or the last rehash function. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - bucket_ptr bucket_pointer() const - { return table_.bucket_pointer(); } - - //! <b>Requires</b>: n is in the range [0, this->bucket_count()). - //! - //! <b>Effects</b>: Returns a local_iterator pointing to the beginning - //! of the sequence stored in the bucket n. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: [this->begin(n), this->end(n)) is a valid range - //! containing all of the elements in the nth bucket. - local_iterator begin(size_type n) - { return table_.begin(n); } - - //! <b>Requires</b>: n is in the range [0, this->bucket_count()). - //! - //! <b>Effects</b>: Returns a const_local_iterator pointing to the beginning - //! of the sequence stored in the bucket n. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: [this->begin(n), this->end(n)) is a valid range - //! containing all of the elements in the nth bucket. - const_local_iterator begin(size_type n) const - { return table_.begin(n); } - - //! <b>Requires</b>: n is in the range [0, this->bucket_count()). - //! - //! <b>Effects</b>: Returns a const_local_iterator pointing to the beginning - //! of the sequence stored in the bucket n. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: [this->begin(n), this->end(n)) is a valid range - //! containing all of the elements in the nth bucket. - const_local_iterator cbegin(size_type n) const - { return table_.cbegin(n); } - - //! <b>Requires</b>: n is in the range [0, this->bucket_count()). - //! - //! <b>Effects</b>: Returns a local_iterator pointing to the end - //! of the sequence stored in the bucket n. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: [this->begin(n), this->end(n)) is a valid range - //! containing all of the elements in the nth bucket. - local_iterator end(size_type n) - { return table_.end(n); } - - //! <b>Requires</b>: n is in the range [0, this->bucket_count()). - //! - //! <b>Effects</b>: Returns a const_local_iterator pointing to the end - //! of the sequence stored in the bucket n. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: [this->begin(n), this->end(n)) is a valid range - //! containing all of the elements in the nth bucket. - const_local_iterator end(size_type n) const - { return table_.end(n); } - - //! <b>Requires</b>: n is in the range [0, this->bucket_count()). - //! - //! <b>Effects</b>: Returns a const_local_iterator pointing to the end - //! of the sequence stored in the bucket n. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: [this->begin(n), this->end(n)) is a valid range - //! containing all of the elements in the nth bucket. - const_local_iterator cend(size_type n) const - { return table_.cend(n); } - - //! <b>Requires</b>: new_buckets must be a pointer to a new bucket array - //! or the same as the old bucket array. new_size is the length of the - //! the array pointed by new_buckets. If new_buckets == this->bucket_pointer() - //! n can be bigger or smaller than this->bucket_count(). - //! - //! <b>Effects</b>: Updates the internal reference with the new bucket erases - //! the values from the old bucket and inserts then in the new one. - //! - //! If store_hash option is true, this method does not use the hash function. - //! - //! <b>Complexity</b>: Average case linear in this->size(), worst case quadratic. - //! - //! <b>Throws</b>: If the hasher functor throws. Basic guarantee. - void rehash(const bucket_traits &new_bucket_traits) - { table_.rehash(new_bucket_traits); } - - //! <b>Requires</b>: - //! - //! <b>Effects</b>: - //! - //! <b>Complexity</b>: - //! - //! <b>Throws</b>: - //! - //! <b>Note</b>: this method is only available if incremental<true> option is activated. - bool incremental_rehash(bool grow = true) - { return table_.incremental_rehash(grow); } - - //! <b>Note</b>: this method is only available if incremental<true> option is activated. - bool incremental_rehash(const bucket_traits &new_bucket_traits) - { return table_.incremental_rehash(new_bucket_traits); } - - //! <b>Requires</b>: - //! - //! <b>Effects</b>: - //! - //! <b>Complexity</b>: - //! - //! <b>Throws</b>: - size_type split_count() const - { return table_.split_count(); } - - //! <b>Effects</b>: Returns the nearest new bucket count optimized for - //! the container that is bigger than n. This suggestion can be used - //! to create bucket arrays with a size that will usually improve - //! container's performance. If such value does not exist, the - //! higher possible value is returned. - //! - //! <b>Complexity</b>: Amortized constant time. - //! - //! <b>Throws</b>: Nothing. - static size_type suggested_upper_bucket_count(size_type n) - { return table_type::suggested_upper_bucket_count(n); } - - //! <b>Effects</b>: Returns the nearest new bucket count optimized for - //! the container that is smaller than n. This suggestion can be used - //! to create bucket arrays with a size that will usually improve - //! container's performance. If such value does not exist, the - //! lower possible value is returned. - //! - //! <b>Complexity</b>: Amortized constant time. - //! - //! <b>Throws</b>: Nothing. - static size_type suggested_lower_bucket_count(size_type n) - { return table_type::suggested_lower_bucket_count(n); } -}; - -//! Helper metafunction to define an \c unordered_set that yields to the same type when the -//! same options (either explicitly or implicitly) are used. -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) || defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template<class T, class ...Options> -#else -template<class T, class O1 = none, class O2 = none - , class O3 = none, class O4 = none - , class O5 = none, class O6 = none - , class O7 = none, class O8 = none - , class O9 = none, class O10= none - > -#endif -struct make_unordered_set -{ - /// @cond - typedef unordered_set_impl - < typename make_hashtable_opt - <T, true, - #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) - O1, O2, O3, O4, O5, O6, O7, O8, O9, O10 - #else - Options... - #endif - >::type - > implementation_defined; - /// @endcond - typedef implementation_defined type; -}; - -#ifndef BOOST_INTRUSIVE_DOXYGEN_INVOKED - -#if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template<class T, class O1, class O2, class O3, class O4, class O5, class O6, class O7, class O8, class O9, class O10> -#else -template<class T, class ...Options> -#endif -class unordered_set - : public make_unordered_set<T, - #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) - O1, O2, O3, O4, O5, O6, O7, O8, O9, O10 - #else - Options... - #endif - >::type -{ - typedef typename make_unordered_set - <T, - #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) - O1, O2, O3, O4, O5, O6, O7, O8, O9, O10 - #else - Options... - #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_MOVABLE_BUT_NOT_COPYABLE(unordered_set) - - public: - typedef typename Base::value_traits value_traits; - typedef typename Base::bucket_traits bucket_traits; - typedef typename Base::iterator iterator; - typedef typename Base::const_iterator const_iterator; - typedef typename Base::bucket_ptr bucket_ptr; - typedef typename Base::size_type size_type; - typedef typename Base::hasher hasher; - typedef typename Base::key_equal key_equal; - - unordered_set ( const bucket_traits &b_traits - , const hasher & hash_func = hasher() - , const key_equal &equal_func = key_equal() - , const value_traits &v_traits = value_traits()) - : Base(b_traits, hash_func, equal_func, v_traits) - {} - - template<class Iterator> - unordered_set ( Iterator b - , Iterator e - , const bucket_traits &b_traits - , const hasher & hash_func = hasher() - , const key_equal &equal_func = key_equal() - , const value_traits &v_traits = value_traits()) - : Base(b, e, b_traits, hash_func, equal_func, v_traits) - {} - - unordered_set(BOOST_RV_REF(unordered_set) x) - : Base(::boost::move(static_cast<Base&>(x))) - {} - - unordered_set& operator=(BOOST_RV_REF(unordered_set) x) - { this->Base::operator=(::boost::move(static_cast<Base&>(x))); return *this; } -}; - -#endif - - -//! The class template unordered_multiset is an intrusive container, that mimics most of -//! the interface of std::tr1::unordered_multiset as described in the C++ TR1. -//! -//! unordered_multiset is a semi-intrusive container: each object to be stored in the -//! container must contain a proper hook, but the container also needs -//! additional auxiliary memory to work: unordered_multiset needs a pointer to an array -//! of type `bucket_type` to be passed in the constructor. This bucket array must -//! have at least the same lifetime as the container. This makes the use of -//! unordered_multiset more complicated than purely intrusive containers. -//! `bucket_type` is default-constructible, copyable and assignable -//! -//! The template parameter \c T is the type to be managed by the container. -//! The user can specify additional options and if no options are provided -//! default options are used. -//! -//! The container supports the following options: -//! \c base_hook<>/member_hook<>/value_traits<>, -//! \c constant_time_size<>, \c size_type<>, \c hash<> and \c equal<> -//! \c bucket_traits<>, \c power_2_buckets<> and \c cache_begin<>. -//! -//! unordered_multiset only provides forward iterators but it provides 4 iterator types: -//! iterator and const_iterator to navigate through the whole container and -//! local_iterator and const_local_iterator to navigate through the values -//! stored in a single bucket. Local iterators are faster and smaller. -//! -//! It's not recommended to use non constant-time size unordered_multisets because several -//! key functions, like "empty()", become non-constant time functions. Non -//! constant-time size unordered_multisets are mainly provided to support auto-unlink hooks. -//! -//! unordered_multiset, unlike std::unordered_set, does not make automatic rehashings nor -//! offers functions related to a load factor. Rehashing can be explicitly requested -//! and the user must provide a new bucket array that will be used from that moment. -//! -//! Since no automatic rehashing is done, iterators are never invalidated when -//! inserting or erasing elements. Iterators are only invalidated when rehasing. -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) -template<class T, class ...Options> -#else -template<class Config> -#endif -class unordered_multiset_impl -{ - /// @cond - private: - typedef hashtable_impl<Config> table_type; - /// @endcond - - //Movable - BOOST_MOVABLE_BUT_NOT_COPYABLE(unordered_multiset_impl) - - typedef table_type implementation_defined; - - public: - typedef typename implementation_defined::value_type value_type; - typedef typename implementation_defined::value_traits value_traits; - typedef typename implementation_defined::bucket_traits bucket_traits; - typedef typename implementation_defined::pointer pointer; - typedef typename implementation_defined::const_pointer const_pointer; - typedef typename implementation_defined::reference reference; - typedef typename implementation_defined::const_reference const_reference; - typedef typename implementation_defined::difference_type difference_type; - typedef typename implementation_defined::size_type size_type; - typedef typename implementation_defined::key_type key_type; - typedef typename implementation_defined::key_equal key_equal; - typedef typename implementation_defined::hasher hasher; - typedef typename implementation_defined::bucket_type bucket_type; - typedef typename implementation_defined::bucket_ptr bucket_ptr; - typedef typename implementation_defined::iterator iterator; - typedef typename implementation_defined::const_iterator const_iterator; - typedef typename implementation_defined::insert_commit_data insert_commit_data; - typedef typename implementation_defined::local_iterator local_iterator; - typedef typename implementation_defined::const_local_iterator const_local_iterator; - typedef typename implementation_defined::node_traits node_traits; - typedef typename implementation_defined::node node; - typedef typename implementation_defined::node_ptr node_ptr; - typedef typename implementation_defined::const_node_ptr const_node_ptr; - typedef typename implementation_defined::node_algorithms node_algorithms; - - /// @cond - private: - table_type table_; - /// @endcond - - public: - - //! <b>Requires</b>: buckets must not be being used by any other resource. - //! - //! <b>Effects</b>: Constructs an empty unordered_multiset, storing a reference - //! to the bucket array and copies of the hasher and equal functors. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: If value_traits::node_traits::node - //! constructor throws (this does not happen with predefined Boost.Intrusive hooks) - //! or the copy constructor or invocation of Hash or Equal throws. - //! - //! <b>Notes</b>: buckets array must be disposed only after - //! *this is disposed. - unordered_multiset_impl ( const bucket_traits &b_traits - , const hasher & hash_func = hasher() - , const key_equal &equal_func = key_equal() - , const value_traits &v_traits = value_traits()) - : table_(b_traits, hash_func, equal_func, v_traits) - {} - - //! <b>Requires</b>: buckets must not be being used by any other resource - //! and Dereferencing iterator must yield an lvalue of type value_type. - //! - //! <b>Effects</b>: Constructs an empty unordered_multiset and inserts elements from - //! [b, e). - //! - //! <b>Complexity</b>: If N is std::distance(b, e): Average case is O(N) - //! (with a good hash function and with buckets_len >= N),worst case O(N2). - //! - //! <b>Throws</b>: If value_traits::node_traits::node - //! constructor throws (this does not happen with predefined Boost.Intrusive hooks) - //! or the copy constructor or invocation of hasher or key_equal throws. - //! - //! <b>Notes</b>: buckets array must be disposed only after - //! *this is disposed. - template<class Iterator> - unordered_multiset_impl ( Iterator b - , Iterator e - , const bucket_traits &b_traits - , const hasher & hash_func = hasher() - , const key_equal &equal_func = key_equal() - , const value_traits &v_traits = value_traits()) - : table_(b_traits, hash_func, equal_func, v_traits) - { table_.insert_equal(b, e); } - - //! <b>Effects</b>: to-do - //! - unordered_multiset_impl(BOOST_RV_REF(unordered_multiset_impl) x) - : table_(::boost::move(x.table_)) - {} - - //! <b>Effects</b>: to-do - //! - unordered_multiset_impl& operator=(BOOST_RV_REF(unordered_multiset_impl) x) - { table_ = ::boost::move(x.table_); return *this; } - - //! <b>Effects</b>: Detaches all elements from this. The objects in the unordered_multiset - //! are not deleted (i.e. no destructors are called). - //! - //! <b>Complexity</b>: Linear to the number of elements in the unordered_multiset, if - //! it's a safe-mode or auto-unlink value. Otherwise constant. - //! - //! <b>Throws</b>: Nothing. - ~unordered_multiset_impl() - {} - - //! <b>Effects</b>: Returns an iterator pointing to the beginning of the unordered_multiset. - //! - //! <b>Complexity</b>: Constant time if `cache_begin<>` is true. Amortized - //! constant time with worst case (empty unordered_set) O(this->bucket_count()) - //! - //! <b>Throws</b>: Nothing. - iterator begin() - { return table_.begin(); } - - //! <b>Effects</b>: Returns a const_iterator pointing to the beginning - //! of the unordered_multiset. - //! - //! <b>Complexity</b>: Constant time if `cache_begin<>` is true. Amortized - //! constant time with worst case (empty unordered_set) O(this->bucket_count()) - //! - //! <b>Throws</b>: Nothing. - const_iterator begin() const - { return table_.begin(); } - - //! <b>Effects</b>: Returns a const_iterator pointing to the beginning - //! of the unordered_multiset. - //! - //! <b>Complexity</b>: Constant time if `cache_begin<>` is true. Amortized - //! constant time with worst case (empty unordered_set) O(this->bucket_count()) - //! - //! <b>Throws</b>: Nothing. - const_iterator cbegin() const - { return table_.cbegin(); } - - //! <b>Effects</b>: Returns an iterator pointing to the end of the unordered_multiset. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - iterator end() - { return table_.end(); } - - //! <b>Effects</b>: Returns a const_iterator pointing to the end of the unordered_multiset. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_iterator end() const - { return table_.end(); } - - //! <b>Effects</b>: Returns a const_iterator pointing to the end of the unordered_multiset. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_iterator cend() const - { return table_.cend(); } - - //! <b>Effects</b>: Returns the hasher object used by the unordered_set. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: If hasher copy-constructor throws. - hasher hash_function() const - { return table_.hash_function(); } - - //! <b>Effects</b>: Returns the key_equal object used by the unordered_multiset. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: If key_equal copy-constructor throws. - key_equal key_eq() const - { return table_.key_eq(); } - - //! <b>Effects</b>: Returns true if the container is empty. - //! - //! <b>Complexity</b>: if constant-time size and cache_last options are disabled, - //! average constant time (worst case, with empty() == true: O(this->bucket_count()). - //! Otherwise constant. - //! - //! <b>Throws</b>: Nothing. - bool empty() const - { return table_.empty(); } - - //! <b>Effects</b>: Returns the number of elements stored in the unordered_multiset. - //! - //! <b>Complexity</b>: Linear to elements contained in *this if - //! constant-time size option is disabled. Constant-time otherwise. - //! - //! <b>Throws</b>: Nothing. - size_type size() const - { return table_.size(); } - - //! <b>Requires</b>: the hasher and the equality function unqualified swap - //! call should not throw. - //! - //! <b>Effects</b>: Swaps the contents of two unordered_multisets. - //! Swaps also the contained bucket array and equality and hasher functors. - //! - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: If the swap() call for the comparison or hash functors - //! found using ADL throw. Basic guarantee. - void swap(unordered_multiset_impl& other) - { table_.swap(other.table_); } - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! Cloner should yield to nodes that compare equal and produce the same - //! hash than the original node. - //! - //! <b>Effects</b>: Erases all the elements from *this - //! calling Disposer::operator()(pointer), clones all the - //! elements from src calling Cloner::operator()(const_reference ) - //! and inserts them on *this. The hash function and the equality - //! predicate are copied from the source. - //! - //! If store_hash option is true, this method does not use the hash function. - //! - //! If any operation throws, all cloned elements are unlinked and disposed - //! calling Disposer::operator()(pointer). - //! - //! <b>Complexity</b>: Linear to erased plus inserted elements. - //! - //! <b>Throws</b>: If cloner or hasher throw or hash or equality predicate copying - //! throws. Basic guarantee. - template <class Cloner, class Disposer> - void clone_from(const unordered_multiset_impl &src, Cloner cloner, Disposer disposer) - { table_.clone_from(src.table_, cloner, disposer); } - - //! <b>Requires</b>: value must be an lvalue - //! - //! <b>Effects</b>: Inserts value into the unordered_multiset. - //! - //! <b>Returns</b>: An iterator to the new inserted value. - //! - //! <b>Complexity</b>: Average case O(1), worst case O(this->size()). - //! - //! <b>Throws</b>: If the internal hasher or the equality functor throws. Strong guarantee. - //! - //! <b>Note</b>: Does not affect the validity of iterators and references. - //! No copy-constructors are called. - iterator insert(reference value) - { return table_.insert_equal(value); } - - //! <b>Requires</b>: Dereferencing iterator must yield an lvalue - //! of type value_type. - //! - //! <b>Effects</b>: Equivalent to this->insert(t) for each element in [b, e). - //! - //! <b>Complexity</b>: Average case is O(N), where N is the - //! size of the range. - //! - //! <b>Throws</b>: If the internal hasher or the equality functor throws. Basic guarantee. - //! - //! <b>Note</b>: Does not affect the validity of iterators and references. - //! No copy-constructors are called. - template<class Iterator> - void insert(Iterator b, Iterator e) - { table_.insert_equal(b, e); } - - //! <b>Effects</b>: Erases the element pointed to by i. - //! - //! <b>Complexity</b>: Average case O(1), worst case O(this->size()). - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased element. No destructors are called. - void erase(const_iterator i) - { table_.erase(i); } - - //! <b>Effects</b>: Erases the range pointed to by b end e. - //! - //! <b>Complexity</b>: Average case O(std::distance(b, e)), - //! worst case O(this->size()). - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - void erase(const_iterator b, const_iterator e) - { table_.erase(b, e); } - - //! <b>Effects</b>: Erases all the elements with the given value. - //! - //! <b>Returns</b>: The number of erased elements. - //! - //! <b>Complexity</b>: Average case O(this->count(value)). - //! Worst case O(this->size()). - //! - //! <b>Throws</b>: If the internal hasher or the equality functor throws. Basic guarantee. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - size_type erase(const_reference value) - { return table_.erase(value); } - - //! <b>Requires</b>: "hash_func" must be a hash function that induces - //! the same hash values as the stored hasher. The difference is that - //! "hash_func" hashes the given key instead of the value_type. - //! - //! "key_value_equal" must be a equality function that induces - //! the same equality as key_equal. The difference is that - //! "key_value_equal" compares an arbitrary key with the contained values. - //! - //! <b>Effects</b>: Erases all the elements that have the same hash and - //! compare equal with the given key. - //! - //! <b>Returns</b>: The number of erased elements. - //! - //! <b>Complexity</b>: Average case O(this->count(value)). - //! Worst case O(this->size()). - //! - //! <b>Throws</b>: If the hash_func or the equal_func functors throws. - //! Basic guarantee. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - template<class KeyType, class KeyHasher, class KeyValueEqual> - size_type erase(const KeyType& key, KeyHasher hash_func, KeyValueEqual equal_func) - { return table_.erase(key, hash_func, equal_func); } - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! - //! <b>Effects</b>: Erases the element pointed to by i. - //! Disposer::operator()(pointer) is called for the removed element. - //! - //! <b>Complexity</b>: Average case O(1), worst case O(this->size()). - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators - //! to the erased elements. - template<class Disposer> - void erase_and_dispose(const_iterator i, Disposer disposer - /// @cond - , typename detail::enable_if_c<!detail::is_convertible<Disposer, const_iterator>::value >::type * = 0 - /// @endcond - ) - { table_.erase_and_dispose(i, disposer); } - - #if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) - template<class Disposer> - void erase_and_dispose(const_iterator i, Disposer disposer) - { this->erase_and_dispose(const_iterator(i), disposer); } - #endif - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! - //! <b>Effects</b>: Erases the range pointed to by b end e. - //! Disposer::operator()(pointer) is called for the removed elements. - //! - //! <b>Complexity</b>: Average case O(std::distance(b, e)), - //! worst case O(this->size()). - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators - //! to the erased elements. - template<class Disposer> - void erase_and_dispose(const_iterator b, const_iterator e, Disposer disposer) - { table_.erase_and_dispose(b, e, disposer); } - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! - //! <b>Effects</b>: Erases all the elements with the given value. - //! Disposer::operator()(pointer) is called for the removed elements. - //! - //! <b>Returns</b>: The number of erased elements. - //! - //! <b>Complexity</b>: Average case O(this->count(value)). - //! Worst case O(this->size()). - //! - //! <b>Throws</b>: If the internal hasher or the equality functor throws. Basic guarantee. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - template<class Disposer> - size_type erase_and_dispose(const_reference value, Disposer disposer) - { return table_.erase_and_dispose(value, disposer); } - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! - //! <b>Effects</b>: Erases all the elements with the given key. - //! according to the comparison functor "equal_func". - //! Disposer::operator()(pointer) is called for the removed elements. - //! - //! <b>Returns</b>: The number of erased elements. - //! - //! <b>Complexity</b>: Average case O(this->count(value)). - //! Worst case O(this->size()). - //! - //! <b>Throws</b>: If hash_func or equal_func throw. Basic guarantee. - //! - //! <b>Note</b>: Invalidates the iterators - //! to the erased elements. - template<class KeyType, class KeyHasher, class KeyValueEqual, class Disposer> - size_type erase_and_dispose(const KeyType& key, KeyHasher hash_func, KeyValueEqual equal_func, Disposer disposer) - { return table_.erase_and_dispose(key, hash_func, equal_func, disposer); } - - //! <b>Effects</b>: Erases all the elements of the container. - //! - //! <b>Complexity</b>: Linear to the number of elements on the container. - //! if it's a safe-mode or auto-unlink value_type. Constant time otherwise. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - void clear() - { return table_.clear(); } - - //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw. - //! - //! <b>Effects</b>: Erases all the elements of the container. - //! - //! <b>Complexity</b>: Linear to the number of elements on the container. - //! Disposer::operator()(pointer) is called for the removed elements. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: Invalidates the iterators (but not the references) - //! to the erased elements. No destructors are called. - template<class Disposer> - void clear_and_dispose(Disposer disposer) - { return table_.clear_and_dispose(disposer); } - - //! <b>Effects</b>: Returns the number of contained elements with the given key - //! - //! <b>Complexity</b>: Average case O(1), worst case O(this->size()). - //! - //! <b>Throws</b>: If the internal hasher or the equality functor throws. - size_type count(const_reference value) const - { return table_.count(value); } - - //! <b>Requires</b>: "hash_func" must be a hash function that induces - //! the same hash values as the stored hasher. The difference is that - //! "hash_func" hashes the given key instead of the value_type. - //! - //! "key_value_equal" must be a equality function that induces - //! the same equality as key_equal. The difference is that - //! "key_value_equal" compares an arbitrary key with the contained values. - //! - //! <b>Effects</b>: Returns the number of contained elements with the given key - //! - //! <b>Complexity</b>: Average case O(1), worst case O(this->size()). - //! - //! <b>Throws</b>: If the internal hasher or the equality functor throws. - template<class KeyType, class KeyHasher, class KeyValueEqual> - size_type count(const KeyType& key, KeyHasher hash_func, KeyValueEqual equal_func) const - { return table_.count(key, hash_func, equal_func); } - - //! <b>Effects</b>: Finds an iterator to the first element whose value is - //! "value" or end() if that element does not exist. - //! - //! <b>Complexity</b>: Average case O(1), worst case O(this->size()). - //! - //! <b>Throws</b>: If the internal hasher or the equality functor throws. - iterator find(const_reference value) - { return table_.find(value); } - - //! <b>Requires</b>: "hash_func" must be a hash function that induces - //! the same hash values as the stored hasher. The difference is that - //! "hash_func" hashes the given key instead of the value_type. - //! - //! "key_value_equal" must be a equality function that induces - //! the same equality as key_equal. The difference is that - //! "key_value_equal" compares an arbitrary key with the contained values. - //! - //! <b>Effects</b>: Finds an iterator to the first element whose key is - //! "key" according to the given hasher and equality functor or end() if - //! that element does not exist. - //! - //! <b>Complexity</b>: Average case O(1), worst case O(this->size()). - //! - //! <b>Throws</b>: If the internal hasher or the equality functor throws. - //! - //! <b>Note</b>: This function is used when constructing a value_type - //! is expensive and the value_type can be compared with a cheaper - //! key type. Usually this key is part of the value_type. - template<class KeyType, class KeyHasher, class KeyValueEqual> - iterator find(const KeyType& key, KeyHasher hash_func, KeyValueEqual equal_func) - { return table_.find(key, hash_func, equal_func); } - - //! <b>Effects</b>: Finds a const_iterator to the first element whose key is - //! "key" or end() if that element does not exist. - //! - //! <b>Complexity</b>: Average case O(1), worst case O(this->size()). - //! - //! <b>Throws</b>: If the internal hasher or the equality functor throws. - const_iterator find(const_reference value) const - { return table_.find(value); } - - //! <b>Requires</b>: "hash_func" must be a hash function that induces - //! the same hash values as the stored hasher. The difference is that - //! "hash_func" hashes the given key instead of the value_type. - //! - //! "key_value_equal" must be a equality function that induces - //! the same equality as key_equal. The difference is that - //! "key_value_equal" compares an arbitrary key with the contained values. - //! - //! <b>Effects</b>: Finds an iterator to the first element whose key is - //! "key" according to the given hasher and equality functor or end() if - //! that element does not exist. - //! - //! <b>Complexity</b>: Average case O(1), worst case O(this->size()). - //! - //! <b>Throws</b>: If the internal hasher or the equality functor throws. - //! - //! <b>Note</b>: This function is used when constructing a value_type - //! is expensive and the value_type can be compared with a cheaper - //! key type. Usually this key is part of the value_type. - template<class KeyType, class KeyHasher, class KeyValueEqual> - const_iterator find(const KeyType& key, KeyHasher hash_func, KeyValueEqual equal_func) const - { return table_.find(key, hash_func, equal_func); } - - //! <b>Effects</b>: Returns a range containing all elements with values equivalent - //! to value. Returns std::make_pair(this->end(), this->end()) if no such - //! elements exist. - //! - //! <b>Complexity</b>: Average case O(this->count(value)). Worst case O(this->size()). - //! - //! <b>Throws</b>: If the internal hasher or the equality functor throws. - std::pair<iterator,iterator> equal_range(const_reference value) - { return table_.equal_range(value); } - - //! <b>Requires</b>: "hash_func" must be a hash function that induces - //! the same hash values as the stored hasher. The difference is that - //! "hash_func" hashes the given key instead of the value_type. - //! - //! "key_value_equal" must be a equality function that induces - //! the same equality as key_equal. The difference is that - //! "key_value_equal" compares an arbitrary key with the contained values. - //! - //! <b>Effects</b>: Returns a range containing all elements with equivalent - //! keys. Returns std::make_pair(this->end(), this->end()) if no such - //! elements exist. - //! - //! <b>Complexity</b>: Average case O(this->count(key, hash_func, equal_func)). - //! Worst case O(this->size()). - //! - //! <b>Throws</b>: If the internal hasher or the equality functor throws. - //! - //! <b>Note</b>: This function is used when constructing a value_type - //! is expensive and the value_type can be compared with a cheaper - //! key type. Usually this key is part of the value_type. - template<class KeyType, class KeyHasher, class KeyValueEqual> - std::pair<iterator,iterator> equal_range - (const KeyType& key, KeyHasher hash_func, KeyValueEqual equal_func) - { return table_.equal_range(key, hash_func, equal_func); } - - //! <b>Effects</b>: Returns a range containing all elements with values equivalent - //! to value. Returns std::make_pair(this->end(), this->end()) if no such - //! elements exist. - //! - //! <b>Complexity</b>: Average case O(this->count(value)). Worst case O(this->size()). - //! - //! <b>Throws</b>: If the internal hasher or the equality functor throws. - std::pair<const_iterator, const_iterator> - equal_range(const_reference value) const - { return table_.equal_range(value); } - - //! <b>Requires</b>: "hash_func" must be a hash function that induces - //! the same hash values as the stored hasher. The difference is that - //! "hash_func" hashes the given key instead of the value_type. - //! - //! "key_value_equal" must be a equality function that induces - //! the same equality as key_equal. The difference is that - //! "key_value_equal" compares an arbitrary key with the contained values. - //! - //! <b>Effects</b>: Returns a range containing all elements with equivalent - //! keys. Returns std::make_pair(this->end(), this->end()) if no such - //! elements exist. - //! - //! <b>Complexity</b>: Average case O(this->count(key, hash_func, equal_func)). - //! Worst case O(this->size()). - //! - //! <b>Throws</b>: If the internal hasher or the equality functor throws. - //! - //! <b>Note</b>: This function is used when constructing a value_type - //! is expensive and the value_type can be compared with a cheaper - //! key type. Usually this key is part of the value_type. - template<class KeyType, class KeyHasher, class KeyValueEqual> - std::pair<const_iterator, const_iterator> - equal_range(const KeyType& key, KeyHasher hash_func, KeyValueEqual equal_func) const - { return table_.equal_range(key, hash_func, equal_func); } - - //! <b>Requires</b>: value must be an lvalue and shall be in a unordered_multiset of - //! appropriate type. Otherwise the behavior is undefined. - //! - //! <b>Effects</b>: Returns: a valid iterator belonging to the unordered_multiset - //! that points to the value - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: If the hash function throws. - iterator iterator_to(reference value) - { return table_.iterator_to(value); } - - //! <b>Requires</b>: value must be an lvalue and shall be in a unordered_multiset of - //! appropriate type. Otherwise the behavior is undefined. - //! - //! <b>Effects</b>: Returns: a valid const_iterator belonging to the - //! unordered_multiset that points to the value - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: If the hash function throws. - const_iterator iterator_to(const_reference value) const - { return table_.iterator_to(value); } - - //! <b>Requires</b>: value must be an lvalue and shall be in a unordered_set of - //! appropriate type. Otherwise the behavior is undefined. - //! - //! <b>Effects</b>: Returns: a valid local_iterator belonging to the unordered_set - //! that points to the value - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: This static function is available only if the <i>value traits</i> - //! is stateless. - static local_iterator s_local_iterator_to(reference value) - { return table_type::s_local_iterator_to(value); } - - //! <b>Requires</b>: value must be an lvalue and shall be in a unordered_set of - //! appropriate type. Otherwise the behavior is undefined. - //! - //! <b>Effects</b>: Returns: a valid const_local_iterator belonging to - //! the unordered_set that points to the value - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: This static function is available only if the <i>value traits</i> - //! is stateless. - static const_local_iterator s_local_iterator_to(const_reference value) - { return table_type::s_local_iterator_to(value); } - - //! <b>Requires</b>: value must be an lvalue and shall be in a unordered_set of - //! appropriate type. Otherwise the behavior is undefined. - //! - //! <b>Effects</b>: Returns: a valid local_iterator belonging to the unordered_set - //! that points to the value - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - local_iterator local_iterator_to(reference value) - { return table_.local_iterator_to(value); } - - //! <b>Requires</b>: value must be an lvalue and shall be in a unordered_set of - //! appropriate type. Otherwise the behavior is undefined. - //! - //! <b>Effects</b>: Returns: a valid const_local_iterator belonging to - //! the unordered_set that points to the value - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - const_local_iterator local_iterator_to(const_reference value) const - { return table_.local_iterator_to(value); } - - //! <b>Effects</b>: Returns the number of buckets passed in the constructor - //! or the last rehash function. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - size_type bucket_count() const - { return table_.bucket_count(); } - - //! <b>Requires</b>: n is in the range [0, this->bucket_count()). - //! - //! <b>Effects</b>: Returns the number of elements in the nth bucket. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - size_type bucket_size(size_type n) const - { return table_.bucket_size(n); } - - //! <b>Effects</b>: Returns the index of the bucket in which elements - //! with keys equivalent to k would be found, if any such element existed. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: If the hash functor throws. - //! - //! <b>Note</b>: the return value is in the range [0, this->bucket_count()). - size_type bucket(const value_type& k) const - { return table_.bucket(k); } - - //! <b>Requires</b>: "hash_func" must be a hash function that induces - //! the same hash values as the stored hasher. The difference is that - //! "hash_func" hashes the given key instead of the value_type. - //! - //! <b>Effects</b>: Returns the index of the bucket in which elements - //! with keys equivalent to k would be found, if any such element existed. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: If the hash functor throws. - //! - //! <b>Note</b>: the return value is in the range [0, this->bucket_count()). - template<class KeyType, class KeyHasher> - size_type bucket(const KeyType& k, const KeyHasher &hash_func) const - { return table_.bucket(k, hash_func); } - - //! <b>Effects</b>: Returns the bucket array pointer passed in the constructor - //! or the last rehash function. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - bucket_ptr bucket_pointer() const - { return table_.bucket_pointer(); } - - //! <b>Requires</b>: n is in the range [0, this->bucket_count()). - //! - //! <b>Effects</b>: Returns a local_iterator pointing to the beginning - //! of the sequence stored in the bucket n. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: [this->begin(n), this->end(n)) is a valid range - //! containing all of the elements in the nth bucket. - local_iterator begin(size_type n) - { return table_.begin(n); } - - //! <b>Requires</b>: n is in the range [0, this->bucket_count()). - //! - //! <b>Effects</b>: Returns a const_local_iterator pointing to the beginning - //! of the sequence stored in the bucket n. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: [this->begin(n), this->end(n)) is a valid range - //! containing all of the elements in the nth bucket. - const_local_iterator begin(size_type n) const - { return table_.begin(n); } - - //! <b>Requires</b>: n is in the range [0, this->bucket_count()). - //! - //! <b>Effects</b>: Returns a const_local_iterator pointing to the beginning - //! of the sequence stored in the bucket n. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: [this->begin(n), this->end(n)) is a valid range - //! containing all of the elements in the nth bucket. - const_local_iterator cbegin(size_type n) const - { return table_.cbegin(n); } - - //! <b>Requires</b>: n is in the range [0, this->bucket_count()). - //! - //! <b>Effects</b>: Returns a local_iterator pointing to the end - //! of the sequence stored in the bucket n. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: [this->begin(n), this->end(n)) is a valid range - //! containing all of the elements in the nth bucket. - local_iterator end(size_type n) - { return table_.end(n); } - - //! <b>Requires</b>: n is in the range [0, this->bucket_count()). - //! - //! <b>Effects</b>: Returns a const_local_iterator pointing to the end - //! of the sequence stored in the bucket n. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: [this->begin(n), this->end(n)) is a valid range - //! containing all of the elements in the nth bucket. - const_local_iterator end(size_type n) const - { return table_.end(n); } - - //! <b>Requires</b>: n is in the range [0, this->bucket_count()). - //! - //! <b>Effects</b>: Returns a const_local_iterator pointing to the end - //! of the sequence stored in the bucket n. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Note</b>: [this->begin(n), this->end(n)) is a valid range - //! containing all of the elements in the nth bucket. - const_local_iterator cend(size_type n) const - { return table_.cend(n); } - - //! <b>Requires</b>: new_buckets must be a pointer to a new bucket array - //! or the same as the old bucket array. new_size is the length of the - //! the array pointed by new_buckets. If new_buckets == this->bucket_pointer() - //! n can be bigger or smaller than this->bucket_count(). - //! - //! <b>Effects</b>: Updates the internal reference with the new bucket erases - //! the values from the old bucket and inserts then in the new one. - //! - //! If store_hash option is true, this method does not use the hash function. - //! - //! <b>Complexity</b>: Average case linear in this->size(), worst case quadratic. - //! - //! <b>Throws</b>: If the hasher functor throws. - void rehash(const bucket_traits &new_bucket_traits) - { table_.rehash(new_bucket_traits); } - - //! <b>Requires</b>: - //! - //! <b>Effects</b>: - //! - //! <b>Complexity</b>: - //! - //! <b>Throws</b>: - //! - //! <b>Note</b>: this method is only available if incremental<true> option is activated. - bool incremental_rehash(bool grow = true) - { return table_.incremental_rehash(grow); } - - //! <b>Note</b>: this method is only available if incremental<true> option is activated. - bool incremental_rehash(const bucket_traits &new_bucket_traits) - { return table_.incremental_rehash(new_bucket_traits); } - - //! <b>Requires</b>: - //! - //! <b>Effects</b>: - //! - //! <b>Complexity</b>: - //! - //! <b>Throws</b>: - size_type split_count() const - { return table_.split_count(); } - - //! <b>Effects</b>: Returns the nearest new bucket count optimized for - //! the container that is bigger than n. This suggestion can be used - //! to create bucket arrays with a size that will usually improve - //! container's performance. If such value does not exist, the - //! higher possible value is returned. - //! - //! <b>Complexity</b>: Amortized constant time. - //! - //! <b>Throws</b>: Nothing. - static size_type suggested_upper_bucket_count(size_type n) - { return table_type::suggested_upper_bucket_count(n); } - - //! <b>Effects</b>: Returns the nearest new bucket count optimized for - //! the container that is smaller than n. This suggestion can be used - //! to create bucket arrays with a size that will usually improve - //! container's performance. If such value does not exist, the - //! lower possible value is returned. - //! - //! <b>Complexity</b>: Amortized constant time. - //! - //! <b>Throws</b>: Nothing. - static size_type suggested_lower_bucket_count(size_type n) - { return table_type::suggested_lower_bucket_count(n); } -}; - -//! Helper metafunction to define an \c unordered_multiset that yields to the same type when the -//! same options (either explicitly or implicitly) are used. -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) || defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template<class T, class ...Options> -#else -template<class T, class O1 = none, class O2 = none - , class O3 = none, class O4 = none - , class O5 = none, class O6 = none - , class O7 = none, class O8 = none - , class O9 = none, class O10= none - > -#endif -struct make_unordered_multiset -{ - /// @cond - typedef unordered_multiset_impl - < typename make_hashtable_opt - <T, false, - #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) - O1, O2, O3, O4, O5, O6, O7, O8, O9, O10 - #else - Options... - #endif - >::type - > implementation_defined; - /// @endcond - typedef implementation_defined type; -}; - -#ifndef BOOST_INTRUSIVE_DOXYGEN_INVOKED - -#if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template<class T, class O1, class O2, class O3, class O4, class O5, class O6, class O7, class O8, class O9, class O10> -#else -template<class T, class ...Options> -#endif -class unordered_multiset - : public make_unordered_multiset<T, - #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) - O1, O2, O3, O4, O5, O6, O7, O8, O9, O10 - #else - Options... - #endif - >::type -{ - typedef typename make_unordered_multiset - <T, - #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) - O1, O2, O3, O4, O5, O6, O7, O8, O9, O10 - #else - Options... - #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_MOVABLE_BUT_NOT_COPYABLE(unordered_multiset) - - public: - typedef typename Base::value_traits value_traits; - typedef typename Base::bucket_traits bucket_traits; - typedef typename Base::iterator iterator; - typedef typename Base::const_iterator const_iterator; - typedef typename Base::bucket_ptr bucket_ptr; - typedef typename Base::size_type size_type; - typedef typename Base::hasher hasher; - typedef typename Base::key_equal key_equal; - - unordered_multiset( const bucket_traits &b_traits - , const hasher & hash_func = hasher() - , const key_equal &equal_func = key_equal() - , const value_traits &v_traits = value_traits()) - : Base(b_traits, hash_func, equal_func, v_traits) - {} - - template<class Iterator> - unordered_multiset( Iterator b - , Iterator e - , const bucket_traits &b_traits - , const hasher & hash_func = hasher() - , const key_equal &equal_func = key_equal() - , const value_traits &v_traits = value_traits()) - : Base(b, e, b_traits, hash_func, equal_func, v_traits) - {} - - unordered_multiset(BOOST_RV_REF(unordered_multiset) x) - : Base(::boost::move(static_cast<Base&>(x))) - {} - - unordered_multiset& operator=(BOOST_RV_REF(unordered_multiset) x) - { this->Base::operator=(::boost::move(static_cast<Base&>(x))); return *this; } -}; - -#endif - -} //namespace intrusive -} //namespace boost - -#include <boost/intrusive/detail/config_end.hpp> - -#endif //BOOST_INTRUSIVE_UNORDERED_SET_HPP diff --git a/src/third_party/boost/boost/intrusive/unordered_set_hook.hpp b/src/third_party/boost/boost/intrusive/unordered_set_hook.hpp deleted file mode 100644 index 2912d32be74..00000000000 --- a/src/third_party/boost/boost/intrusive/unordered_set_hook.hpp +++ /dev/null @@ -1,434 +0,0 @@ -///////////////////////////////////////////////////////////////////////////// -// -// (C) Copyright Olaf Krzikalla 2004-2006. -// (C) Copyright Ion Gaztanaga 2006-2009 -// -// Distributed under the Boost Software License, Version 1.0. -// (See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) -// -// See http://www.boost.org/libs/intrusive for documentation. -// -///////////////////////////////////////////////////////////////////////////// - -#ifndef BOOST_INTRUSIVE_UNORDERED_SET_HOOK_HPP -#define BOOST_INTRUSIVE_UNORDERED_SET_HOOK_HPP - -#include <boost/intrusive/detail/config_begin.hpp> -#include <boost/intrusive/intrusive_fwd.hpp> -#include <boost/pointer_cast.hpp> -#include <boost/intrusive/detail/utilities.hpp> -#include <boost/intrusive/pointer_traits.hpp> -#include <boost/intrusive/slist_hook.hpp> -#include <boost/intrusive/options.hpp> -#include <boost/intrusive/pointer_traits.hpp> -#include <boost/intrusive/detail/generic_hook.hpp> - -namespace boost { -namespace intrusive { - -/// @cond - -template<class VoidPointer, bool StoreHash, bool OptimizeMultiKey> -struct unordered_node - : public slist_node<VoidPointer> -{ - typedef typename pointer_traits - <VoidPointer>::template rebind_pointer - < unordered_node<VoidPointer, StoreHash, OptimizeMultiKey> >::type - node_ptr; - node_ptr prev_in_group_; - std::size_t hash_; -}; - -template<class VoidPointer> -struct unordered_node<VoidPointer, false, true> - : public slist_node<VoidPointer> -{ - typedef typename pointer_traits - <VoidPointer>::template rebind_pointer - < unordered_node<VoidPointer, false, true> >::type - node_ptr; - node_ptr prev_in_group_; -}; - -template<class VoidPointer> -struct unordered_node<VoidPointer, true, false> - : public slist_node<VoidPointer> -{ - typedef typename pointer_traits - <VoidPointer>::template rebind_pointer - < unordered_node<VoidPointer, true, false> >::type - node_ptr; - std::size_t hash_; -}; - -template<class VoidPointer, bool StoreHash, bool OptimizeMultiKey> -struct unordered_node_traits - : public slist_node_traits<VoidPointer> -{ - typedef slist_node_traits<VoidPointer> reduced_slist_node_traits; - typedef unordered_node<VoidPointer, StoreHash, OptimizeMultiKey> node; - - typedef typename pointer_traits - <VoidPointer>::template rebind_pointer - < node >::type node_ptr; - typedef typename pointer_traits - <VoidPointer>::template rebind_pointer - < const node >::type const_node_ptr; - - static const bool store_hash = StoreHash; - static const bool optimize_multikey = OptimizeMultiKey; - - static node_ptr get_next(const const_node_ptr & n) - { - return pointer_traits<node_ptr>::pointer_to(static_cast<node&>(*n->next_)); - } - - static void set_next(const node_ptr & n, const node_ptr & next) - { n->next_ = next; } - - static node_ptr get_prev_in_group(const const_node_ptr & n) - { return n->prev_in_group_; } - - static void set_prev_in_group(const node_ptr & n, const node_ptr & prev) - { n->prev_in_group_ = prev; } - - static std::size_t get_hash(const const_node_ptr & n) - { return n->hash_; } - - static void set_hash(const node_ptr & n, std::size_t h) - { n->hash_ = h; } -}; - -template<class NodeTraits> -struct unordered_group_adapter -{ - typedef typename NodeTraits::node node; - typedef typename NodeTraits::node_ptr node_ptr; - typedef typename NodeTraits::const_node_ptr const_node_ptr; - - static node_ptr get_next(const const_node_ptr & n) - { return NodeTraits::get_prev_in_group(n); } - - static void set_next(const node_ptr & n, const node_ptr & next) - { NodeTraits::set_prev_in_group(n, next); } -}; - -template<class NodeTraits> -struct unordered_algorithms - : public circular_slist_algorithms<NodeTraits> -{ - typedef circular_slist_algorithms<NodeTraits> base_type; - typedef unordered_group_adapter<NodeTraits> group_traits; - typedef circular_slist_algorithms<group_traits> group_algorithms; - - static void init(typename base_type::node_ptr n) - { - base_type::init(n); - group_algorithms::init(n); - } - - static void init_header(typename base_type::node_ptr n) - { - base_type::init_header(n); - group_algorithms::init_header(n); - } - - static void unlink(typename base_type::node_ptr n) - { - base_type::unlink(n); - group_algorithms::unlink(n); - } -}; - -template<class VoidPointer, bool StoreHash, bool OptimizeMultiKey> -struct get_uset_node_algo -{ - typedef typename detail::if_c - < (StoreHash || OptimizeMultiKey) - , unordered_node_traits<VoidPointer, StoreHash, OptimizeMultiKey> - , slist_node_traits<VoidPointer> - >::type node_traits_type; - typedef typename detail::if_c - < OptimizeMultiKey - , unordered_algorithms<node_traits_type> - , circular_slist_algorithms<node_traits_type> - >::type type; -}; -/// @endcond - -//! Helper metafunction to define a \c unordered_set_base_hook that yields to the same -//! type when the same options (either explicitly or implicitly) are used. -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) || defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template<class ...Options> -#else -template<class O1 = none, class O2 = none, class O3 = none, class O4 = none> -#endif -struct make_unordered_set_base_hook -{ - /// @cond - typedef typename pack_options - < hook_defaults, - #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) - O1, O2, O3, O4 - #else - Options... - #endif - >::type packed_options; - - typedef detail::generic_hook - < get_uset_node_algo<typename packed_options::void_pointer - , packed_options::store_hash - , packed_options::optimize_multikey - > - , typename packed_options::tag - , packed_options::link_mode - , detail::UsetBaseHook - > implementation_defined; - /// @endcond - typedef implementation_defined type; -}; - -//! Derive a class from unordered_set_base_hook in order to store objects in -//! in an unordered_set/unordered_multi_set. unordered_set_base_hook holds the data necessary to maintain -//! the unordered_set/unordered_multi_set and provides an appropriate value_traits class for unordered_set/unordered_multi_set. -//! -//! The hook admits the following options: \c tag<>, \c void_pointer<>, -//! \c link_mode<>, \c store_hash<> and \c optimize_multikey<>. -//! -//! \c tag<> defines a tag to identify the node. -//! The same tag value can be used in different classes, but if a class is -//! derived from more than one \c list_base_hook, then each \c list_base_hook needs its -//! unique tag. -//! -//! \c void_pointer<> is the pointer type that will be used internally in the hook -//! and the the container configured to use this hook. -//! -//! \c link_mode<> will specify the linking mode of the hook (\c normal_link, -//! \c auto_unlink or \c safe_link). -//! -//! \c store_hash<> will tell the hook to store the hash of the value -//! to speed up rehashings. -//! -//! \c optimize_multikey<> will tell the hook to store a link to form a group -//! with other value with the same value to speed up searches and insertions -//! in unordered_multisets with a great number of with equivalent keys. -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) || defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template<class ...Options> -#else -template<class O1, class O2, class O3, class O4> -#endif -class unordered_set_base_hook - : public make_unordered_set_base_hook< - #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) - O1, O2, O3, O4 - #else - Options... - #endif - >::type -{ - #if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) - public: - //! <b>Effects</b>: If link_mode is \c auto_unlink or \c safe_link - //! initializes the node to an unlinked state. - //! - //! <b>Throws</b>: Nothing. - unordered_set_base_hook(); - - //! <b>Effects</b>: If link_mode is \c auto_unlink or \c safe_link - //! initializes the node to an unlinked state. The argument is ignored. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Rationale</b>: Providing a copy-constructor - //! makes classes using the hook STL-compliant without forcing the - //! user to do some additional work. \c swap can be used to emulate - //! move-semantics. - unordered_set_base_hook(const unordered_set_base_hook& ); - - //! <b>Effects</b>: Empty function. The argument is ignored. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Rationale</b>: Providing an assignment operator - //! makes classes using the hook STL-compliant without forcing the - //! user to do some additional work. \c swap can be used to emulate - //! move-semantics. - unordered_set_base_hook& operator=(const unordered_set_base_hook& ); - - //! <b>Effects</b>: If link_mode is \c normal_link, the destructor does - //! nothing (ie. no code is generated). If link_mode is \c safe_link and the - //! object is stored in an unordered_set an assertion is raised. If link_mode is - //! \c auto_unlink and \c is_linked() is true, the node is unlinked. - //! - //! <b>Throws</b>: Nothing. - ~unordered_set_base_hook(); - - //! <b>Effects</b>: Swapping two nodes swaps the position of the elements - //! related to those nodes in one or two containers. That is, if the node - //! this is part of the element e1, the node x is part of the element e2 - //! and both elements are included in the containers s1 and s2, then after - //! the swap-operation e1 is in s2 at the position of e2 and e2 is in s1 - //! at the position of e1. If one element is not in a container, then - //! after the swap-operation the other element is not in a container. - //! Iterators to e1 and e2 related to those nodes are invalidated. - //! - //! <b>Complexity</b>: Constant - //! - //! <b>Throws</b>: Nothing. - void swap_nodes(unordered_set_base_hook &other); - - //! <b>Precondition</b>: link_mode must be \c safe_link or \c auto_unlink. - //! - //! <b>Returns</b>: true, if the node belongs to a container, false - //! otherwise. This function can be used to test whether \c unordered_set::iterator_to - //! will return a valid iterator. - //! - //! <b>Complexity</b>: Constant - bool is_linked() const; - - //! <b>Effects</b>: Removes the node if it's inserted in a container. - //! This function is only allowed if link_mode is \c auto_unlink. - //! - //! <b>Throws</b>: Nothing. - void unlink(); - #endif -}; - - -//! Helper metafunction to define a \c unordered_set_member_hook that yields to the same -//! type when the same options (either explicitly or implicitly) are used. -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) || defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template<class ...Options> -#else -template<class O1 = none, class O2 = none, class O3 = none, class O4 = none> -#endif -struct make_unordered_set_member_hook -{ - /// @cond - typedef typename pack_options - < hook_defaults, - #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) - O1, O2, O3, O4 - #else - Options... - #endif - >::type packed_options; - - typedef detail::generic_hook - < get_uset_node_algo< typename packed_options::void_pointer - , packed_options::store_hash - , packed_options::optimize_multikey - > - , member_tag - , packed_options::link_mode - , detail::NoBaseHook - > implementation_defined; - /// @endcond - typedef implementation_defined type; -}; - -//! Put a public data member unordered_set_member_hook in order to store objects of this class in -//! an unordered_set/unordered_multi_set. unordered_set_member_hook holds the data necessary for maintaining the -//! unordered_set/unordered_multi_set and provides an appropriate value_traits class for unordered_set/unordered_multi_set. -//! -//! The hook admits the following options: \c void_pointer<>, -//! \c link_mode<> and \c store_hash<>. -//! -//! \c void_pointer<> is the pointer type that will be used internally in the hook -//! and the the container configured to use this hook. -//! -//! \c link_mode<> will specify the linking mode of the hook (\c normal_link, -//! \c auto_unlink or \c safe_link). -//! -//! \c store_hash<> will tell the hook to store the hash of the value -//! to speed up rehashings. -#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) || defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) -template<class ...Options> -#else -template<class O1, class O2, class O3, class O4> -#endif -class unordered_set_member_hook - : public make_unordered_set_member_hook< - #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES) - O1, O2, O3, O4 - #else - Options... - #endif - >::type -{ - #if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) - public: - //! <b>Effects</b>: If link_mode is \c auto_unlink or \c safe_link - //! initializes the node to an unlinked state. - //! - //! <b>Throws</b>: Nothing. - unordered_set_member_hook(); - - //! <b>Effects</b>: If link_mode is \c auto_unlink or \c safe_link - //! initializes the node to an unlinked state. The argument is ignored. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Rationale</b>: Providing a copy-constructor - //! makes classes using the hook STL-compliant without forcing the - //! user to do some additional work. \c swap can be used to emulate - //! move-semantics. - unordered_set_member_hook(const unordered_set_member_hook& ); - - //! <b>Effects</b>: Empty function. The argument is ignored. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Rationale</b>: Providing an assignment operator - //! makes classes using the hook STL-compliant without forcing the - //! user to do some additional work. \c swap can be used to emulate - //! move-semantics. - unordered_set_member_hook& operator=(const unordered_set_member_hook& ); - - //! <b>Effects</b>: If link_mode is \c normal_link, the destructor does - //! nothing (ie. no code is generated). If link_mode is \c safe_link and the - //! object is stored in an unordered_set an assertion is raised. If link_mode is - //! \c auto_unlink and \c is_linked() is true, the node is unlinked. - //! - //! <b>Throws</b>: Nothing. - ~unordered_set_member_hook(); - - //! <b>Effects</b>: Swapping two nodes swaps the position of the elements - //! related to those nodes in one or two containers. That is, if the node - //! this is part of the element e1, the node x is part of the element e2 - //! and both elements are included in the containers s1 and s2, then after - //! the swap-operation e1 is in s2 at the position of e2 and e2 is in s1 - //! at the position of e1. If one element is not in a container, then - //! after the swap-operation the other element is not in a container. - //! Iterators to e1 and e2 related to those nodes are invalidated. - //! - //! <b>Complexity</b>: Constant - //! - //! <b>Throws</b>: Nothing. - void swap_nodes(unordered_set_member_hook &other); - - //! <b>Precondition</b>: link_mode must be \c safe_link or \c auto_unlink. - //! - //! <b>Returns</b>: true, if the node belongs to a container, false - //! otherwise. This function can be used to test whether \c unordered_set::iterator_to - //! will return a valid iterator. - //! - //! <b>Complexity</b>: Constant - bool is_linked() const; - - //! <b>Effects</b>: Removes the node if it's inserted in a container. - //! This function is only allowed if link_mode is \c auto_unlink. - //! - //! <b>Throws</b>: Nothing. - void unlink(); - #endif -}; - -} //namespace intrusive -} //namespace boost - -#include <boost/intrusive/detail/config_end.hpp> - -#endif //BOOST_INTRUSIVE_UNORDERED_SET_HOOK_HPP |