boost/container/stable_vector.hpp
////////////////////////////////////////////////////////////////////////////// // // (C) Copyright Ion Gaztanaga 2008-2015. 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/container for documentation. // ////////////////////////////////////////////////////////////////////////////// // Stable vector. // // Copyright 2008 Joaquin M Lopez Munoz. // 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) // ////////////////////////////////////////////////////////////////////////////// #ifndef BOOST_CONTAINER_STABLE_VECTOR_HPP #define BOOST_CONTAINER_STABLE_VECTOR_HPP #ifndef BOOST_CONFIG_HPP # include <boost/config.hpp> #endif #if defined(BOOST_HAS_PRAGMA_ONCE) # pragma once #endif #include <boost/container/detail/config_begin.hpp> #include <boost/container/detail/workaround.hpp> // container #include <boost/container/allocator_traits.hpp> #include <boost/container/container_fwd.hpp> #include <boost/container/new_allocator.hpp> //new_allocator #include <boost/container/throw_exception.hpp> // container/detail #include <boost/container/detail/addressof.hpp> #include <boost/container/detail/algorithm.hpp> //algo_equal(), algo_lexicographical_compare #include <boost/container/detail/alloc_helpers.hpp> #include <boost/container/detail/allocator_version_traits.hpp> #include <boost/container/detail/construct_in_place.hpp> #include <boost/container/detail/iterator.hpp> #include <boost/container/detail/iterators.hpp> #include <boost/container/detail/placement_new.hpp> #include <boost/move/detail/to_raw_pointer.hpp> #include <boost/container/detail/type_traits.hpp> // intrusive #include <boost/intrusive/pointer_traits.hpp> // intrusive/detail #include <boost/intrusive/detail/minimal_pair_header.hpp> //pair // move #include <boost/move/utility_core.hpp> #include <boost/move/iterator.hpp> #include <boost/move/adl_move_swap.hpp> #include <boost/move/detail/launder.hpp> // move/detail #include <boost/move/detail/move_helpers.hpp> #include <boost/move/detail/iterator_to_raw_pointer.hpp> // other #include <boost/assert.hpp> // std #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST) #include <initializer_list> #endif #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED #include <boost/container/vector.hpp> //#define STABLE_VECTOR_ENABLE_INVARIANT_CHECKING #endif //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED namespace boost { namespace container { #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED namespace stable_vector_detail{ template <class C> class clear_on_destroy { public: inline clear_on_destroy(C &c) : c_(c), do_clear_(true) {} inline void release() { do_clear_ = false; } inline ~clear_on_destroy() { if(do_clear_){ c_.clear(); c_.priv_clear_pool(); } } private: clear_on_destroy(const clear_on_destroy &); clear_on_destroy &operator=(const clear_on_destroy &); C &c_; bool do_clear_; }; template<typename Pointer> struct node; template<class VoidPtr> struct node_base { private: typedef typename boost::intrusive:: pointer_traits<VoidPtr> void_ptr_traits; typedef typename void_ptr_traits:: template rebind_pointer <node_base>::type node_base_ptr; public: typedef typename void_ptr_traits:: template rebind_pointer <node_base_ptr>::type node_base_ptr_ptr; public: inline explicit node_base(const node_base_ptr_ptr &n) : up(n) {} inline node_base() : up() {} node_base_ptr_ptr up; }; template<typename Pointer> struct node : public node_base <typename ::boost::intrusive::pointer_traits<Pointer>::template rebind_pointer<void>::type > { public: typedef typename ::boost::intrusive::pointer_traits<Pointer>::element_type T; typedef node_base <typename ::boost::intrusive::pointer_traits<Pointer>::template rebind_pointer<void>::type > hook_type; typedef typename boost::container::dtl::aligned_storage <sizeof(T), boost::container::dtl::alignment_of<T>::value>::type storage_t; storage_t m_storage; inline explicit node(const typename hook_type::node_base_ptr_ptr &n) : hook_type(n) {} inline node() {} #if defined(BOOST_GCC) && (BOOST_GCC >= 40600) && (BOOST_GCC < 80000) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wstrict-aliasing" #define BOOST_CONTAINER_DISABLE_ALIASING_WARNING # endif inline T &get_data() { return *boost::move_detail::launder_cast<T*>(&this->m_storage); } inline const T &get_data() const { return *boost::move_detail::launder_cast<const T*>(&this->m_storage); } inline T *get_data_ptr() { return boost::move_detail::launder_cast<T*>(&this->m_storage); } inline const T *get_data_ptr() const { return boost::move_detail::launder_cast<const T*>(&this->m_storage); } inline ~node() { boost::move_detail::launder_cast<T*>(&this->m_storage)->~T(); } #if defined(BOOST_CONTAINER_DISABLE_ALIASING_WARNING) #pragma GCC diagnostic pop #undef BOOST_CONTAINER_DISABLE_ALIASING_WARNING # endif inline void destroy_header() { static_cast<hook_type*>(this)->~hook_type(); } }; template<class VoidPtr, class VoidAllocator> struct index_traits { typedef boost::intrusive:: pointer_traits <VoidPtr> void_ptr_traits; typedef stable_vector_detail:: node_base<VoidPtr> node_base_type; typedef typename void_ptr_traits::template rebind_pointer<node_base_type>::type node_base_ptr; typedef typename void_ptr_traits::template rebind_pointer<node_base_ptr>::type node_base_ptr_ptr; typedef boost::intrusive:: pointer_traits<node_base_ptr> node_base_ptr_traits; typedef boost::intrusive:: pointer_traits<node_base_ptr_ptr> node_base_ptr_ptr_traits; typedef typename allocator_traits<VoidAllocator>:: template portable_rebind_alloc <node_base_ptr>::type node_base_ptr_allocator; typedef ::boost::container::vector <node_base_ptr, node_base_ptr_allocator> index_type; typedef typename index_type::iterator index_iterator; typedef typename index_type::const_iterator const_index_iterator; typedef typename index_type::size_type size_type; BOOST_STATIC_CONSTEXPR size_type ExtraPointers = 3; //Stable vector stores metadata at the end of the index (node_base_ptr vector) with additional 3 pointers: // back() is this->index.back() - ExtraPointers; // end node index is *(this->index.end() - 3) // Node cache first is *(this->index.end() - 2); // Node cache last is this->index.back(); inline static node_base_ptr_ptr ptr_to_node_base_ptr(node_base_ptr &n) { return node_base_ptr_ptr_traits::pointer_to(n); } static void fix_up_pointers(index_iterator first, index_iterator last) { while(first != last){ typedef typename index_type::reference node_base_ptr_ref; node_base_ptr_ref nbp = *first; nbp->up = index_traits::ptr_to_node_base_ptr(nbp); ++first; } } inline static index_iterator get_fix_up_end(index_type &index) { return index.end() - (ExtraPointers - 1); } inline static void fix_up_pointers_from(index_type & index, index_iterator first) { index_traits::fix_up_pointers(first, index_traits::get_fix_up_end(index)); } static void readjust_end_node(index_type &index, node_base_type &end_node) { if(!index.empty()){ index_iterator end_node_it(index_traits::get_fix_up_end(index)); node_base_ptr &end_node_idx_ref = *(--end_node_it); end_node_idx_ref = node_base_ptr_traits::pointer_to(end_node); end_node.up = node_base_ptr_ptr_traits::pointer_to(end_node_idx_ref); } else{ end_node.up = node_base_ptr_ptr(); } } static void initialize_end_node(index_type &index, node_base_type &end_node, const size_type index_capacity_if_empty) { if(index.empty()){ index.reserve(index_capacity_if_empty + ExtraPointers); index.resize(ExtraPointers); node_base_ptr &end_node_ref = *index.data(); end_node_ref = node_base_ptr_traits::pointer_to(end_node); end_node.up = index_traits::ptr_to_node_base_ptr(end_node_ref); } } #ifdef STABLE_VECTOR_ENABLE_INVARIANT_CHECKING static bool invariants(index_type &index) { for( index_iterator it = index.begin() , it_end = index_traits::get_fix_up_end(index) ; it != it_end ; ++it){ if((*it)->up != index_traits::ptr_to_node_base_ptr(*it)){ return false; } } return true; } #endif //STABLE_VECTOR_ENABLE_INVARIANT_CHECKING }; } //namespace stable_vector_detail template<typename Pointer, bool IsConst> class stable_vector_iterator { typedef boost::intrusive::pointer_traits<Pointer> non_const_ptr_traits; public: typedef std::random_access_iterator_tag iterator_category; typedef typename non_const_ptr_traits::element_type value_type; typedef typename non_const_ptr_traits::difference_type difference_type; typedef typename non_const_ptr_traits::size_type size_type; typedef typename ::boost::container::dtl::if_c < IsConst , typename non_const_ptr_traits::template rebind_pointer<const value_type>::type , Pointer >::type pointer; typedef boost::intrusive::pointer_traits<pointer> ptr_traits; typedef typename ptr_traits::reference reference; typedef typename non_const_ptr_traits::template rebind_pointer<void>::type void_ptr; typedef stable_vector_detail::node<Pointer> node_type; typedef stable_vector_detail::node_base<void_ptr> node_base_type; typedef typename non_const_ptr_traits::template rebind_pointer<node_type>::type node_ptr; typedef boost::intrusive:: pointer_traits<node_ptr> node_ptr_traits; typedef typename non_const_ptr_traits::template rebind_pointer<node_base_type>::type node_base_ptr; typedef typename non_const_ptr_traits::template rebind_pointer<node_base_ptr>::type node_base_ptr_ptr; class nat { public: node_base_ptr node_pointer() const { return node_base_ptr(); } }; typedef typename dtl::if_c< IsConst , stable_vector_iterator<Pointer, false> , nat>::type nonconst_iterator; node_base_ptr m_pn; public: inline explicit stable_vector_iterator(node_base_ptr p) BOOST_NOEXCEPT_OR_NOTHROW : m_pn(p) {} inline stable_vector_iterator() BOOST_NOEXCEPT_OR_NOTHROW : m_pn() //Value initialization to achieve "null iterators" (N3644) {} inline stable_vector_iterator(const stable_vector_iterator& other) BOOST_NOEXCEPT_OR_NOTHROW : m_pn(other.node_pointer()) {} inline stable_vector_iterator(const nonconst_iterator& other) BOOST_NOEXCEPT_OR_NOTHROW : m_pn(other.node_pointer()) {} inline stable_vector_iterator & operator=(const stable_vector_iterator& other) BOOST_NOEXCEPT_OR_NOTHROW { m_pn = other.node_pointer(); return *this; } BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline node_ptr node_pointer() const BOOST_NOEXCEPT_OR_NOTHROW { return node_ptr_traits::static_cast_from(m_pn); } public: //Pointer like operators BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline reference operator*() const BOOST_NOEXCEPT_OR_NOTHROW { return node_pointer()->get_data(); } BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline pointer operator->() const BOOST_NOEXCEPT_OR_NOTHROW { return ptr_traits::pointer_to(this->operator*()); } //Increment / Decrement inline stable_vector_iterator& operator++() BOOST_NOEXCEPT_OR_NOTHROW { node_base_ptr_ptr p(this->m_pn->up); this->m_pn = *(++p); return *this; } inline stable_vector_iterator operator++(int) BOOST_NOEXCEPT_OR_NOTHROW { stable_vector_iterator tmp(*this); ++*this; return stable_vector_iterator(tmp); } inline stable_vector_iterator& operator--() BOOST_NOEXCEPT_OR_NOTHROW { node_base_ptr_ptr p(this->m_pn->up); this->m_pn = *(--p); return *this; } inline stable_vector_iterator operator--(int) BOOST_NOEXCEPT_OR_NOTHROW { stable_vector_iterator tmp(*this); --*this; return stable_vector_iterator(tmp); } BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline reference operator[](difference_type off) const BOOST_NOEXCEPT_OR_NOTHROW { return node_ptr_traits::static_cast_from(this->m_pn->up[off])->get_data(); } //Arithmetic inline stable_vector_iterator& operator+=(difference_type off) BOOST_NOEXCEPT_OR_NOTHROW { if(off) this->m_pn = this->m_pn->up[off]; return *this; } BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline friend stable_vector_iterator operator+(const stable_vector_iterator &left, difference_type off) BOOST_NOEXCEPT_OR_NOTHROW { stable_vector_iterator tmp(left); tmp += off; return tmp; } BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline friend stable_vector_iterator operator+(difference_type off, const stable_vector_iterator& right) BOOST_NOEXCEPT_OR_NOTHROW { stable_vector_iterator tmp(right); tmp += off; return tmp; } inline stable_vector_iterator& operator-=(difference_type off) BOOST_NOEXCEPT_OR_NOTHROW { *this += -off; return *this; } BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline friend stable_vector_iterator operator-(const stable_vector_iterator &left, difference_type off) BOOST_NOEXCEPT_OR_NOTHROW { stable_vector_iterator tmp(left); tmp -= off; return tmp; } //Difference BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline friend difference_type operator-(const stable_vector_iterator &left, const stable_vector_iterator &right) BOOST_NOEXCEPT_OR_NOTHROW { return left.m_pn->up - right.m_pn->up; } //Comparison operators BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline friend bool operator== (const stable_vector_iterator& l, const stable_vector_iterator& r) BOOST_NOEXCEPT_OR_NOTHROW { return l.m_pn == r.m_pn; } BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline friend bool operator!= (const stable_vector_iterator& l, const stable_vector_iterator& r) BOOST_NOEXCEPT_OR_NOTHROW { return l.m_pn != r.m_pn; } BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline friend bool operator< (const stable_vector_iterator& l, const stable_vector_iterator& r) BOOST_NOEXCEPT_OR_NOTHROW { return l.m_pn->up < r.m_pn->up; } BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline friend bool operator<= (const stable_vector_iterator& l, const stable_vector_iterator& r) BOOST_NOEXCEPT_OR_NOTHROW { return l.m_pn->up <= r.m_pn->up; } BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline friend bool operator> (const stable_vector_iterator& l, const stable_vector_iterator& r) BOOST_NOEXCEPT_OR_NOTHROW { return l.m_pn->up > r.m_pn->up; } BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline friend bool operator>= (const stable_vector_iterator& l, const stable_vector_iterator& r) BOOST_NOEXCEPT_OR_NOTHROW { return l.m_pn->up >= r.m_pn->up; } }; #if defined(STABLE_VECTOR_ENABLE_INVARIANT_CHECKING) #define BOOST_CONTAINER_STABLE_VECTOR_CHECK_INVARIANT \ invariant_checker BOOST_JOIN(check_invariant_,__LINE__)(*this); \ BOOST_JOIN(check_invariant_,__LINE__).touch(); #else //STABLE_VECTOR_ENABLE_INVARIANT_CHECKING #define BOOST_CONTAINER_STABLE_VECTOR_CHECK_INVARIANT #endif //#if defined(STABLE_VECTOR_ENABLE_INVARIANT_CHECKING) #endif //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED //! Originally developed by Joaquin M. Lopez Munoz, stable_vector is a std::vector //! drop-in replacement implemented as a node container, offering iterator and reference //! stability. //! //! Here are the details taken from the author's blog //! (<a href="http://bannalia.blogspot.com/2008/09/introducing-stablevector.html" > //! Introducing stable_vector</a>): //! //! We present stable_vector, a fully STL-compliant stable container that provides //! most of the features of std::vector except element contiguity. //! //! General properties: stable_vector satisfies all the requirements of a container, //! a reversible container and a sequence and provides all the optional operations //! present in std::vector. Like std::vector, iterators are random access. //! stable_vector does not provide element contiguity; in exchange for this absence, //! the container is stable, i.e. references and iterators to an element of a stable_vector //! remain valid as long as the element is not erased, and an iterator that has been //! assigned the return value of end() always remain valid until the destruction of //! the associated stable_vector. //! //! Operation complexity: The big-O complexities of stable_vector operations match //! exactly those of std::vector. In general, insertion/deletion is constant time at //! the end of the sequence and linear elsewhere. Unlike std::vector, stable_vector //! does not internally perform any value_type destruction, copy or assignment //! operations other than those exactly corresponding to the insertion of new //! elements or deletion of stored elements, which can sometimes compensate in terms //! of performance for the extra burden of doing more pointer manipulation and an //! additional allocation per element. //! //! Exception safety: As stable_vector does not internally copy elements around, some //! operations provide stronger exception safety guarantees than in std::vector. //! //! \tparam T The type of object that is stored in the stable_vector //! \tparam Allocator The allocator used for all internal memory management #ifdef BOOST_CONTAINER_DOXYGEN_INVOKED template <class T, class Allocator = void > #else template <class T, class Allocator> #endif class stable_vector { #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED typedef typename real_allocator<T, Allocator>::type ValueAllocator; typedef allocator_traits<ValueAllocator> allocator_traits_type; typedef boost::intrusive:: pointer_traits <typename allocator_traits_type::pointer> ptr_traits; typedef typename ptr_traits:: template rebind_pointer<void>::type void_ptr; typedef typename allocator_traits_type:: template portable_rebind_alloc <void>::type void_allocator_type; typedef stable_vector_detail::index_traits <void_ptr, void_allocator_type> index_traits_type; typedef typename index_traits_type::node_base_type node_base_type; typedef typename index_traits_type::node_base_ptr node_base_ptr; typedef typename index_traits_type:: node_base_ptr_ptr node_base_ptr_ptr; typedef typename index_traits_type:: node_base_ptr_traits node_base_ptr_traits; typedef typename index_traits_type:: node_base_ptr_ptr_traits node_base_ptr_ptr_traits; typedef typename index_traits_type::index_type index_type; typedef typename index_traits_type::index_iterator index_iterator; typedef typename index_traits_type:: const_index_iterator const_index_iterator; typedef stable_vector_detail::node <typename ptr_traits::pointer> node_type; typedef typename ptr_traits::template rebind_pointer<node_type>::type node_ptr; typedef boost::intrusive:: pointer_traits<node_ptr> node_ptr_traits; typedef typename ptr_traits::template rebind_pointer<const node_type>::type const_node_ptr; typedef boost::intrusive:: pointer_traits<const_node_ptr> const_node_ptr_traits; typedef typename node_ptr_traits::reference node_reference; typedef typename const_node_ptr_traits::reference const_node_reference; typedef ::boost::container::dtl::integral_constant <unsigned, boost::container::dtl:: version<ValueAllocator>::value> alloc_version; typedef typename allocator_traits_type:: template portable_rebind_alloc <node_type>::type node_allocator_type; typedef ::boost::container::dtl:: allocator_version_traits<node_allocator_type> allocator_version_traits_t; typedef typename allocator_version_traits_t::multiallocation_chain multiallocation_chain; inline node_ptr allocate_one() { return allocator_version_traits_t::allocate_one(this->priv_node_alloc()); } inline void deallocate_one(const node_ptr &p) { allocator_version_traits_t::deallocate_one(this->priv_node_alloc(), p); } inline void allocate_individual(typename allocator_traits_type::size_type n, multiallocation_chain &m) { allocator_version_traits_t::allocate_individual(this->priv_node_alloc(), n, m); } inline void deallocate_individual(multiallocation_chain &holder) { allocator_version_traits_t::deallocate_individual(this->priv_node_alloc(), holder); } friend class stable_vector_detail::clear_on_destroy<stable_vector>; typedef stable_vector_iterator < typename allocator_traits<ValueAllocator>::pointer , false> iterator_impl; typedef stable_vector_iterator < typename allocator_traits<ValueAllocator>::pointer , true> const_iterator_impl; #endif //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED public: ////////////////////////////////////////////// // // types // ////////////////////////////////////////////// typedef T value_type; typedef typename ::boost::container::allocator_traits<ValueAllocator>::pointer pointer; typedef typename ::boost::container::allocator_traits<ValueAllocator>::const_pointer const_pointer; typedef typename ::boost::container::allocator_traits<ValueAllocator>::reference reference; typedef typename ::boost::container::allocator_traits<ValueAllocator>::const_reference const_reference; typedef typename ::boost::container::allocator_traits<ValueAllocator>::size_type size_type; typedef typename ::boost::container::allocator_traits<ValueAllocator>::difference_type difference_type; typedef ValueAllocator allocator_type; typedef node_allocator_type stored_allocator_type; typedef BOOST_CONTAINER_IMPDEF(iterator_impl) iterator; typedef BOOST_CONTAINER_IMPDEF(const_iterator_impl) const_iterator; typedef BOOST_CONTAINER_IMPDEF(boost::container::reverse_iterator<iterator>) reverse_iterator; typedef BOOST_CONTAINER_IMPDEF(boost::container::reverse_iterator<const_iterator>) const_reverse_iterator; #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED private: BOOST_COPYABLE_AND_MOVABLE(stable_vector) BOOST_STATIC_CONSTEXPR size_type ExtraPointers = index_traits_type::ExtraPointers; class insert_rollback; friend class insert_rollback; class push_back_rollback; friend class push_back_rollback; #endif //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED public: ////////////////////////////////////////////// // // construct/copy/destroy // ////////////////////////////////////////////// //! <b>Effects</b>: Default constructs a stable_vector. //! //! <b>Throws</b>: If allocator_type's default constructor throws. //! //! <b>Complexity</b>: Constant. inline stable_vector() BOOST_NOEXCEPT_IF(dtl::is_nothrow_default_constructible<ValueAllocator>::value) : internal_data(), index() { BOOST_CONTAINER_STABLE_VECTOR_CHECK_INVARIANT; } //! <b>Effects</b>: Constructs a stable_vector taking the allocator as parameter. //! //! <b>Throws</b>: Nothing //! //! <b>Complexity</b>: Constant. inline explicit stable_vector(const allocator_type& al) BOOST_NOEXCEPT_OR_NOTHROW : internal_data(al), index(al) { BOOST_CONTAINER_STABLE_VECTOR_CHECK_INVARIANT; } //! <b>Effects</b>: Constructs a stable_vector //! and inserts n value initialized values. //! //! <b>Throws</b>: If allocator_type's default constructor //! throws or T's default or copy constructor throws. //! //! <b>Complexity</b>: Linear to n. explicit stable_vector(size_type n) : internal_data(), index() { stable_vector_detail::clear_on_destroy<stable_vector> cod(*this); this->resize(n); BOOST_CONTAINER_STABLE_VECTOR_CHECK_INVARIANT; cod.release(); } //! <b>Effects</b>: Constructs a stable_vector //! and inserts n default initialized values. //! //! <b>Throws</b>: If allocator_type's default constructor //! throws or T's default or copy constructor throws. //! //! <b>Complexity</b>: Linear to n. //! //! <b>Note</b>: Non-standard extension stable_vector(size_type n, default_init_t) : internal_data(), index() { stable_vector_detail::clear_on_destroy<stable_vector> cod(*this); this->resize(n, default_init); BOOST_CONTAINER_STABLE_VECTOR_CHECK_INVARIANT; cod.release(); } //! <b>Effects</b>: Constructs a stable_vector that will use a copy of allocator a //! and inserts n value initialized values. //! //! <b>Throws</b>: If allocator_type's default constructor //! throws or T's default or copy constructor throws. //! //! <b>Complexity</b>: Linear to n. explicit stable_vector(size_type n, const allocator_type &a) : internal_data(), index(a) { stable_vector_detail::clear_on_destroy<stable_vector> cod(*this); this->resize(n); BOOST_CONTAINER_STABLE_VECTOR_CHECK_INVARIANT; cod.release(); } //! <b>Effects</b>: Constructs a stable_vector that will use a copy of allocator a //! and inserts n default initialized values. //! //! <b>Throws</b>: If allocator_type's default constructor //! throws or T's default or copy constructor throws. //! //! <b>Complexity</b>: Linear to n. //! //! <b>Note</b>: Non-standard extension stable_vector(size_type n, default_init_t, const allocator_type &a) : internal_data(), index(a) { stable_vector_detail::clear_on_destroy<stable_vector> cod(*this); this->resize(n, default_init); BOOST_CONTAINER_STABLE_VECTOR_CHECK_INVARIANT; cod.release(); } //! <b>Effects</b>: Constructs a stable_vector that will use a copy of allocator a //! and inserts n copies of value. //! //! <b>Throws</b>: If allocator_type's default constructor //! throws or T's default or copy constructor throws. //! //! <b>Complexity</b>: Linear to n. stable_vector(size_type n, const T& t, const allocator_type& al = allocator_type()) : internal_data(al), index(al) { stable_vector_detail::clear_on_destroy<stable_vector> cod(*this); this->insert(this->cend(), n, t); BOOST_CONTAINER_STABLE_VECTOR_CHECK_INVARIANT; cod.release(); } //! <b>Effects</b>: Constructs a stable_vector that will use a copy of allocator a //! and inserts a copy of the range [first, last) in the stable_vector. //! //! <b>Throws</b>: If allocator_type's default constructor //! throws or T's constructor taking a dereferenced InIt throws. //! //! <b>Complexity</b>: Linear to the range [first, last). template <class InputIterator> stable_vector(InputIterator first,InputIterator last, const allocator_type& al = allocator_type()) : internal_data(al), index(al) { stable_vector_detail::clear_on_destroy<stable_vector> cod(*this); this->insert(this->cend(), first, last); BOOST_CONTAINER_STABLE_VECTOR_CHECK_INVARIANT; cod.release(); } //! <b>Effects</b>: Copy constructs a stable_vector. //! //! <b>Postcondition</b>: x == *this. //! //! <b>Complexity</b>: Linear to the elements x contains. stable_vector(const stable_vector& x) : internal_data(allocator_traits<node_allocator_type>:: select_on_container_copy_construction(x.priv_node_alloc())) , index(allocator_traits<allocator_type>:: select_on_container_copy_construction(x.index.get_stored_allocator())) { stable_vector_detail::clear_on_destroy<stable_vector> cod(*this); this->insert(this->cend(), x.begin(), x.end()); BOOST_CONTAINER_STABLE_VECTOR_CHECK_INVARIANT; cod.release(); } #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST) //! <b>Effects</b>: Constructs a stable_vector that will use a copy of allocator a //! and inserts a copy of the range [il.begin(), il.last()) in the stable_vector //! //! <b>Throws</b>: If allocator_type's default constructor //! throws or T's constructor taking a dereferenced initializer_list iterator throws. //! //! <b>Complexity</b>: Linear to the range [il.begin(), il.end()). stable_vector(std::initializer_list<value_type> il, const allocator_type& l = allocator_type()) : internal_data(l), index(l) { stable_vector_detail::clear_on_destroy<stable_vector> cod(*this); insert(cend(), il.begin(), il.end()); BOOST_CONTAINER_STABLE_VECTOR_CHECK_INVARIANT; cod.release(); } #endif //! <b>Effects</b>: Move constructor. Moves x's resources to *this. //! //! <b>Throws</b>: If allocator_type's copy constructor throws. //! //! <b>Complexity</b>: Constant. inline stable_vector(BOOST_RV_REF(stable_vector) x) BOOST_NOEXCEPT_OR_NOTHROW : internal_data(boost::move(x.priv_node_alloc())), index(boost::move(x.index)) { this->priv_swap_members(x); } //! <b>Effects</b>: Copy constructs a stable_vector using the specified allocator. //! //! <b>Postcondition</b>: x == *this. //! //! <b>Complexity</b>: Linear to the elements x contains. stable_vector(const stable_vector& x, const allocator_type &a) : internal_data(a), index(a) { stable_vector_detail::clear_on_destroy<stable_vector> cod(*this); this->insert(this->cend(), x.begin(), x.end()); BOOST_CONTAINER_STABLE_VECTOR_CHECK_INVARIANT; cod.release(); } //! <b>Effects</b>: Move constructor using the specified allocator. //! Moves x's resources to *this. //! //! <b>Throws</b>: If allocator_type's copy constructor throws. //! //! <b>Complexity</b>: Constant if a == x.get_allocator(), linear otherwise stable_vector(BOOST_RV_REF(stable_vector) x, const allocator_type &a) : internal_data(a), index(a) { if(this->priv_node_alloc() == x.priv_node_alloc()){ this->index.swap(x.index); this->priv_swap_members(x); } else{ stable_vector_detail::clear_on_destroy<stable_vector> cod(*this); this->insert(this->cend(), boost::make_move_iterator(x.begin()), boost::make_move_iterator(x.end())); BOOST_CONTAINER_STABLE_VECTOR_CHECK_INVARIANT; cod.release(); } } //! <b>Effects</b>: Destroys the stable_vector. All stored values are destroyed //! and used memory is deallocated. //! //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Linear to the number of elements. ~stable_vector() { this->clear(); this->priv_clear_pool(); } //! <b>Effects</b>: Makes *this contain the same elements as x. //! //! <b>Postcondition</b>: this->size() == x.size(). *this contains a copy //! of each of x's elements. //! //! <b>Throws</b>: If memory allocation throws or T's copy constructor throws. //! //! <b>Complexity</b>: Linear to the number of elements in x. stable_vector& operator=(BOOST_COPY_ASSIGN_REF(stable_vector) x) { BOOST_CONTAINER_STABLE_VECTOR_CHECK_INVARIANT; if (BOOST_LIKELY(this != &x)) { node_allocator_type &this_alloc = this->priv_node_alloc(); const node_allocator_type &x_alloc = x.priv_node_alloc(); dtl::bool_<allocator_traits_type:: propagate_on_container_copy_assignment::value> flag; if(flag && this_alloc != x_alloc){ this->clear(); this->shrink_to_fit(); } dtl::assign_alloc(this->priv_node_alloc(), x.priv_node_alloc(), flag); dtl::assign_alloc(this->index.get_stored_allocator(), x.index.get_stored_allocator(), flag); this->assign(x.begin(), x.end()); } return *this; } //! <b>Effects</b>: Move assignment. All x's values are transferred to *this. //! //! <b>Postcondition</b>: x.empty(). *this contains a the elements x had //! before the function. //! //! <b>Throws</b>: If allocator_traits_type::propagate_on_container_move_assignment //! is false and (allocation throws or T's move constructor throws) //! //! <b>Complexity</b>: Constant if allocator_traits_type:: //! propagate_on_container_move_assignment is true or //! this->get>allocator() == x.get_allocator(). Linear otherwise. stable_vector& operator=(BOOST_RV_REF(stable_vector) x) BOOST_NOEXCEPT_IF(allocator_traits_type::propagate_on_container_move_assignment::value || allocator_traits_type::is_always_equal::value) { if (BOOST_LIKELY(this != &x)) { //We know resources can be transferred at comiple time if both allocators are //always equal or the allocator is going to be propagated const bool can_steal_resources_alloc = allocator_traits_type::propagate_on_container_move_assignment::value || allocator_traits_type::is_always_equal::value; dtl::bool_<can_steal_resources_alloc> flag; this->priv_move_assign(boost::move(x), flag); } return *this; } #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST) //! <b>Effects</b>: Make *this container contains elements from il. //! //! <b>Complexity</b>: Linear to the range [il.begin(), il.end()). stable_vector& operator=(std::initializer_list<value_type> il) { BOOST_CONTAINER_STABLE_VECTOR_CHECK_INVARIANT; assign(il.begin(), il.end()); return *this; } #endif //! <b>Effects</b>: Assigns the n copies of val to *this. //! //! <b>Throws</b>: If memory allocation throws or T's copy constructor throws. //! //! <b>Complexity</b>: Linear to n. inline void assign(size_type n, const T& t) { typedef constant_iterator<value_type> cvalue_iterator; this->assign(cvalue_iterator(t, n), cvalue_iterator()); } //! <b>Effects</b>: Assigns the the range [first, last) to *this. //! //! <b>Throws</b>: If memory allocation throws or //! T's constructor from dereferencing InpIt throws. //! //! <b>Complexity</b>: Linear to n. template<typename InputIterator> #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED) typename dtl::disable_if_convertible<InputIterator, size_type>::type #else void #endif assign(InputIterator first,InputIterator last) { BOOST_CONTAINER_STABLE_VECTOR_CHECK_INVARIANT; iterator first1 = this->begin(); iterator last1 = this->end(); for ( ; first1 != last1 && first != last; ++first1, ++first) *first1 = *first; if (first == last){ this->erase(first1, last1); } else{ this->insert(last1, first, last); } } #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST) //! <b>Effects</b>: Assigns the the range [il.begin(), il.end()) to *this. //! //! <b>Throws</b>: If memory allocation throws or //! T's constructor from dereferencing initializer_list iterator throws. //! inline void assign(std::initializer_list<value_type> il) { BOOST_CONTAINER_STABLE_VECTOR_CHECK_INVARIANT; assign(il.begin(), il.end()); } #endif //! <b>Effects</b>: Returns a copy of the internal allocator. //! //! <b>Throws</b>: If allocator's copy constructor throws. //! //! <b>Complexity</b>: Constant. BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline allocator_type get_allocator() const { return this->priv_node_alloc(); } //! <b>Effects</b>: Returns a reference to the internal allocator. //! //! <b>Throws</b>: Nothing //! //! <b>Complexity</b>: Constant. //! //! <b>Note</b>: Non-standard extension. BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline const stored_allocator_type &get_stored_allocator() const BOOST_NOEXCEPT_OR_NOTHROW { return this->priv_node_alloc(); } //! <b>Effects</b>: Returns a reference to the internal allocator. //! //! <b>Throws</b>: Nothing //! //! <b>Complexity</b>: Constant. //! //! <b>Note</b>: Non-standard extension. BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline stored_allocator_type &get_stored_allocator() BOOST_NOEXCEPT_OR_NOTHROW { return this->priv_node_alloc(); } ////////////////////////////////////////////// // // iterators // ////////////////////////////////////////////// //! <b>Effects</b>: Returns an iterator to the first element contained in the stable_vector. //! //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Constant. BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline iterator begin() BOOST_NOEXCEPT_OR_NOTHROW { return (this->index.empty()) ? this->end(): iterator(node_ptr_traits::static_cast_from(this->index.front())); } //! <b>Effects</b>: Returns a const_iterator to the first element contained in the stable_vector. //! //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Constant. BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline const_iterator begin() const BOOST_NOEXCEPT_OR_NOTHROW { return (this->index.empty()) ? this->cend() : const_iterator(node_ptr_traits::static_cast_from(this->index.front())) ; } //! <b>Effects</b>: Returns an iterator to the end of the stable_vector. //! //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Constant. BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline iterator end() BOOST_NOEXCEPT_OR_NOTHROW { return iterator(this->priv_get_end_node()); } //! <b>Effects</b>: Returns a const_iterator to the end of the stable_vector. //! //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Constant. BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline const_iterator end() const BOOST_NOEXCEPT_OR_NOTHROW { return const_iterator(this->priv_get_end_node()); } //! <b>Effects</b>: Returns a reverse_iterator pointing to the beginning //! of the reversed stable_vector. //! //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Constant. BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline reverse_iterator rbegin() BOOST_NOEXCEPT_OR_NOTHROW { return reverse_iterator(this->end()); } //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning //! of the reversed stable_vector. //! //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Constant. BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline const_reverse_iterator rbegin() const BOOST_NOEXCEPT_OR_NOTHROW { return const_reverse_iterator(this->end()); } //! <b>Effects</b>: Returns a reverse_iterator pointing to the end //! of the reversed stable_vector. //! //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Constant. BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline reverse_iterator rend() BOOST_NOEXCEPT_OR_NOTHROW { return reverse_iterator(this->begin()); } //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the end //! of the reversed stable_vector. //! //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Constant. BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline const_reverse_iterator rend() const BOOST_NOEXCEPT_OR_NOTHROW { return const_reverse_iterator(this->begin()); } //! <b>Effects</b>: Returns a const_iterator to the first element contained in the stable_vector. //! //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Constant. BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline const_iterator cbegin() const BOOST_NOEXCEPT_OR_NOTHROW { return this->begin(); } //! <b>Effects</b>: Returns a const_iterator to the end of the stable_vector. //! //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Constant. BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline const_iterator cend() const BOOST_NOEXCEPT_OR_NOTHROW { return this->end(); } //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning //! of the reversed stable_vector. //! //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Constant. BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline const_reverse_iterator crbegin() const BOOST_NOEXCEPT_OR_NOTHROW { return this->rbegin(); } //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the end //! of the reversed stable_vector. //! //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Constant. BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline const_reverse_iterator crend()const BOOST_NOEXCEPT_OR_NOTHROW { return this->rend(); } ////////////////////////////////////////////// // // capacity // ////////////////////////////////////////////// //! <b>Effects</b>: Returns true if the stable_vector contains no elements. //! //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Constant. BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline bool empty() const BOOST_NOEXCEPT_OR_NOTHROW { return this->index.size() <= ExtraPointers; } //! <b>Effects</b>: Returns the number of the elements contained in the stable_vector. //! //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Constant. BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline size_type size() const BOOST_NOEXCEPT_OR_NOTHROW { const size_type index_size = this->index.size(); return (index_size - ExtraPointers) & (size_type(0u) -size_type(index_size != 0)); } //! <b>Effects</b>: Returns the largest possible size of the stable_vector. //! //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Constant. BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline size_type max_size() const BOOST_NOEXCEPT_OR_NOTHROW { return this->index.max_size() - ExtraPointers; } //! <b>Effects</b>: Inserts or erases elements at the end such that //! the size becomes n. New elements are value initialized. //! //! <b>Throws</b>: If memory allocation throws, or T's value initialization throws. //! //! <b>Complexity</b>: Linear to the difference between size() and new_size. void resize(size_type n) { typedef value_init_construct_iterator<value_type> value_init_iterator; BOOST_CONTAINER_STABLE_VECTOR_CHECK_INVARIANT; if(n > this->size()) this->insert( this->cend() , value_init_iterator(n - this->size()), value_init_iterator()); else if(n < this->size()) this->erase(this->cbegin() + difference_type(n), this->cend()); } //! <b>Effects</b>: Inserts or erases elements at the end such that //! the size becomes n. New elements are default initialized. //! //! <b>Throws</b>: If memory allocation throws, or T's default initialization throws. //! //! <b>Complexity</b>: Linear to the difference between size() and new_size. //! //! <b>Note</b>: Non-standard extension void resize(size_type n, default_init_t) { typedef default_init_construct_iterator<value_type> default_init_iterator; BOOST_CONTAINER_STABLE_VECTOR_CHECK_INVARIANT; if(n > this->size()) this->insert(this->cend(), default_init_iterator(n - this->size()), default_init_iterator()); else if(n < this->size()) this->erase(this->cbegin() + difference_type(n), this->cend()); } //! <b>Effects</b>: Inserts or erases elements at the end such that //! the size becomes n. New elements are copy constructed from x. //! //! <b>Throws</b>: If memory allocation throws, or T's copy constructor throws. //! //! <b>Complexity</b>: Linear to the difference between size() and new_size. void resize(size_type n, const T& t) { BOOST_CONTAINER_STABLE_VECTOR_CHECK_INVARIANT; if(n > this->size()) this->insert(this->cend(), n - this->size(), t); else if(n < this->size()) this->erase(this->cbegin() + difference_type(n), this->cend()); } //! <b>Effects</b>: Number of elements for which memory has been allocated. //! capacity() is always greater than or equal to size(). //! //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Constant. BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline size_type capacity() const BOOST_NOEXCEPT_OR_NOTHROW { const size_type index_size = this->index.size(); BOOST_ASSERT(!index_size || index_size >= ExtraPointers); const size_type node_extra_capacity = this->internal_data.pool_size; //Pool count must be less than index capacity, as index is a vector BOOST_ASSERT(node_extra_capacity <= (this->index.capacity()- index_size)); const size_type index_offset = (node_extra_capacity - ExtraPointers) & (size_type(0u) - size_type(index_size != 0)); return index_size + index_offset; } //! <b>Effects</b>: If n is less than or equal to capacity(), this call has no //! effect. Otherwise, it is a request for allocation of additional memory. //! If the request is successful, then capacity() is greater than or equal to //! n; otherwise, capacity() is unchanged. In either case, size() is unchanged. //! //! <b>Throws</b>: If memory allocation allocation throws. void reserve(size_type n) { BOOST_CONTAINER_STABLE_VECTOR_CHECK_INVARIANT; if(n > this->max_size()){ throw_length_error("stable_vector::reserve max_size() exceeded"); } size_type sz = this->size(); size_type old_capacity = this->capacity(); if(n > old_capacity){ index_traits_type::initialize_end_node(this->index, this->internal_data.end_node, n); const void * old_ptr = &index[0]; this->index.reserve(n + ExtraPointers); bool realloced = &index[0] != old_ptr; //Fix the pointers for the newly allocated buffer if(realloced){ index_traits_type::fix_up_pointers_from(this->index, this->index.begin()); } //Now fill pool if data is not enough if((n - sz) > this->internal_data.pool_size){ this->priv_increase_pool((n - sz) - this->internal_data.pool_size); } } } //! <b>Effects</b>: Tries to deallocate the excess of memory created //! with previous allocations. The size of the stable_vector is unchanged //! //! <b>Throws</b>: If memory allocation throws. //! //! <b>Complexity</b>: Linear to size(). void shrink_to_fit() { if(this->capacity()){ //First empty allocated node pool this->priv_clear_pool(); //If empty completely destroy the index, let's recover default-constructed state if(this->empty()){ this->index.clear(); this->index.shrink_to_fit(); this->internal_data.end_node.up = node_base_ptr_ptr(); } //Otherwise, try to shrink-to-fit the index and readjust pointers if necessary else{ const void* old_ptr = &index[0]; this->index.shrink_to_fit(); bool realloced = &index[0] != old_ptr; //Fix the pointers for the newly allocated buffer if(realloced){ index_traits_type::fix_up_pointers_from(this->index, this->index.begin()); } } } } ////////////////////////////////////////////// // // element access // ////////////////////////////////////////////// //! <b>Requires</b>: !empty() //! //! <b>Effects</b>: Returns a reference to the first //! element of the container. //! //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Constant. BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline reference front() BOOST_NOEXCEPT_OR_NOTHROW { BOOST_ASSERT(!this->empty()); return static_cast<node_reference>(*this->index.front()).get_data(); } //! <b>Requires</b>: !empty() //! //! <b>Effects</b>: Returns a const reference to the first //! element of the container. //! //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Constant. BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline const_reference front() const BOOST_NOEXCEPT_OR_NOTHROW { BOOST_ASSERT(!this->empty()); return static_cast<const_node_reference>(*this->index.front()).get_data(); } //! <b>Requires</b>: !empty() //! //! <b>Effects</b>: Returns a reference to the last //! element of the container. //! //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Constant. BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline reference back() BOOST_NOEXCEPT_OR_NOTHROW { BOOST_ASSERT(!this->empty()); return static_cast<node_reference>(*this->index[this->size()-1u]).get_data(); } //! <b>Requires</b>: !empty() //! //! <b>Effects</b>: Returns a const reference to the last //! element of the container. //! //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Constant. BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline const_reference back() const BOOST_NOEXCEPT_OR_NOTHROW { BOOST_ASSERT(!this->empty()); return static_cast<const_node_reference>(*this->index[this->size()-1u]).get_data(); } //! <b>Requires</b>: size() > n. //! //! <b>Effects</b>: Returns a reference to the nth element //! from the beginning of the container. //! //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Constant. BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline reference operator[](size_type n) BOOST_NOEXCEPT_OR_NOTHROW { BOOST_ASSERT(this->size() > n); return static_cast<node_reference>(*this->index[n]).get_data(); } //! <b>Requires</b>: size() > n. //! //! <b>Effects</b>: Returns a const reference to the nth element //! from the beginning of the container. //! //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Constant. BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline const_reference operator[](size_type n) const BOOST_NOEXCEPT_OR_NOTHROW { BOOST_ASSERT(this->size() > n); return static_cast<const_node_reference>(*this->index[n]).get_data(); } //! <b>Requires</b>: size() >= n. //! //! <b>Effects</b>: Returns an iterator to the nth element //! from the beginning of the container. Returns end() //! if n == size(). //! //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Constant. //! //! <b>Note</b>: Non-standard extension BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline iterator nth(size_type n) BOOST_NOEXCEPT_OR_NOTHROW { BOOST_ASSERT(this->size() >= n); return (this->index.empty()) ? this->end() : iterator(node_ptr_traits::static_cast_from(this->index[n])); } //! <b>Requires</b>: size() >= n. //! //! <b>Effects</b>: Returns a const_iterator to the nth element //! from the beginning of the container. Returns end() //! if n == size(). //! //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Constant. //! //! <b>Note</b>: Non-standard extension BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline const_iterator nth(size_type n) const BOOST_NOEXCEPT_OR_NOTHROW { BOOST_ASSERT(this->size() >= n); return (this->index.empty()) ? this->cend() : iterator(node_ptr_traits::static_cast_from(this->index[n])); } //! <b>Requires</b>: begin() <= p <= end(). //! //! <b>Effects</b>: Returns the index of the element pointed by p //! and size() if p == end(). //! //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Constant. //! //! <b>Note</b>: Non-standard extension BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline size_type index_of(iterator p) BOOST_NOEXCEPT_OR_NOTHROW { return this->priv_index_of(p.node_pointer()); } //! <b>Requires</b>: begin() <= p <= end(). //! //! <b>Effects</b>: Returns the index of the element pointed by p //! and size() if p == end(). //! //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Constant. //! //! <b>Note</b>: Non-standard extension BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline size_type index_of(const_iterator p) const BOOST_NOEXCEPT_OR_NOTHROW { return this->priv_index_of(p.node_pointer()); } //! <b>Requires</b>: size() > n. //! //! <b>Effects</b>: Returns a reference to the nth element //! from the beginning of the container. //! //! <b>Throws</b>: range_error if n >= size() //! //! <b>Complexity</b>: Constant. BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline reference at(size_type n) { if(n >= this->size()){ throw_out_of_range("vector::at invalid subscript"); } return operator[](n); } //! <b>Requires</b>: size() > n. //! //! <b>Effects</b>: Returns a const reference to the nth element //! from the beginning of the container. //! //! <b>Throws</b>: range_error if n >= size() //! //! <b>Complexity</b>: Constant. BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline const_reference at(size_type n)const { if(n >= this->size()){ throw_out_of_range("vector::at invalid subscript"); } return operator[](n); } ////////////////////////////////////////////// // // modifiers // ////////////////////////////////////////////// #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) || defined(BOOST_CONTAINER_DOXYGEN_INVOKED) //! <b>Effects</b>: Inserts an object of type T constructed with //! std::forward<Args>(args)... in the end of the stable_vector. //! //! <b>Returns</b>: A reference to the created object. //! //! <b>Throws</b>: If memory allocation throws or the in-place constructor throws. //! //! <b>Complexity</b>: Amortized constant time. template<class ...Args> reference emplace_back(Args &&...args) { typedef emplace_functor<Args...> EmplaceFunctor; typedef emplace_iterator<value_type, EmplaceFunctor> EmplaceIterator; EmplaceFunctor &&ef = EmplaceFunctor(boost::forward<Args>(args)...); return *this->insert(this->cend(), EmplaceIterator(ef), EmplaceIterator()); } //! <b>Requires</b>: p must be a valid iterator of *this. //! //! <b>Effects</b>: Inserts an object of type T constructed with //! std::forward<Args>(args)... before p //! //! <b>Throws</b>: If memory allocation throws or the in-place constructor throws. //! //! <b>Complexity</b>: If p is end(), amortized constant time //! Linear time otherwise. template<class ...Args> iterator emplace(const_iterator p, Args && ...args) { BOOST_ASSERT(this->priv_in_range_or_end(p)); difference_type pos_n = p - cbegin(); typedef emplace_functor<Args...> EmplaceFunctor; typedef emplace_iterator<value_type, EmplaceFunctor> EmplaceIterator; EmplaceFunctor &&ef = EmplaceFunctor(boost::forward<Args>(args)...); this->insert(p, EmplaceIterator(ef), EmplaceIterator()); return iterator(this->begin() + pos_n); } #else #define BOOST_CONTAINER_STABLE_VECTOR_EMPLACE_CODE(N) \ BOOST_MOVE_TMPL_LT##N BOOST_MOVE_CLASS##N BOOST_MOVE_GT##N \ reference emplace_back(BOOST_MOVE_UREF##N)\ {\ typedef emplace_functor##N\ BOOST_MOVE_LT##N BOOST_MOVE_TARG##N BOOST_MOVE_GT##N EmplaceFunctor;\ typedef emplace_iterator<value_type, EmplaceFunctor> EmplaceIterator;\ EmplaceFunctor ef BOOST_MOVE_LP##N BOOST_MOVE_FWD##N BOOST_MOVE_RP##N;\ return *this->insert(this->cend() , EmplaceIterator(ef), EmplaceIterator());\ }\ \ BOOST_MOVE_TMPL_LT##N BOOST_MOVE_CLASS##N BOOST_MOVE_GT##N \ iterator emplace(const_iterator p BOOST_MOVE_I##N BOOST_MOVE_UREF##N)\ {\ BOOST_ASSERT(this->priv_in_range_or_end(p));\ typedef emplace_functor##N\ BOOST_MOVE_LT##N BOOST_MOVE_TARG##N BOOST_MOVE_GT##N EmplaceFunctor;\ typedef emplace_iterator<value_type, EmplaceFunctor> EmplaceIterator;\ EmplaceFunctor ef BOOST_MOVE_LP##N BOOST_MOVE_FWD##N BOOST_MOVE_RP##N;\ const size_type pos_n = size_type(p - this->cbegin());\ this->insert(p, EmplaceIterator(ef), EmplaceIterator());\ return this->begin() += difference_type(pos_n);\ }\ // BOOST_MOVE_ITERATE_0TO9(BOOST_CONTAINER_STABLE_VECTOR_EMPLACE_CODE) #undef BOOST_CONTAINER_STABLE_VECTOR_EMPLACE_CODE #endif // !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) #if defined(BOOST_CONTAINER_DOXYGEN_INVOKED) //! <b>Effects</b>: Inserts a copy of x at the end of the stable_vector. //! //! <b>Throws</b>: If memory allocation throws or //! T's copy constructor throws. //! //! <b>Complexity</b>: Amortized constant time. void push_back(const T &x); //! <b>Effects</b>: Constructs a new element in the end of the stable_vector //! and moves the resources of x to this new element. //! //! <b>Throws</b>: If memory allocation throws. //! //! <b>Complexity</b>: Amortized constant time. void push_back(T &&x); #else BOOST_MOVE_CONVERSION_AWARE_CATCH(push_back, T, void, priv_push_back) #endif #if defined(BOOST_CONTAINER_DOXYGEN_INVOKED) //! <b>Requires</b>: p must be a valid iterator of *this. //! //! <b>Effects</b>: Insert a copy of x before p. //! //! <b>Returns</b>: An iterator to the inserted element. //! //! <b>Throws</b>: If memory allocation throws or x's copy constructor throws. //! //! <b>Complexity</b>: If p is end(), amortized constant time //! Linear time otherwise. iterator insert(const_iterator p, const T &x); //! <b>Requires</b>: p must be a valid iterator of *this. //! //! <b>Effects</b>: Insert a new element before p with x's resources. //! //! <b>Returns</b>: an iterator to the inserted element. //! //! <b>Throws</b>: If memory allocation throws. //! //! <b>Complexity</b>: If p is end(), amortized constant time //! Linear time otherwise. iterator insert(const_iterator p, T &&x); #else BOOST_MOVE_CONVERSION_AWARE_CATCH_1ARG(insert, T, iterator, priv_insert, const_iterator, const_iterator) #endif //! <b>Requires</b>: p must be a valid iterator of *this. //! //! <b>Effects</b>: Insert n copies of x before p. //! //! <b>Returns</b>: an iterator to the first inserted element or p if n is 0. //! //! <b>Throws</b>: If memory allocation throws or T's copy constructor throws. //! //! <b>Complexity</b>: Linear to n. iterator insert(const_iterator p, size_type n, const T& t) { BOOST_ASSERT(this->priv_in_range_or_end(p)); BOOST_CONTAINER_STABLE_VECTOR_CHECK_INVARIANT; typedef constant_iterator<value_type> cvalue_iterator; return this->insert(p, cvalue_iterator(t, n), cvalue_iterator()); } //! <b>Requires</b>: p must be a valid iterator of *this. #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST) //! <b>Requires</b>: p must be a valid iterator of *this. //! //! <b>Effects</b>: Insert a copy of the [il.begin(), il.end()) range before p. //! //! <b>Returns</b>: an iterator to the first inserted element or p if first == last. //! //! <b>Complexity</b>: Linear to distance [il.begin(), il.end()). inline iterator insert(const_iterator p, std::initializer_list<value_type> il) { //Position checks done by insert() BOOST_CONTAINER_STABLE_VECTOR_CHECK_INVARIANT; return insert(p, il.begin(), il.end()); } #endif //! <b>Requires</b>: pos must be a valid iterator of *this. //! //! <b>Effects</b>: Insert a copy of the [first, last) range before p. //! //! <b>Returns</b>: an iterator to the first inserted element or p if first == last. //! //! <b>Throws</b>: If memory allocation throws, T's constructor from a //! dereferenced InpIt throws or T's copy constructor throws. //! //! <b>Complexity</b>: Linear to distance [first, last). template <class InputIterator> iterator insert(const_iterator p, InputIterator first, InputIterator last #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED) //Put this as argument instead of the return type as old GCC's like 3.4 //detect this and the next disable_if_or as overloads , typename dtl::disable_if_or < void , dtl::is_convertible<InputIterator, size_type> , dtl::is_not_input_iterator<InputIterator> >::type* = 0 #endif ) { BOOST_ASSERT(this->priv_in_range_or_end(p)); BOOST_CONTAINER_STABLE_VECTOR_CHECK_INVARIANT; const difference_type pos_n = p - this->cbegin(); for(; first != last; ++first){ this->emplace(p, *first); } return this->begin() + difference_type(pos_n); } #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED) template <class FwdIt> typename dtl::disable_if_or < iterator , dtl::is_convertible<FwdIt, size_type> , dtl::is_input_iterator<FwdIt> >::type insert(const_iterator p, FwdIt first, FwdIt last) { BOOST_ASSERT(this->priv_in_range_or_end(p)); const size_type num_new = boost::container::iterator_udistance(first, last); const size_type idx = static_cast<size_type>(p - this->cbegin()); if(num_new){ //Fills the node pool and inserts num_new null pointers in idx. //If a new buffer was needed fixes up pointers up to idx so //past-new nodes are not aligned until the end of this function //or in a rollback in case of exception index_iterator it_past_newly_constructed(this->priv_insert_forward_non_templated(idx, num_new)); const index_iterator it_past_new(it_past_newly_constructed + difference_type(num_new)); { //Prepare rollback insert_rollback rollback(*this, it_past_newly_constructed, it_past_new); while(first != last){ const node_ptr n = this->priv_get_from_pool(); BOOST_ASSERT(!!n); //Put it in the index so rollback can return it in pool if construct_in_place throws *it_past_newly_constructed = n; //Constructs and fixes up pointers This can throw this->priv_build_node_from_it(n, it_past_newly_constructed, first); ++first; ++it_past_newly_constructed; } //rollback.~insert_rollback() called in case of exception } //Fix up pointers for past-new nodes (new nodes were fixed during construction) and //nodes before insertion p in priv_insert_forward_non_templated(...) index_traits_type::fix_up_pointers_from(this->index, it_past_newly_constructed); } return this->begin() + static_cast<difference_type>(idx); } #endif //! <b>Effects</b>: Removes the last element from the stable_vector. //! //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Constant time. inline void pop_back() BOOST_NOEXCEPT_OR_NOTHROW { BOOST_ASSERT(!this->empty()); this->erase(--this->cend()); } //! <b>Effects</b>: Erases the element at p. //! //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Linear to the elements between p and the //! last element. Constant if p is the last element. inline iterator erase(const_iterator p) BOOST_NOEXCEPT_OR_NOTHROW { BOOST_ASSERT(this->priv_in_range(p)); BOOST_CONTAINER_STABLE_VECTOR_CHECK_INVARIANT; const difference_type d = p - this->cbegin(); index_iterator it = this->index.begin() + d; this->priv_delete_node(p.node_pointer()); it = this->index.erase(it); index_traits_type::fix_up_pointers_from(this->index, it); return iterator(node_ptr_traits::static_cast_from(*it)); } //! <b>Effects</b>: Erases the elements pointed by [first, last). //! //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Linear to the distance between first and last //! plus linear to the elements between p and the last element. iterator erase(const_iterator first, const_iterator last) BOOST_NOEXCEPT_OR_NOTHROW { BOOST_ASSERT(first == last || (first < last && this->priv_in_range(first) && this->priv_in_range_or_end(last))); BOOST_CONTAINER_STABLE_VECTOR_CHECK_INVARIANT; const const_iterator cbeg(this->cbegin()); const size_type d1 = static_cast<size_type>(first - cbeg), d2 = static_cast<size_type>(last - cbeg); size_type d_dif = d2 - d1; if(d_dif){ multiallocation_chain holder; const index_iterator it1(this->index.begin() + difference_type(d1)); const index_iterator it2(it1 + difference_type(d_dif)); index_iterator it(it1); while(d_dif){ --d_dif; node_base_ptr &nb = *it; ++it; node_type &n = *node_ptr_traits::static_cast_from(nb); this->priv_destroy_node(n); holder.push_back(node_ptr_traits::pointer_to(n)); } this->priv_put_in_pool(holder); const index_iterator e = this->index.erase(it1, it2); index_traits_type::fix_up_pointers_from(this->index, e); } return iterator(last.node_pointer()); } //! <b>Effects</b>: Swaps the contents of *this and x. //! //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Constant. void swap(stable_vector & x) BOOST_NOEXCEPT_IF( allocator_traits_type::propagate_on_container_swap::value || allocator_traits_type::is_always_equal::value) { BOOST_ASSERT(allocator_traits_type::propagate_on_container_swap::value || allocator_traits_type::is_always_equal::value || this->get_stored_allocator() == x.get_stored_allocator()); BOOST_CONTAINER_STABLE_VECTOR_CHECK_INVARIANT; dtl::bool_<allocator_traits_type::propagate_on_container_swap::value> flag; dtl::swap_alloc(this->priv_node_alloc(), x.priv_node_alloc(), flag); //vector's allocator is swapped here this->index.swap(x.index); this->priv_swap_members(x); } //! <b>Effects</b>: Erases all the elements of the stable_vector. //! //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Linear to the number of elements in the stable_vector. inline void clear() BOOST_NOEXCEPT_OR_NOTHROW { this->erase(this->cbegin(),this->cend()); } //! <b>Effects</b>: Returns true if x and y are equal //! //! <b>Complexity</b>: Linear to the number of elements in the container. BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline friend bool operator==(const stable_vector& x, const stable_vector& y) { return x.size() == y.size() && ::boost::container::algo_equal(x.begin(), x.end(), y.begin()); } //! <b>Effects</b>: Returns true if x and y are unequal //! //! <b>Complexity</b>: Linear to the number of elements in the container. BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline friend bool operator!=(const stable_vector& x, const stable_vector& y) { return !(x == y); } //! <b>Effects</b>: Returns true if x is less than y //! //! <b>Complexity</b>: Linear to the number of elements in the container. BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline friend bool operator<(const stable_vector& x, const stable_vector& y) { return ::boost::container::algo_lexicographical_compare(x.begin(), x.end(), y.begin(), y.end()); } //! <b>Effects</b>: Returns true if x is greater than y //! //! <b>Complexity</b>: Linear to the number of elements in the container. BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline friend bool operator>(const stable_vector& x, const stable_vector& y) { return y < x; } //! <b>Effects</b>: Returns true if x is equal or less than y //! //! <b>Complexity</b>: Linear to the number of elements in the container. BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline friend bool operator<=(const stable_vector& x, const stable_vector& y) { return !(y < x); } //! <b>Effects</b>: Returns true if x is equal or greater than y //! //! <b>Complexity</b>: Linear to the number of elements in the container. BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline friend bool operator>=(const stable_vector& x, const stable_vector& y) { return !(x < y); } //! <b>Effects</b>: x.swap(y) //! //! <b>Complexity</b>: Constant. inline friend void swap(stable_vector& x, stable_vector& y) BOOST_NOEXCEPT_IF(BOOST_NOEXCEPT(x.swap(y))) { x.swap(y); } #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED private: void priv_move_assign(BOOST_RV_REF(stable_vector) x, dtl::bool_<true> /*steal_resources*/) { //Resources can be transferred if both allocators are //going to be equal after this function (either propagated or already equal) BOOST_CONTAINER_STABLE_VECTOR_CHECK_INVARIANT //Destroy objects but retain memory in case x reuses it in the future this->clear(); //Move allocator if needed dtl::bool_<allocator_traits_type:: propagate_on_container_move_assignment::value> flag; dtl::move_alloc(this->priv_node_alloc(), x.priv_node_alloc(), flag); //Take resources this->index = boost::move(x.index); //this also moves the vector's allocator if needed this->priv_swap_members(x); } void priv_move_assign(BOOST_RV_REF(stable_vector) x, dtl::bool_<false> /*steal_resources*/) { //We can't guarantee a compile-time equal allocator or propagation so fallback to runtime //Resources can be transferred if both allocators are equal if (this->priv_node_alloc() == x.priv_node_alloc()) { this->priv_move_assign(boost::move(x), dtl::true_()); } else { this->assign(boost::make_move_iterator(x.begin()), boost::make_move_iterator(x.end())); } } bool priv_in_range(const_iterator pos) const { return (this->begin() <= pos) && (pos < this->end()); } inline bool priv_in_range_or_end(const_iterator pos) const { return (this->begin() <= pos) && (pos <= this->end()); } inline size_type priv_index_of(node_ptr p) const { //Check range BOOST_ASSERT(this->index.empty() || (this->index.data() <= p->up)); BOOST_ASSERT(this->index.empty() || p->up <= (this->index.data() + this->index.size())); return this->index.empty() ? 0u : size_type(p->up - this->index.data()); } class insert_rollback { public: insert_rollback(stable_vector &sv, index_iterator &it_past_constructed, const index_iterator &it_past_new) : m_sv(sv), m_it_past_constructed(it_past_constructed), m_it_past_new(it_past_new) {} ~insert_rollback() { if(m_it_past_constructed != m_it_past_new){ m_sv.priv_put_in_pool(node_ptr_traits::static_cast_from(*m_it_past_constructed)); index_iterator e = m_sv.index.erase(m_it_past_constructed, m_it_past_new); index_traits_type::fix_up_pointers_from(m_sv.index, e); } } private: stable_vector &m_sv; index_iterator &m_it_past_constructed; const index_iterator &m_it_past_new; }; class push_back_rollback { public: inline push_back_rollback(stable_vector &sv, const node_ptr &p) : m_sv(sv), m_p(p) {} inline ~push_back_rollback() { if(m_p){ m_sv.priv_put_in_pool(m_p); } } inline void release() { m_p = node_ptr(); } private: stable_vector &m_sv; node_ptr m_p; }; index_iterator priv_insert_forward_non_templated(size_type idx, size_type num_new) { index_traits_type::initialize_end_node(this->index, this->internal_data.end_node, num_new); //Now try to fill the pool with new data if(this->internal_data.pool_size < num_new){ this->priv_increase_pool(num_new - this->internal_data.pool_size); } //Now try to make room in the vector const node_base_ptr_ptr old_buffer = this->index.data(); this->index.insert(this->index.begin() + (difference_type)idx, num_new, node_ptr()); bool new_buffer = this->index.data() != old_buffer; //Fix the pointers for the newly allocated buffer const index_iterator index_beg = this->index.begin(); if(new_buffer){ index_traits_type::fix_up_pointers(index_beg, index_beg + (difference_type)idx); } return index_beg + (difference_type)idx; } inline bool priv_capacity_bigger_than_size() const { return this->index.capacity() > this->index.size() && this->internal_data.pool_size > 0; } template <class U> void priv_push_back(BOOST_MOVE_CATCH_FWD(U) x) { if(BOOST_LIKELY(this->priv_capacity_bigger_than_size())){ //Enough memory in the pool and in the index const node_ptr p = this->priv_get_from_pool(); BOOST_ASSERT(!!p); { push_back_rollback rollback(*this, p); //This might throw this->priv_build_node_from_convertible(p, ::boost::forward<U>(x)); rollback.release(); } //This can't throw as there is room for a new elements in the index index_iterator new_index = this->index.insert(this->index.end() - ExtraPointers, p); index_traits_type::fix_up_pointers_from(this->index, new_index); } else{ this->insert(this->cend(), ::boost::forward<U>(x)); } } iterator priv_insert(const_iterator p, const value_type &t) { BOOST_ASSERT(this->priv_in_range_or_end(p)); typedef constant_iterator<value_type> cvalue_iterator; return this->insert(p, cvalue_iterator(t, 1), cvalue_iterator()); } iterator priv_insert(const_iterator p, BOOST_RV_REF(T) x) { BOOST_ASSERT(this->priv_in_range_or_end(p)); typedef repeat_iterator<T> repeat_it; typedef boost::move_iterator<repeat_it> repeat_move_it; //Just call more general insert(p, size, value) and return iterator return this->insert(p, repeat_move_it(repeat_it(x, 1)), repeat_move_it(repeat_it())); } void priv_clear_pool() { if(!this->index.empty() && this->index.back()){ node_base_ptr &pool_first_ref = *(this->index.end() - 2); node_base_ptr &pool_last_ref = this->index.back(); multiallocation_chain holder; holder.incorporate_after( holder.before_begin() , node_ptr_traits::static_cast_from(pool_first_ref) , node_ptr_traits::static_cast_from(pool_last_ref) , internal_data.pool_size); this->deallocate_individual(holder); pool_first_ref = pool_last_ref = 0; this->internal_data.pool_size = 0; } } void priv_increase_pool(size_type n) { node_base_ptr &pool_first_ref = *(this->index.end() - 2); node_base_ptr &pool_last_ref = this->index.back(); multiallocation_chain holder; holder.incorporate_after( holder.before_begin() , node_ptr_traits::static_cast_from(pool_first_ref) , node_ptr_traits::static_cast_from(pool_last_ref) , internal_data.pool_size); multiallocation_chain m; this->allocate_individual(n, m); holder.splice_after(holder.before_begin(), m, m.before_begin(), m.last(), n); this->internal_data.pool_size += n; typename multiallocation_chain::pointer_pair data(holder.extract_data()); pool_first_ref = data.first; pool_last_ref = data.second; } void priv_put_in_pool(const node_ptr &p) { node_base_ptr &pool_first_ref = *(this->index.end()-2); node_base_ptr &pool_last_ref = this->index.back(); multiallocation_chain holder; holder.incorporate_after( holder.before_begin() , node_ptr_traits::static_cast_from(pool_first_ref) , node_ptr_traits::static_cast_from(pool_last_ref) , internal_data.pool_size); holder.push_front(p); ++this->internal_data.pool_size; typename multiallocation_chain::pointer_pair ret(holder.extract_data()); pool_first_ref = ret.first; pool_last_ref = ret.second; } void priv_put_in_pool(multiallocation_chain &ch) { node_base_ptr &pool_first_ref = *(this->index.end()-(ExtraPointers-1)); node_base_ptr &pool_last_ref = this->index.back(); ch.incorporate_after( ch.before_begin() , node_ptr_traits::static_cast_from(pool_first_ref) , node_ptr_traits::static_cast_from(pool_last_ref) , internal_data.pool_size); this->internal_data.pool_size = ch.size(); const typename multiallocation_chain::pointer_pair ret(ch.extract_data()); pool_first_ref = ret.first; pool_last_ref = ret.second; } node_ptr priv_get_from_pool() { //Precondition: index is not empty BOOST_ASSERT(!this->index.empty()); node_base_ptr &pool_first_ref = *(this->index.end() - (ExtraPointers-1)); node_base_ptr &pool_last_ref = this->index.back(); multiallocation_chain holder; holder.incorporate_after( holder.before_begin() , node_ptr_traits::static_cast_from(pool_first_ref) , node_ptr_traits::static_cast_from(pool_last_ref) , internal_data.pool_size); node_ptr ret = holder.pop_front(); --this->internal_data.pool_size; if(!internal_data.pool_size){ pool_first_ref = pool_last_ref = node_ptr(); } else{ const typename multiallocation_chain::pointer_pair data(holder.extract_data()); pool_first_ref = data.first; pool_last_ref = data.second; } return ret; } inline node_base_ptr priv_get_end_node() const { return node_base_ptr_traits::pointer_to(const_cast<node_base_type&>(this->internal_data.end_node)); } inline void priv_destroy_node(const node_type &n) { allocator_traits<node_allocator_type>:: destroy(this->priv_node_alloc(), &n); } inline void priv_delete_node(const node_ptr &n) { this->priv_destroy_node(*n); this->priv_put_in_pool(n); } template<class Iterator> void priv_build_node_from_it(const node_ptr &p, const index_iterator &up_index, const Iterator &it) { node_type *praw = ::new(boost::movelib::iterator_to_raw_pointer(p), boost_container_new_t()) node_type(index_traits_type::ptr_to_node_base_ptr(*up_index)); BOOST_CONTAINER_TRY{ //This can throw boost::container::construct_in_place ( this->priv_node_alloc() , praw->get_data_ptr() , it); } BOOST_CONTAINER_CATCH(...) { praw->destroy_header(); this->priv_node_alloc().deallocate(p, 1); BOOST_CONTAINER_RETHROW } BOOST_CONTAINER_CATCH_END } template<class ValueConvertible> void priv_build_node_from_convertible(const node_ptr &p, BOOST_FWD_REF(ValueConvertible) value_convertible) { node_type *praw = ::new(boost::movelib::iterator_to_raw_pointer(p), boost_container_new_t()) node_type; BOOST_CONTAINER_TRY{ //This can throw boost::container::allocator_traits<node_allocator_type>::construct ( this->priv_node_alloc() , p->get_data_ptr() , ::boost::forward<ValueConvertible>(value_convertible)); } BOOST_CONTAINER_CATCH(...) { praw->destroy_header(); this->priv_node_alloc().deallocate(p, 1); BOOST_CONTAINER_RETHROW } BOOST_CONTAINER_CATCH_END } void priv_swap_members(stable_vector &x) { boost::adl_move_swap(this->internal_data.pool_size, x.internal_data.pool_size); index_traits_type::readjust_end_node(this->index, this->internal_data.end_node); index_traits_type::readjust_end_node(x.index, x.internal_data.end_node); } #if defined(STABLE_VECTOR_ENABLE_INVARIANT_CHECKING) bool priv_invariant()const { index_type & index_ref = const_cast<index_type&>(this->index); const size_type index_size = this->index.size(); if(!index_size) return !this->capacity() && !this->size(); if(index_size < ExtraPointers) return false; const size_type bucket_extra_capacity = this->index.capacity()- index_size; const size_type node_extra_capacity = this->internal_data.pool_size; if(bucket_extra_capacity < node_extra_capacity){ return false; } if(this->priv_get_end_node() != *(index.end() - ExtraPointers)){ return false; } if(!index_traits_type::invariants(index_ref)){ return false; } size_type n = this->capacity() - this->size(); node_base_ptr &pool_first_ref = *(index_ref.end() - (ExtraPointers-1)); node_base_ptr &pool_last_ref = index_ref.back(); multiallocation_chain holder; holder.incorporate_after( holder.before_begin() , node_ptr_traits::static_cast_from(pool_first_ref) , node_ptr_traits::static_cast_from(pool_last_ref) , internal_data.pool_size); typename multiallocation_chain::iterator beg(holder.begin()), end(holder.end()); size_type num_pool = 0; while(beg != end){ ++num_pool; ++beg; } return n >= num_pool && num_pool == internal_data.pool_size; } class invariant_checker { invariant_checker(const invariant_checker &); invariant_checker & operator=(const invariant_checker &); const stable_vector* p; public: invariant_checker(const stable_vector& v):p(&v){} ~invariant_checker(){BOOST_ASSERT(p->priv_invariant());} void touch(){} }; #endif class ebo_holder : public node_allocator_type { private: BOOST_MOVABLE_BUT_NOT_COPYABLE(ebo_holder) public: template<class AllocatorRLValue> explicit ebo_holder(BOOST_FWD_REF(AllocatorRLValue) a) : node_allocator_type(boost::forward<AllocatorRLValue>(a)) , pool_size(0) , end_node() {} ebo_holder() : node_allocator_type() , pool_size(0) , end_node() {} size_type pool_size; node_base_type end_node; } internal_data; node_allocator_type &priv_node_alloc() { return internal_data; } const node_allocator_type &priv_node_alloc() const { return internal_data; } index_type index; #endif //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED }; #ifndef BOOST_CONTAINER_NO_CXX17_CTAD template <typename InputIterator> stable_vector(InputIterator, InputIterator) -> stable_vector<typename iterator_traits<InputIterator>::value_type>; template <typename InputIterator, typename Allocator> stable_vector(InputIterator, InputIterator, Allocator const&) -> stable_vector<typename iterator_traits<InputIterator>::value_type, Allocator>; #endif #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED #undef BOOST_CONTAINER_STABLE_VECTOR_CHECK_INVARIANT } //namespace container { //!has_trivial_destructor_after_move<> == true_type //!specialization for optimizations template <class T, class Allocator> struct has_trivial_destructor_after_move<boost::container::stable_vector<T, Allocator> > { typedef typename boost::container::stable_vector<T, Allocator>::allocator_type allocator_type; typedef typename ::boost::container::allocator_traits<allocator_type>::pointer pointer; BOOST_STATIC_CONSTEXPR bool value = ::boost::has_trivial_destructor_after_move<allocator_type>::value && ::boost::has_trivial_destructor_after_move<pointer>::value; }; namespace container { #endif //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED }} //namespace boost{ namespace container { #include <boost/container/detail/config_end.hpp> #endif //BOOST_CONTAINER_STABLE_VECTOR_HPP