Mercurial > hg > vamp-build-and-test
diff DEPENDENCIES/generic/include/boost/container/deque.hpp @ 101:c530137014c0
Update Boost headers (1.58.0)
| author | Chris Cannam |
|---|---|
| date | Mon, 07 Sep 2015 11:12:49 +0100 |
| parents | 2665513ce2d3 |
| children |
line wrap: on
line diff
--- a/DEPENDENCIES/generic/include/boost/container/deque.hpp Fri Sep 04 12:01:02 2015 +0100 +++ b/DEPENDENCIES/generic/include/boost/container/deque.hpp Mon Sep 07 11:12:49 2015 +0100 @@ -1,69 +1,75 @@ ////////////////////////////////////////////////////////////////////////////// // -// (C) Copyright Ion Gaztanaga 2005-2012. Distributed under the Boost +// (C) Copyright Ion Gaztanaga 2005-2013. 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. // ////////////////////////////////////////////////////////////////////////////// - #ifndef BOOST_CONTAINER_DEQUE_HPP #define BOOST_CONTAINER_DEQUE_HPP -#if defined(_MSC_VER) +#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> - -#include <boost/container/detail/utilities.hpp> -#include <boost/container/detail/iterators.hpp> -#include <boost/container/detail/algorithms.hpp> -#include <boost/container/detail/mpl.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/advanced_insert_int.hpp> +#include <boost/container/detail/algorithm.hpp> //algo_equal(), algo_lexicographical_compare +#include <boost/container/detail/alloc_helpers.hpp> +#include <boost/container/detail/copy_move_algo.hpp> +#include <boost/container/detail/iterator.hpp> +#include <boost/container/detail/iterator_to_raw_pointer.hpp> +#include <boost/container/detail/iterators.hpp> +#include <boost/container/detail/min_max.hpp> +#include <boost/container/detail/mpl.hpp> +#include <boost/container/detail/to_raw_pointer.hpp> +#include <boost/container/detail/type_traits.hpp> +// move +#include <boost/move/adl_move_swap.hpp> +#include <boost/move/iterator.hpp> +#include <boost/move/traits.hpp> +#include <boost/move/utility_core.hpp> +// move/detail +#if defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) +#include <boost/move/detail/fwd_macros.hpp> +#endif +#include <boost/move/detail/move_helpers.hpp> +// other +#include <boost/assert.hpp> +#include <boost/core/no_exceptions_support.hpp> +// std #include <cstddef> -#include <iterator> -#include <boost/assert.hpp> -#include <memory> -#include <algorithm> -#include <boost/detail/no_exceptions_support.hpp> -#include <boost/type_traits/has_trivial_destructor.hpp> -#include <boost/type_traits/has_trivial_copy.hpp> -#include <boost/type_traits/has_trivial_assign.hpp> -#include <boost/type_traits/has_nothrow_copy.hpp> -#include <boost/type_traits/has_nothrow_assign.hpp> -#include <boost/move/utility.hpp> -#include <boost/move/iterator.hpp> -#include <boost/move/detail/move_helpers.hpp> -#include <boost/container/detail/advanced_insert_int.hpp> -#include <boost/detail/no_exceptions_support.hpp> + +#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST) +#include <initializer_list> +#endif namespace boost { namespace container { -/// @cond -#ifdef BOOST_CONTAINER_DOXYGEN_INVOKED -template <class T, class Allocator = std::allocator<T> > -#else +#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED template <class T, class Allocator> -#endif class deque; template <class T> struct deque_value_traits { typedef T value_type; - static const bool trivial_dctr = boost::has_trivial_destructor<value_type>::value; + static const bool trivial_dctr = container_detail::is_trivially_destructible<value_type>::value; static const bool trivial_dctr_after_move = ::boost::has_trivial_destructor_after_move<value_type>::value; - static const bool trivial_copy = has_trivial_copy<value_type>::value; - static const bool nothrow_copy = has_nothrow_copy<value_type>::value; - static const bool trivial_assign = has_trivial_assign<value_type>::value; - //static const bool nothrow_assign = has_nothrow_assign<value_type>::value; - static const bool nothrow_assign = false; }; // Note: this function is simply a kludge to work around several compilers' @@ -97,16 +103,16 @@ // [start.cur, start.last) and [finish.first, finish.cur) are initialized // objects, and [start.first, start.cur) and [finish.cur, finish.last) // are uninitialized storage. -// [map, map + map_size) is a valid, non-empty range. +// [map, map + map_size) is a valid, non-empty range. // [start.node, finish.node] is a valid range contained within -// [map, map + map_size). -// Allocator pointer in the range [map, map + map_size) points to an allocated node +// [map, map + map_size). +// A pointer in the range [map, map + map_size) points to an allocated node // if and only if the pointer is in the range [start.node, finish.node]. template<class Pointer, bool IsConst> class deque_iterator { public: - typedef std::random_access_iterator_tag iterator_category; + typedef std::random_access_iterator_tag iterator_category; typedef typename boost::intrusive::pointer_traits<Pointer>::element_type value_type; typedef typename boost::intrusive::pointer_traits<Pointer>::difference_type difference_type; typedef typename if_c @@ -126,7 +132,7 @@ typedef Pointer val_alloc_ptr; typedef typename boost::intrusive::pointer_traits<Pointer>:: - template rebind_pointer<Pointer>::type index_pointer; + template rebind_pointer<Pointer>::type index_pointer; Pointer m_cur; Pointer m_first; @@ -140,34 +146,34 @@ Pointer get_last() const { return m_last; } index_pointer get_node() const { return m_node; } - deque_iterator(val_alloc_ptr x, index_pointer y) BOOST_CONTAINER_NOEXCEPT + deque_iterator(val_alloc_ptr x, index_pointer y) BOOST_NOEXCEPT_OR_NOTHROW : m_cur(x), m_first(*y), m_last(*y + s_buffer_size()), m_node(y) {} - deque_iterator() BOOST_CONTAINER_NOEXCEPT - : m_cur(), m_first(), m_last(), m_node() + deque_iterator() BOOST_NOEXCEPT_OR_NOTHROW + : m_cur(), m_first(), m_last(), m_node() //Value initialization to achieve "null iterators" (N3644) {} - deque_iterator(deque_iterator<Pointer, false> const& x) BOOST_CONTAINER_NOEXCEPT + deque_iterator(deque_iterator<Pointer, false> const& x) BOOST_NOEXCEPT_OR_NOTHROW : m_cur(x.get_cur()), m_first(x.get_first()), m_last(x.get_last()), m_node(x.get_node()) {} - deque_iterator(Pointer cur, Pointer first, Pointer last, index_pointer node) BOOST_CONTAINER_NOEXCEPT + deque_iterator(Pointer cur, Pointer first, Pointer last, index_pointer node) BOOST_NOEXCEPT_OR_NOTHROW : m_cur(cur), m_first(first), m_last(last), m_node(node) {} - deque_iterator<Pointer, false> unconst() const BOOST_CONTAINER_NOEXCEPT + deque_iterator<Pointer, false> unconst() const BOOST_NOEXCEPT_OR_NOTHROW { return deque_iterator<Pointer, false>(this->get_cur(), this->get_first(), this->get_last(), this->get_node()); } - reference operator*() const BOOST_CONTAINER_NOEXCEPT + reference operator*() const BOOST_NOEXCEPT_OR_NOTHROW { return *this->m_cur; } - pointer operator->() const BOOST_CONTAINER_NOEXCEPT + pointer operator->() const BOOST_NOEXCEPT_OR_NOTHROW { return this->m_cur; } - difference_type operator-(const deque_iterator& x) const BOOST_CONTAINER_NOEXCEPT + difference_type operator-(const deque_iterator& x) const BOOST_NOEXCEPT_OR_NOTHROW { if(!this->m_cur && !x.m_cur){ return 0; @@ -176,7 +182,7 @@ (this->m_cur - this->m_first) + (x.m_last - x.m_cur); } - deque_iterator& operator++() BOOST_CONTAINER_NOEXCEPT + deque_iterator& operator++() BOOST_NOEXCEPT_OR_NOTHROW { ++this->m_cur; if (this->m_cur == this->m_last) { @@ -186,14 +192,14 @@ return *this; } - deque_iterator operator++(int) BOOST_CONTAINER_NOEXCEPT + deque_iterator operator++(int) BOOST_NOEXCEPT_OR_NOTHROW { deque_iterator tmp(*this); ++*this; return tmp; } - deque_iterator& operator--() BOOST_CONTAINER_NOEXCEPT + deque_iterator& operator--() BOOST_NOEXCEPT_OR_NOTHROW { if (this->m_cur == this->m_first) { this->priv_set_node(this->m_node - 1); @@ -203,14 +209,14 @@ return *this; } - deque_iterator operator--(int) BOOST_CONTAINER_NOEXCEPT + deque_iterator operator--(int) BOOST_NOEXCEPT_OR_NOTHROW { deque_iterator tmp(*this); --*this; return tmp; } - deque_iterator& operator+=(difference_type n) BOOST_CONTAINER_NOEXCEPT + deque_iterator& operator+=(difference_type n) BOOST_NOEXCEPT_OR_NOTHROW { difference_type offset = n + (this->m_cur - this->m_first); if (offset >= 0 && offset < difference_type(this->s_buffer_size())) @@ -226,44 +232,44 @@ return *this; } - deque_iterator operator+(difference_type n) const BOOST_CONTAINER_NOEXCEPT + deque_iterator operator+(difference_type n) const BOOST_NOEXCEPT_OR_NOTHROW { deque_iterator tmp(*this); return tmp += n; } - deque_iterator& operator-=(difference_type n) BOOST_CONTAINER_NOEXCEPT + deque_iterator& operator-=(difference_type n) BOOST_NOEXCEPT_OR_NOTHROW { return *this += -n; } - - deque_iterator operator-(difference_type n) const BOOST_CONTAINER_NOEXCEPT + + deque_iterator operator-(difference_type n) const BOOST_NOEXCEPT_OR_NOTHROW { deque_iterator tmp(*this); return tmp -= n; } - reference operator[](difference_type n) const BOOST_CONTAINER_NOEXCEPT + reference operator[](difference_type n) const BOOST_NOEXCEPT_OR_NOTHROW { return *(*this + n); } - friend bool operator==(const deque_iterator& l, const deque_iterator& r) BOOST_CONTAINER_NOEXCEPT + friend bool operator==(const deque_iterator& l, const deque_iterator& r) BOOST_NOEXCEPT_OR_NOTHROW { return l.m_cur == r.m_cur; } - friend bool operator!=(const deque_iterator& l, const deque_iterator& r) BOOST_CONTAINER_NOEXCEPT + friend bool operator!=(const deque_iterator& l, const deque_iterator& r) BOOST_NOEXCEPT_OR_NOTHROW { return l.m_cur != r.m_cur; } - friend bool operator<(const deque_iterator& l, const deque_iterator& r) BOOST_CONTAINER_NOEXCEPT + friend bool operator<(const deque_iterator& l, const deque_iterator& r) BOOST_NOEXCEPT_OR_NOTHROW { return (l.m_node == r.m_node) ? (l.m_cur < r.m_cur) : (l.m_node < r.m_node); } - friend bool operator>(const deque_iterator& l, const deque_iterator& r) BOOST_CONTAINER_NOEXCEPT + friend bool operator>(const deque_iterator& l, const deque_iterator& r) BOOST_NOEXCEPT_OR_NOTHROW { return r < l; } - friend bool operator<=(const deque_iterator& l, const deque_iterator& r) BOOST_CONTAINER_NOEXCEPT + friend bool operator<=(const deque_iterator& l, const deque_iterator& r) BOOST_NOEXCEPT_OR_NOTHROW { return !(r < l); } - friend bool operator>=(const deque_iterator& l, const deque_iterator& r) BOOST_CONTAINER_NOEXCEPT + friend bool operator>=(const deque_iterator& l, const deque_iterator& r) BOOST_NOEXCEPT_OR_NOTHROW { return !(l < r); } - void priv_set_node(index_pointer new_node) BOOST_CONTAINER_NOEXCEPT + void priv_set_node(index_pointer new_node) BOOST_NOEXCEPT_OR_NOTHROW { this->m_node = new_node; this->m_first = *new_node; this->m_last = this->m_first + this->s_buffer_size(); } - friend deque_iterator operator+(difference_type n, deque_iterator x) BOOST_CONTAINER_NOEXCEPT + friend deque_iterator operator+(difference_type n, deque_iterator x) BOOST_NOEXCEPT_OR_NOTHROW { return x += n; } }; @@ -302,19 +308,19 @@ typedef deque_value_traits<val_alloc_val> traits_t; typedef ptr_alloc_t map_allocator_type; - static size_type s_buffer_size() BOOST_CONTAINER_NOEXCEPT + static size_type s_buffer_size() BOOST_NOEXCEPT_OR_NOTHROW { return deque_buf_size<val_alloc_val>::value; } val_alloc_ptr priv_allocate_node() { return this->alloc().allocate(s_buffer_size()); } - void priv_deallocate_node(val_alloc_ptr p) BOOST_CONTAINER_NOEXCEPT + void priv_deallocate_node(val_alloc_ptr p) BOOST_NOEXCEPT_OR_NOTHROW { this->alloc().deallocate(p, s_buffer_size()); } ptr_alloc_ptr priv_allocate_map(size_type n) { return this->ptr_alloc().allocate(n); } - void priv_deallocate_map(ptr_alloc_ptr p, size_type n) BOOST_CONTAINER_NOEXCEPT + void priv_deallocate_map(ptr_alloc_ptr p, size_type n) BOOST_NOEXCEPT_OR_NOTHROW { this->ptr_alloc().deallocate(p, n); } typedef container_detail::deque_iterator<val_alloc_ptr, false> iterator; @@ -347,15 +353,15 @@ private: deque_base(const deque_base&); - + protected: - void swap_members(deque_base &x) BOOST_CONTAINER_NOEXCEPT + void swap_members(deque_base &x) BOOST_NOEXCEPT_OR_NOTHROW { - std::swap(this->members_.m_start, x.members_.m_start); - std::swap(this->members_.m_finish, x.members_.m_finish); - std::swap(this->members_.m_map, x.members_.m_map); - std::swap(this->members_.m_map_size, x.members_.m_map_size); + ::boost::adl_move_swap(this->members_.m_start, x.members_.m_start); + ::boost::adl_move_swap(this->members_.m_finish, x.members_.m_finish); + ::boost::adl_move_swap(this->members_.m_map, x.members_.m_map); + ::boost::adl_move_swap(this->members_.m_map_size, x.members_.m_map_size); } void priv_initialize_map(size_type num_elements) @@ -368,7 +374,7 @@ ptr_alloc_ptr nstart = this->members_.m_map + (this->members_.m_map_size - num_nodes) / 2; ptr_alloc_ptr nfinish = nstart + num_nodes; - + BOOST_TRY { this->priv_create_nodes(nstart, nfinish); } @@ -390,9 +396,9 @@ void priv_create_nodes(ptr_alloc_ptr nstart, ptr_alloc_ptr nfinish) { - ptr_alloc_ptr cur; + ptr_alloc_ptr cur = nstart; BOOST_TRY { - for (cur = nstart; cur < nfinish; ++cur) + for (; cur < nfinish; ++cur) *cur = this->priv_allocate_node(); } BOOST_CATCH(...){ @@ -402,13 +408,13 @@ BOOST_CATCH_END } - void priv_destroy_nodes(ptr_alloc_ptr nstart, ptr_alloc_ptr nfinish) BOOST_CONTAINER_NOEXCEPT + void priv_destroy_nodes(ptr_alloc_ptr nstart, ptr_alloc_ptr nfinish) BOOST_NOEXCEPT_OR_NOTHROW { for (ptr_alloc_ptr n = nstart; n < nfinish; ++n) this->priv_deallocate_node(*n); } - void priv_clear_map() BOOST_CONTAINER_NOEXCEPT + void priv_clear_map() BOOST_NOEXCEPT_OR_NOTHROW { if (this->members_.m_map) { this->priv_destroy_nodes(this->members_.m_start.m_node, this->members_.m_finish.m_node + 1); @@ -453,33 +459,36 @@ iterator m_finish; } members_; - ptr_alloc_t &ptr_alloc() BOOST_CONTAINER_NOEXCEPT - { return members_; } - - const ptr_alloc_t &ptr_alloc() const BOOST_CONTAINER_NOEXCEPT + ptr_alloc_t &ptr_alloc() BOOST_NOEXCEPT_OR_NOTHROW { return members_; } - allocator_type &alloc() BOOST_CONTAINER_NOEXCEPT + const ptr_alloc_t &ptr_alloc() const BOOST_NOEXCEPT_OR_NOTHROW { return members_; } - - const allocator_type &alloc() const BOOST_CONTAINER_NOEXCEPT + + allocator_type &alloc() BOOST_NOEXCEPT_OR_NOTHROW + { return members_; } + + const allocator_type &alloc() const BOOST_NOEXCEPT_OR_NOTHROW { return members_; } }; -/// @endcond +#endif //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED -//! Deque class +#ifdef BOOST_CONTAINER_DOXYGEN_INVOKED +//! A double-ended queue is a sequence that supports random access to elements, constant time insertion +//! and removal of elements at the end of the sequence, and linear time insertion and removal of elements in the middle. //! -#ifdef BOOST_CONTAINER_DOXYGEN_INVOKED -template <class T, class Allocator = std::allocator<T> > +//! \tparam T The type of object that is stored in the deque +//! \tparam Allocator The allocator used for all internal memory management +template <class T, class Allocator = new_allocator<T> > #else template <class T, class Allocator> #endif class deque : protected deque_base<Allocator> { - /// @cond + #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED private: typedef deque_base<Allocator> Base; - /// @endcond + #endif //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED public: @@ -500,10 +509,10 @@ typedef BOOST_CONTAINER_IMPDEF(allocator_type) stored_allocator_type; typedef BOOST_CONTAINER_IMPDEF(typename Base::iterator) iterator; typedef BOOST_CONTAINER_IMPDEF(typename Base::const_iterator) const_iterator; - typedef BOOST_CONTAINER_IMPDEF(std::reverse_iterator<iterator>) reverse_iterator; - typedef BOOST_CONTAINER_IMPDEF(std::reverse_iterator<const_iterator>) const_reverse_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; - /// @cond + #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED private: // Internal typedefs BOOST_COPYABLE_AND_MOVABLE(deque) @@ -512,7 +521,7 @@ { return Base::s_buffer_size(); } typedef allocator_traits<Allocator> allocator_traits_type; - /// @endcond + #endif //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED public: ////////////////////////////////////////////// @@ -535,30 +544,30 @@ //! <b>Throws</b>: Nothing //! //! <b>Complexity</b>: Constant. - explicit deque(const allocator_type& a) BOOST_CONTAINER_NOEXCEPT + explicit deque(const allocator_type& a) BOOST_NOEXCEPT_OR_NOTHROW : Base(a) {} - //! <b>Effects</b>: Constructs a deque that will use a copy of allocator a + //! <b>Effects</b>: Constructs a deque //! and inserts n value initialized values. //! - //! <b>Throws</b>: If allocator_type's default constructor or copy constructor - //! throws or T's default or copy constructor throws. + //! <b>Throws</b>: If allocator_type's default constructor + //! throws or T's value initialization throws. //! //! <b>Complexity</b>: Linear to n. explicit deque(size_type n) : Base(n, allocator_type()) { - container_detail::insert_value_initialized_n_proxy<Allocator, iterator> proxy(this->alloc()); - proxy.uninitialized_copy_n_and_update(this->begin(), n); + container_detail::insert_value_initialized_n_proxy<Allocator, iterator> proxy; + proxy.uninitialized_copy_n_and_update(this->alloc(), this->begin(), n); //deque_base will deallocate in case of exception... } - //! <b>Effects</b>: Constructs a deque that will use a copy of allocator a + //! <b>Effects</b>: Constructs a deque //! and inserts n default initialized values. //! - //! <b>Throws</b>: If allocator_type's default constructor or copy constructor - //! throws or T's default or copy constructor throws. + //! <b>Throws</b>: If allocator_type's default constructor + //! throws or T's default initialization or copy constructor throws. //! //! <b>Complexity</b>: Linear to n. //! @@ -566,16 +575,48 @@ deque(size_type n, default_init_t) : Base(n, allocator_type()) { - container_detail::insert_default_initialized_n_proxy<Allocator, iterator> proxy(this->alloc()); - proxy.uninitialized_copy_n_and_update(this->begin(), n); + container_detail::insert_default_initialized_n_proxy<Allocator, iterator> proxy; + proxy.uninitialized_copy_n_and_update(this->alloc(), this->begin(), n); + //deque_base will deallocate in case of exception... + } + + //! <b>Effects</b>: Constructs a deque 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 value initialization throws. + //! + //! <b>Complexity</b>: Linear to n. + explicit deque(size_type n, const allocator_type &a) + : Base(n, a) + { + container_detail::insert_value_initialized_n_proxy<Allocator, iterator> proxy; + proxy.uninitialized_copy_n_and_update(this->alloc(), this->begin(), n); + //deque_base will deallocate in case of exception... + } + + //! <b>Effects</b>: Constructs a deque 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 initialization or copy constructor throws. + //! + //! <b>Complexity</b>: Linear to n. + //! + //! <b>Note</b>: Non-standard extension + deque(size_type n, default_init_t, const allocator_type &a) + : Base(n, a) + { + container_detail::insert_default_initialized_n_proxy<Allocator, iterator> proxy; + proxy.uninitialized_copy_n_and_update(this->alloc(), this->begin(), n); //deque_base will deallocate in case of exception... } //! <b>Effects</b>: Constructs a deque that will use a copy of allocator a //! and inserts n copies of value. //! - //! <b>Throws</b>: If allocator_type's default constructor or copy constructor - //! throws or T's default or copy constructor throws. + //! <b>Throws</b>: If allocator_type's default constructor + //! throws or T's copy constructor throws. //! //! <b>Complexity</b>: Linear to n. deque(size_type n, const value_type& value, @@ -586,8 +627,8 @@ //! <b>Effects</b>: Constructs a deque that will use a copy of allocator a //! and inserts a copy of the range [first, last) in the deque. //! - //! <b>Throws</b>: If allocator_type's default constructor or copy constructor - //! throws or T's constructor taking an dereferenced InIt throws. + //! <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 InIt> @@ -600,10 +641,24 @@ ) : Base(a) { - typedef typename std::iterator_traits<InIt>::iterator_category ItCat; - this->priv_range_initialize(first, last, ItCat()); + this->priv_range_initialize(first, last); } +#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST) + //! <b>Effects</b>: Constructs a deque that will use a copy of allocator a + //! and inserts a copy of the range [il.begin(), il.end()) in the deque. + //! + //! <b>Throws</b>: If allocator_type's default constructor + //! throws or T's constructor taking a dereferenced std::initializer_list iterator throws. + //! + //! <b>Complexity</b>: Linear to the range [il.begin(), il.end()). + deque(std::initializer_list<value_type> il, const allocator_type& a = allocator_type()) + : Base(a) + { + this->priv_range_initialize(il.begin(), il.end()); + } +#endif + //! <b>Effects</b>: Copy constructs a deque. //! //! <b>Postcondition</b>: x == *this. @@ -619,13 +674,13 @@ } } - //! <b>Effects</b>: Move constructor. Moves mx's resources to *this. + //! <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. deque(BOOST_RV_REF(deque) x) - : Base(boost::move(static_cast<Base&>(x))) + : Base(BOOST_MOVE_BASE(Base, x)) { this->swap_members(x); } //! <b>Effects</b>: Copy constructs a vector using the specified allocator. @@ -647,23 +702,24 @@ } //! <b>Effects</b>: Move constructor using the specified allocator. - //! Moves mx's resources to *this if a == allocator_type(). + //! Moves x's resources to *this if a == allocator_type(). //! Otherwise copies values from x to *this. //! //! <b>Throws</b>: If allocation or T's copy constructor throws. //! - //! <b>Complexity</b>: Constant if a == mx.get_allocator(), linear otherwise. - deque(BOOST_RV_REF(deque) mx, const allocator_type &a) + //! <b>Complexity</b>: Constant if a == x.get_allocator(), linear otherwise. + deque(BOOST_RV_REF(deque) x, const allocator_type &a) : Base(a) { - if(mx.alloc() == a){ - this->swap_members(mx); + if(x.alloc() == a){ + this->swap_members(x); } else{ - if(mx.size()){ - this->priv_initialize_map(mx.size()); + if(x.size()){ + this->priv_initialize_map(x.size()); boost::container::uninitialized_copy_alloc - (this->alloc(), mx.begin(), mx.end(), this->members_.m_start); + ( this->alloc(), boost::make_move_iterator(x.begin()) + , boost::make_move_iterator(x.end()), this->members_.m_start); } } } @@ -674,7 +730,7 @@ //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Linear to the number of elements. - ~deque() BOOST_CONTAINER_NOEXCEPT + ~deque() BOOST_NOEXCEPT_OR_NOTHROW { this->priv_destroy_range(this->members_.m_start, this->members_.m_finish); } @@ -705,39 +761,60 @@ return *this; } - //! <b>Effects</b>: Move assignment. All mx's values are transferred to *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 value_type's move constructor throws) //! - //! <b>Throws</b>: If allocator_type's copy constructor throws. - //! - //! <b>Complexity</b>: Linear. + //! <b>Complexity</b>: Constant if allocator_traits_type:: + //! propagate_on_container_move_assignment is true or + //! this->get>allocator() == x.get_allocator(). Linear otherwise. deque& operator= (BOOST_RV_REF(deque) x) + BOOST_NOEXCEPT_IF(allocator_traits_type::propagate_on_container_move_assignment::value + || allocator_traits_type::is_always_equal::value) { - if (&x != this){ - allocator_type &this_alloc = this->alloc(); - allocator_type &x_alloc = x.alloc(); - //If allocators are equal we can just swap pointers - if(this_alloc == x_alloc){ - //Destroy objects but retain memory in case x reuses it in the future - this->clear(); - this->swap_members(x); - //Move allocator if needed - container_detail::bool_<allocator_traits_type:: - propagate_on_container_move_assignment::value> flag; - container_detail::move_alloc(this_alloc, x_alloc, flag); - container_detail::move_alloc(this->ptr_alloc(), x.ptr_alloc(), flag); - } - //If unequal allocators, then do a one by one move - else{ - this->assign( boost::make_move_iterator(x.begin()) - , boost::make_move_iterator(x.end())); - } + BOOST_ASSERT(this != &x); + allocator_type &this_alloc = this->alloc(); + allocator_type &x_alloc = x.alloc(); + const bool propagate_alloc = allocator_traits_type:: + propagate_on_container_move_assignment::value; + container_detail::bool_<propagate_alloc> flag; + const bool allocators_equal = this_alloc == x_alloc; (void)allocators_equal; + //Resources can be transferred if both allocators are + //going to be equal after this function (either propagated or already equal) + if(propagate_alloc || allocators_equal){ + //Destroy objects but retain memory in case x reuses it in the future + this->clear(); + //Move allocator if needed + container_detail::move_alloc(this_alloc, x_alloc, flag); + container_detail::move_alloc(this->ptr_alloc(), x.ptr_alloc(), flag); + //Nothrow swap + this->swap_members(x); + } + //Else do a one by one move + else{ + this->assign( boost::make_move_iterator(x.begin()) + , boost::make_move_iterator(x.end())); } return *this; } +#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST) + //! <b>Effects</b>: Makes *this contain the same elements as il. + //! + //! <b>Postcondition</b>: this->size() == il.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 il. + deque& operator=(std::initializer_list<value_type> il) + { + this->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. @@ -786,10 +863,10 @@ >::type * = 0 ) { - const size_type len = std::distance(first, last); + const size_type len = boost::container::iterator_distance(first, last); if (len > size()) { FwdIt mid = first; - std::advance(mid, this->size()); + boost::container::iterator_advance(mid, this->size()); boost::container::copy(first, mid, begin()); this->insert(this->cend(), mid, last); } @@ -799,12 +876,23 @@ } #endif +#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 std::initializer_list iterator throws. + //! + //! <b>Complexity</b>: Linear to il.size(). + void assign(std::initializer_list<value_type> il) + { this->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. - allocator_type get_allocator() const BOOST_CONTAINER_NOEXCEPT + allocator_type get_allocator() const BOOST_NOEXCEPT_OR_NOTHROW { return Base::alloc(); } //! <b>Effects</b>: Returns a reference to the internal allocator. @@ -814,7 +902,7 @@ //! <b>Complexity</b>: Constant. //! //! <b>Note</b>: Non-standard extension. - const stored_allocator_type &get_stored_allocator() const BOOST_CONTAINER_NOEXCEPT + const stored_allocator_type &get_stored_allocator() const BOOST_NOEXCEPT_OR_NOTHROW { return Base::alloc(); } ////////////////////////////////////////////// @@ -830,7 +918,7 @@ //! <b>Complexity</b>: Constant. //! //! <b>Note</b>: Non-standard extension. - stored_allocator_type &get_stored_allocator() BOOST_CONTAINER_NOEXCEPT + stored_allocator_type &get_stored_allocator() BOOST_NOEXCEPT_OR_NOTHROW { return Base::alloc(); } //! <b>Effects</b>: Returns an iterator to the first element contained in the deque. @@ -838,7 +926,7 @@ //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Constant. - iterator begin() BOOST_CONTAINER_NOEXCEPT + iterator begin() BOOST_NOEXCEPT_OR_NOTHROW { return this->members_.m_start; } //! <b>Effects</b>: Returns a const_iterator to the first element contained in the deque. @@ -846,7 +934,7 @@ //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Constant. - const_iterator begin() const BOOST_CONTAINER_NOEXCEPT + const_iterator begin() const BOOST_NOEXCEPT_OR_NOTHROW { return this->members_.m_start; } //! <b>Effects</b>: Returns an iterator to the end of the deque. @@ -854,7 +942,7 @@ //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Constant. - iterator end() BOOST_CONTAINER_NOEXCEPT + iterator end() BOOST_NOEXCEPT_OR_NOTHROW { return this->members_.m_finish; } //! <b>Effects</b>: Returns a const_iterator to the end of the deque. @@ -862,7 +950,7 @@ //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Constant. - const_iterator end() const BOOST_CONTAINER_NOEXCEPT + const_iterator end() const BOOST_NOEXCEPT_OR_NOTHROW { return this->members_.m_finish; } //! <b>Effects</b>: Returns a reverse_iterator pointing to the beginning @@ -871,7 +959,7 @@ //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Constant. - reverse_iterator rbegin() BOOST_CONTAINER_NOEXCEPT + reverse_iterator rbegin() BOOST_NOEXCEPT_OR_NOTHROW { return reverse_iterator(this->members_.m_finish); } //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning @@ -880,7 +968,7 @@ //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Constant. - const_reverse_iterator rbegin() const BOOST_CONTAINER_NOEXCEPT + const_reverse_iterator rbegin() const BOOST_NOEXCEPT_OR_NOTHROW { return const_reverse_iterator(this->members_.m_finish); } //! <b>Effects</b>: Returns a reverse_iterator pointing to the end @@ -889,7 +977,7 @@ //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Constant. - reverse_iterator rend() BOOST_CONTAINER_NOEXCEPT + reverse_iterator rend() BOOST_NOEXCEPT_OR_NOTHROW { return reverse_iterator(this->members_.m_start); } //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the end @@ -898,7 +986,7 @@ //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Constant. - const_reverse_iterator rend() const BOOST_CONTAINER_NOEXCEPT + const_reverse_iterator rend() const BOOST_NOEXCEPT_OR_NOTHROW { return const_reverse_iterator(this->members_.m_start); } //! <b>Effects</b>: Returns a const_iterator to the first element contained in the deque. @@ -906,7 +994,7 @@ //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Constant. - const_iterator cbegin() const BOOST_CONTAINER_NOEXCEPT + const_iterator cbegin() const BOOST_NOEXCEPT_OR_NOTHROW { return this->members_.m_start; } //! <b>Effects</b>: Returns a const_iterator to the end of the deque. @@ -914,7 +1002,7 @@ //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Constant. - const_iterator cend() const BOOST_CONTAINER_NOEXCEPT + const_iterator cend() const BOOST_NOEXCEPT_OR_NOTHROW { return this->members_.m_finish; } //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning @@ -923,7 +1011,7 @@ //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Constant. - const_reverse_iterator crbegin() const BOOST_CONTAINER_NOEXCEPT + const_reverse_iterator crbegin() const BOOST_NOEXCEPT_OR_NOTHROW { return const_reverse_iterator(this->members_.m_finish); } //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the end @@ -932,7 +1020,7 @@ //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Constant. - const_reverse_iterator crend() const BOOST_CONTAINER_NOEXCEPT + const_reverse_iterator crend() const BOOST_NOEXCEPT_OR_NOTHROW { return const_reverse_iterator(this->members_.m_start); } ////////////////////////////////////////////// @@ -946,7 +1034,7 @@ //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Constant. - bool empty() const BOOST_CONTAINER_NOEXCEPT + bool empty() const BOOST_NOEXCEPT_OR_NOTHROW { return this->members_.m_finish == this->members_.m_start; } //! <b>Effects</b>: Returns the number of the elements contained in the deque. @@ -954,7 +1042,7 @@ //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Constant. - size_type size() const BOOST_CONTAINER_NOEXCEPT + size_type size() const BOOST_NOEXCEPT_OR_NOTHROW { return this->members_.m_finish - this->members_.m_start; } //! <b>Effects</b>: Returns the largest possible size of the deque. @@ -962,7 +1050,7 @@ //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Constant. - size_type max_size() const BOOST_CONTAINER_NOEXCEPT + size_type max_size() const BOOST_NOEXCEPT_OR_NOTHROW { return allocator_traits_type::max_size(this->alloc()); } //! <b>Effects</b>: Inserts or erases elements at the end such that @@ -978,7 +1066,7 @@ this->priv_erase_last_n(len - new_size); else{ const size_type n = new_size - this->size(); - container_detail::insert_value_initialized_n_proxy<Allocator, iterator> proxy(this->alloc()); + container_detail::insert_value_initialized_n_proxy<Allocator, iterator> proxy; priv_insert_back_aux_impl(n, proxy); } } @@ -998,7 +1086,7 @@ this->priv_erase_last_n(len - new_size); else{ const size_type n = new_size - this->size(); - container_detail::insert_default_initialized_n_proxy<Allocator, iterator> proxy(this->alloc()); + container_detail::insert_default_initialized_n_proxy<Allocator, iterator> proxy; priv_insert_back_aux_impl(n, proxy); } } @@ -1049,7 +1137,7 @@ //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Constant. - reference front() BOOST_CONTAINER_NOEXCEPT + reference front() BOOST_NOEXCEPT_OR_NOTHROW { return *this->members_.m_start; } //! <b>Requires</b>: !empty() @@ -1060,7 +1148,7 @@ //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Constant. - const_reference front() const BOOST_CONTAINER_NOEXCEPT + const_reference front() const BOOST_NOEXCEPT_OR_NOTHROW { return *this->members_.m_start; } //! <b>Requires</b>: !empty() @@ -1071,7 +1159,7 @@ //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Constant. - reference back() BOOST_CONTAINER_NOEXCEPT + reference back() BOOST_NOEXCEPT_OR_NOTHROW { return *(end()-1); } //! <b>Requires</b>: !empty() @@ -1082,7 +1170,7 @@ //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Constant. - const_reference back() const BOOST_CONTAINER_NOEXCEPT + const_reference back() const BOOST_NOEXCEPT_OR_NOTHROW { return *(cend()-1); } //! <b>Requires</b>: size() > n. @@ -1093,7 +1181,7 @@ //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Constant. - reference operator[](size_type n) BOOST_CONTAINER_NOEXCEPT + reference operator[](size_type n) BOOST_NOEXCEPT_OR_NOTHROW { return this->members_.m_start[difference_type(n)]; } //! <b>Requires</b>: size() > n. @@ -1104,9 +1192,70 @@ //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Constant. - const_reference operator[](size_type n) const BOOST_CONTAINER_NOEXCEPT + const_reference operator[](size_type n) const BOOST_NOEXCEPT_OR_NOTHROW { return this->members_.m_start[difference_type(n)]; } + //! <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 + iterator nth(size_type n) BOOST_NOEXCEPT_OR_NOTHROW + { + BOOST_ASSERT(this->size() >= n); + return iterator(this->begin()+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 + const_iterator nth(size_type n) const BOOST_NOEXCEPT_OR_NOTHROW + { + BOOST_ASSERT(this->size() >= n); + return const_iterator(this->cbegin()+n); + } + + //! <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 + size_type index_of(iterator p) BOOST_NOEXCEPT_OR_NOTHROW + { return this->priv_index_of(p); } + + //! <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 + size_type index_of(const_iterator p) const BOOST_NOEXCEPT_OR_NOTHROW + { return this->priv_index_of(p); } + //! <b>Requires</b>: size() > n. //! //! <b>Effects</b>: Returns a reference to the nth element @@ -1135,7 +1284,7 @@ // ////////////////////////////////////////////// - #if defined(BOOST_CONTAINER_PERFECT_FORWARDING) || defined(BOOST_CONTAINER_DOXYGEN_INVOKED) + #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 beginning of the deque. @@ -1144,7 +1293,7 @@ //! //! <b>Complexity</b>: Amortized constant time template <class... Args> - void emplace_front(Args&&... args) + void emplace_front(BOOST_FWD_REF(Args)... args) { if(this->priv_push_front_simple_available()){ allocator_traits_type::construct @@ -1154,8 +1303,8 @@ this->priv_push_front_simple_commit(); } else{ - typedef container_detail::insert_non_movable_emplace_proxy<Allocator, iterator, Args...> type; - this->priv_insert_front_aux_impl(1, type(this->alloc(), boost::forward<Args>(args)...)); + typedef container_detail::insert_nonmovable_emplace_proxy<Allocator, iterator, Args...> type; + this->priv_insert_front_aux_impl(1, type(boost::forward<Args>(args)...)); } } @@ -1166,7 +1315,7 @@ //! //! <b>Complexity</b>: Amortized constant time template <class... Args> - void emplace_back(Args&&... args) + void emplace_back(BOOST_FWD_REF(Args)... args) { if(this->priv_push_back_simple_available()){ allocator_traits_type::construct @@ -1176,22 +1325,22 @@ this->priv_push_back_simple_commit(); } else{ - typedef container_detail::insert_non_movable_emplace_proxy<Allocator, iterator, Args...> type; - this->priv_insert_back_aux_impl(1, type(this->alloc(), boost::forward<Args>(args)...)); + typedef container_detail::insert_nonmovable_emplace_proxy<Allocator, iterator, Args...> type; + this->priv_insert_back_aux_impl(1, type(boost::forward<Args>(args)...)); } } - //! <b>Requires</b>: position must be a valid iterator of *this. + //! <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 position + //! std::forward<Args>(args)... before p //! //! <b>Throws</b>: If memory allocation throws or the in-place constructor throws. //! - //! <b>Complexity</b>: If position is end(), amortized constant time + //! <b>Complexity</b>: If p is end(), amortized constant time //! Linear time otherwise. template <class... Args> - iterator emplace(const_iterator p, Args&&... args) + iterator emplace(const_iterator p, BOOST_FWD_REF(Args)... args) { if(p == this->cbegin()){ this->emplace_front(boost::forward<Args>(args)...); @@ -1203,74 +1352,65 @@ } else{ typedef container_detail::insert_emplace_proxy<Allocator, iterator, Args...> type; - return this->priv_insert_aux_impl(p, 1, type(this->alloc(), boost::forward<Args>(args)...)); + return this->priv_insert_aux_impl(p, 1, type(boost::forward<Args>(args)...)); } } - #else //#ifdef BOOST_CONTAINER_PERFECT_FORWARDING + #else //!defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) - //advanced_insert_int.hpp includes all necessary preprocessor machinery... - #define BOOST_PP_LOCAL_MACRO(n) \ - BOOST_PP_EXPR_IF(n, template<) BOOST_PP_ENUM_PARAMS(n, class P) BOOST_PP_EXPR_IF(n, > ) \ - void emplace_front(BOOST_PP_ENUM(n, BOOST_CONTAINER_PP_PARAM_LIST, _)) \ - { \ - if(priv_push_front_simple_available()){ \ - allocator_traits_type::construct \ - ( this->alloc() \ - , this->priv_push_front_simple_pos() \ - BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_PARAM_FORWARD, _)); \ - priv_push_front_simple_commit(); \ - } \ - else{ \ - container_detail::BOOST_PP_CAT(insert_non_movable_emplace_proxy_arg, n) \ - <Allocator, iterator BOOST_PP_ENUM_TRAILING_PARAMS(n, P)> proxy \ - (this->alloc() BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_PARAM_FORWARD, _)); \ - priv_insert_front_aux_impl(1, proxy); \ - } \ - } \ - \ - BOOST_PP_EXPR_IF(n, template<) BOOST_PP_ENUM_PARAMS(n, class P) BOOST_PP_EXPR_IF(n, >) \ - void emplace_back(BOOST_PP_ENUM(n, BOOST_CONTAINER_PP_PARAM_LIST, _)) \ - { \ - if(priv_push_back_simple_available()){ \ - allocator_traits_type::construct \ - ( this->alloc() \ - , this->priv_push_back_simple_pos() \ - BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_PARAM_FORWARD, _)); \ - priv_push_back_simple_commit(); \ - } \ - else{ \ - container_detail::BOOST_PP_CAT(insert_non_movable_emplace_proxy_arg, n) \ - <Allocator, iterator BOOST_PP_ENUM_TRAILING_PARAMS(n, P)> proxy \ - (this->alloc() BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_PARAM_FORWARD, _)); \ - priv_insert_back_aux_impl(1, proxy); \ - } \ - } \ - \ - BOOST_PP_EXPR_IF(n, template<) BOOST_PP_ENUM_PARAMS(n, class P) BOOST_PP_EXPR_IF(n, >) \ - iterator emplace(const_iterator p \ - BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_PARAM_LIST, _)) \ - { \ - if(p == this->cbegin()){ \ - this->emplace_front(BOOST_PP_ENUM(n, BOOST_CONTAINER_PP_PARAM_FORWARD, _)); \ - return this->begin(); \ - } \ - else if(p == cend()){ \ - this->emplace_back(BOOST_PP_ENUM(n, BOOST_CONTAINER_PP_PARAM_FORWARD, _)); \ - return (this->end()-1); \ - } \ - else{ \ - container_detail::BOOST_PP_CAT(insert_emplace_proxy_arg, n) \ - <Allocator, iterator BOOST_PP_ENUM_TRAILING_PARAMS(n, P)> proxy \ - (this->alloc() BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_PARAM_FORWARD, _)); \ - return this->priv_insert_aux_impl(p, 1, proxy); \ - } \ - } \ - //! - #define BOOST_PP_LOCAL_LIMITS (0, BOOST_CONTAINER_MAX_CONSTRUCTOR_PARAMETERS) - #include BOOST_PP_LOCAL_ITERATE() + #define BOOST_CONTAINER_DEQUE_EMPLACE_CODE(N) \ + BOOST_MOVE_TMPL_LT##N BOOST_MOVE_CLASS##N BOOST_MOVE_GT##N\ + void emplace_front(BOOST_MOVE_UREF##N)\ + {\ + if(priv_push_front_simple_available()){\ + allocator_traits_type::construct\ + ( this->alloc(), this->priv_push_front_simple_pos() BOOST_MOVE_I##N BOOST_MOVE_FWD##N);\ + priv_push_front_simple_commit();\ + }\ + else{\ + typedef container_detail::insert_nonmovable_emplace_proxy##N\ + <Allocator, iterator BOOST_MOVE_I##N BOOST_MOVE_TARG##N> type;\ + priv_insert_front_aux_impl(1, type(BOOST_MOVE_FWD##N));\ + }\ + }\ + \ + BOOST_MOVE_TMPL_LT##N BOOST_MOVE_CLASS##N BOOST_MOVE_GT##N\ + void emplace_back(BOOST_MOVE_UREF##N)\ + {\ + if(priv_push_back_simple_available()){\ + allocator_traits_type::construct\ + ( this->alloc(), this->priv_push_back_simple_pos() BOOST_MOVE_I##N BOOST_MOVE_FWD##N);\ + priv_push_back_simple_commit();\ + }\ + else{\ + typedef container_detail::insert_nonmovable_emplace_proxy##N\ + <Allocator, iterator BOOST_MOVE_I##N BOOST_MOVE_TARG##N> type;\ + priv_insert_back_aux_impl(1, type(BOOST_MOVE_FWD##N));\ + }\ + }\ + \ + 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)\ + {\ + if(p == this->cbegin()){\ + this->emplace_front(BOOST_MOVE_FWD##N);\ + return this->begin();\ + }\ + else if(p == cend()){\ + this->emplace_back(BOOST_MOVE_FWD##N);\ + return (--this->end());\ + }\ + else{\ + typedef container_detail::insert_emplace_proxy_arg##N\ + <Allocator, iterator BOOST_MOVE_I##N BOOST_MOVE_TARG##N> type;\ + return this->priv_insert_aux_impl(p, 1, type(BOOST_MOVE_FWD##N));\ + }\ + } + // + BOOST_MOVE_ITERATE_0TO9(BOOST_CONTAINER_DEQUE_EMPLACE_CODE) + #undef BOOST_CONTAINER_DEQUE_EMPLACE_CODE - #endif //#ifdef BOOST_CONTAINER_PERFECT_FORWARDING + #endif // !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) #if defined(BOOST_CONTAINER_DOXYGEN_INVOKED) //! <b>Effects</b>: Inserts a copy of x at the front of the deque. @@ -1282,7 +1422,7 @@ void push_front(const T &x); //! <b>Effects</b>: Constructs a new element in the front of the deque - //! and moves the resources of mx to this new element. + //! and moves the resources of x to this new element. //! //! <b>Throws</b>: If memory allocation throws. //! @@ -1302,7 +1442,7 @@ void push_back(const T &x); //! <b>Effects</b>: Constructs a new element in the end of the deque - //! and moves the resources of mx to this new element. + //! and moves the resources of x to this new element. //! //! <b>Throws</b>: If memory allocation throws. //! @@ -1314,29 +1454,29 @@ #if defined(BOOST_CONTAINER_DOXYGEN_INVOKED) - //! <b>Requires</b>: position must be a valid iterator of *this. + //! <b>Requires</b>: p must be a valid iterator of *this. //! - //! <b>Effects</b>: Insert a copy of x before position. + //! <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 position is end(), amortized constant time + //! <b>Complexity</b>: If p is end(), amortized constant time //! Linear time otherwise. - iterator insert(const_iterator position, const T &x); + iterator insert(const_iterator p, const T &x); - //! <b>Requires</b>: position must be a valid iterator of *this. + //! <b>Requires</b>: p must be a valid iterator of *this. //! - //! <b>Effects</b>: Insert a new element before position with mx's resources. + //! <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 position is end(), amortized constant time + //! <b>Complexity</b>: If p is end(), amortized constant time //! Linear time otherwise. - iterator insert(const_iterator position, T &&x); + iterator insert(const_iterator p, T &&x); #else BOOST_MOVE_CONVERSION_AWARE_CATCH_1ARG(insert, T, iterator, priv_insert, const_iterator, const_iterator) #endif @@ -1365,7 +1505,7 @@ //! <b>Throws</b>: If memory allocation throws, T's constructor from a //! dereferenced InIt throws or T's copy constructor throws. //! - //! <b>Complexity</b>: Linear to std::distance [first, last). + //! <b>Complexity</b>: Linear to distance [first, last). template <class InIt> iterator insert(const_iterator pos, InIt first, InIt last #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED) @@ -1386,6 +1526,21 @@ return it; } +#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST) + //! <b>Requires</b>: pos must be a valid iterator of *this. + //! + //! <b>Effects</b>: Insert a copy of the [il.begin(), il.end()) range before pos. + //! + //! <b>Returns</b>: an iterator to the first inserted element or pos if il.begin() == il.end(). + //! + //! <b>Throws</b>: If memory allocation throws, T's constructor from a + //! dereferenced std::initializer_list throws or T's copy constructor throws. + //! + //! <b>Complexity</b>: Linear to distance [il.begin(), il.end()). + iterator insert(const_iterator pos, std::initializer_list<value_type> il) + { return insert(pos, il.begin(), il.end()); } +#endif + #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED) template <class FwdIt> iterator insert(const_iterator p, FwdIt first, FwdIt last @@ -1397,8 +1552,8 @@ #endif ) { - container_detail::insert_range_proxy<Allocator, FwdIt, iterator> proxy(this->alloc(), first); - return priv_insert_aux_impl(p, (size_type)std::distance(first, last), proxy); + container_detail::insert_range_proxy<Allocator, FwdIt, iterator> proxy(first); + return priv_insert_aux_impl(p, boost::container::iterator_distance(first, last), proxy); } #endif @@ -1407,7 +1562,7 @@ //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Constant time. - void pop_front() BOOST_CONTAINER_NOEXCEPT + void pop_front() BOOST_NOEXCEPT_OR_NOTHROW { if (this->members_.m_start.m_cur != this->members_.m_start.m_last - 1) { allocator_traits_type::destroy @@ -1425,7 +1580,7 @@ //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Constant time. - void pop_back() BOOST_CONTAINER_NOEXCEPT + void pop_back() BOOST_NOEXCEPT_OR_NOTHROW { if (this->members_.m_finish.m_cur != this->members_.m_finish.m_first) { --this->members_.m_finish.m_cur; @@ -1438,7 +1593,7 @@ this->priv_pop_back_aux(); } - //! <b>Effects</b>: Erases the element at position pos. + //! <b>Effects</b>: Erases the element at p. //! //! <b>Throws</b>: Nothing. //! @@ -1446,17 +1601,17 @@ //! last element (if pos is near the end) or the first element //! if(pos is near the beginning). //! Constant if pos is the first or the last element. - iterator erase(const_iterator pos) BOOST_CONTAINER_NOEXCEPT + iterator erase(const_iterator pos) BOOST_NOEXCEPT_OR_NOTHROW { iterator next = pos.unconst(); ++next; size_type index = pos - this->members_.m_start; if (index < (this->size()/2)) { - boost::move_backward(this->begin(), pos.unconst(), next); + boost::container::move_backward(this->begin(), pos.unconst(), next); pop_front(); } else { - boost::move(next, this->end(), pos.unconst()); + boost::container::move(next, this->end(), pos.unconst()); pop_back(); } return this->members_.m_start + index; @@ -1470,7 +1625,7 @@ //! last plus the elements between pos and the //! last element (if pos is near the end) or the first element //! if(pos is near the beginning). - iterator erase(const_iterator first, const_iterator last) BOOST_CONTAINER_NOEXCEPT + iterator erase(const_iterator first, const_iterator last) BOOST_NOEXCEPT_OR_NOTHROW { if (first == this->members_.m_start && last == this->members_.m_finish) { this->clear(); @@ -1480,7 +1635,7 @@ const size_type n = static_cast<size_type>(last - first); const size_type elems_before = static_cast<size_type>(first - this->members_.m_start); if (elems_before < (this->size() - n) - elems_before) { - boost::move_backward(begin(), first.unconst(), last.unconst()); + boost::container::move_backward(begin(), first.unconst(), last.unconst()); iterator new_start = this->members_.m_start + n; if(!Base::traits_t::trivial_dctr_after_move) this->priv_destroy_range(this->members_.m_start, new_start); @@ -1488,7 +1643,7 @@ this->members_.m_start = new_start; } else { - boost::move(last.unconst(), end(), first.unconst()); + boost::container::move(last.unconst(), end(), first.unconst()); iterator new_finish = this->members_.m_finish - n; if(!Base::traits_t::trivial_dctr_after_move) this->priv_destroy_range(new_finish, this->members_.m_finish); @@ -1505,6 +1660,8 @@ //! //! <b>Complexity</b>: Constant. void swap(deque &x) + BOOST_NOEXCEPT_IF(allocator_traits_type::propagate_on_container_swap::value + || allocator_traits_type::is_always_equal::value) { this->swap_members(x); container_detail::bool_<allocator_traits_type::propagate_on_container_swap::value> flag; @@ -1517,7 +1674,7 @@ //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Linear to the number of elements in the deque. - void clear() BOOST_CONTAINER_NOEXCEPT + void clear() BOOST_NOEXCEPT_OR_NOTHROW { for (index_pointer node = this->members_.m_start.m_node + 1; node < this->members_.m_finish.m_node; @@ -1537,9 +1694,58 @@ this->members_.m_finish = this->members_.m_start; } - /// @cond + //! <b>Effects</b>: Returns true if x and y are equal + //! + //! <b>Complexity</b>: Linear to the number of elements in the container. + friend bool operator==(const deque& x, const deque& 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. + friend bool operator!=(const deque& x, const deque& 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. + friend bool operator<(const deque& x, const deque& 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. + friend bool operator>(const deque& x, const deque& 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. + friend bool operator<=(const deque& x, const deque& 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. + friend bool operator>=(const deque& x, const deque& y) + { return !(x < y); } + + //! <b>Effects</b>: x.swap(y) + //! + //! <b>Complexity</b>: Constant. + friend void swap(deque& x, deque& y) + { x.swap(y); } + + #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED private: + size_type priv_index_of(const_iterator p) const + { + BOOST_ASSERT(this->cbegin() <= p); + BOOST_ASSERT(p <= this->cend()); + return static_cast<size_type>(p - this->cbegin()); + } + void priv_erase_last_n(size_type n) { if(n == this->size()) { @@ -1558,19 +1764,20 @@ { if (n >= this->size()) throw_out_of_range("deque::at out of range"); } template <class U> - iterator priv_insert(const_iterator position, BOOST_FWD_REF(U) x) + iterator priv_insert(const_iterator p, BOOST_FWD_REF(U) x) { - if (position == cbegin()){ + if (p == cbegin()){ this->push_front(::boost::forward<U>(x)); return begin(); } - else if (position == cend()){ + else if (p == cend()){ this->push_back(::boost::forward<U>(x)); return --end(); } else { return priv_insert_aux_impl - (position, (size_type)1, container_detail::get_insert_value_proxy<iterator>(this->alloc(), ::boost::forward<U>(x))); + ( p, (size_type)1 + , container_detail::get_insert_value_proxy<iterator, Allocator>(::boost::forward<U>(x))); } } @@ -1584,7 +1791,8 @@ } else{ priv_insert_aux_impl - (this->cbegin(), (size_type)1, container_detail::get_insert_value_proxy<iterator>(this->alloc(), ::boost::forward<U>(x))); + ( this->cbegin(), (size_type)1 + , container_detail::get_insert_value_proxy<iterator, Allocator>(::boost::forward<U>(x))); } } @@ -1598,8 +1806,8 @@ } else{ priv_insert_aux_impl - (this->cend(), (size_type)1, container_detail::get_insert_value_proxy<iterator>(this->alloc(), ::boost::forward<U>(x))); - container_detail::insert_copy_proxy<Allocator, iterator> proxy(this->alloc(), x); + ( this->cend(), (size_type)1 + , container_detail::get_insert_value_proxy<iterator, Allocator>(::boost::forward<U>(x))); } } @@ -1633,26 +1841,24 @@ void priv_destroy_range(iterator p, iterator p2) { - for(;p != p2; ++p){ - allocator_traits_type::destroy - ( this->alloc() - , container_detail::to_raw_pointer(&*p) - ); + if(!Base::traits_t::trivial_dctr){ + for(;p != p2; ++p){ + allocator_traits_type::destroy(this->alloc(), container_detail::iterator_to_raw_pointer(p)); + } } } void priv_destroy_range(pointer p, pointer p2) { - for(;p != p2; ++p){ - allocator_traits_type::destroy - ( this->alloc() - , container_detail::to_raw_pointer(&*p) - ); + if(!Base::traits_t::trivial_dctr){ + for(;p != p2; ++p){ + allocator_traits_type::destroy(this->alloc(), container_detail::iterator_to_raw_pointer(p)); + } } } template<class InsertProxy> - iterator priv_insert_aux_impl(const_iterator p, size_type n, InsertProxy interf) + iterator priv_insert_aux_impl(const_iterator p, size_type n, InsertProxy proxy) { iterator pos(p.unconst()); const size_type pos_n = p - this->cbegin(); @@ -1667,7 +1873,7 @@ const iterator new_start = this->priv_reserve_elements_at_front(n); const iterator old_start = this->members_.m_start; if(!elemsbefore){ - interf.uninitialized_copy_n_and_update(new_start, n); + proxy.uninitialized_copy_n_and_update(this->alloc(), new_start, n); this->members_.m_start = new_start; } else{ @@ -1677,18 +1883,18 @@ ::boost::container::uninitialized_move_alloc (this->alloc(), this->members_.m_start, start_n, new_start); this->members_.m_start = new_start; - boost::move(start_n, pos, old_start); - interf.copy_n_and_update(pos - n, n); + boost::container::move(start_n, pos, old_start); + proxy.copy_n_and_update(this->alloc(), pos - n, n); } else { const size_type mid_count = n - elemsbefore; const iterator mid_start = old_start - mid_count; - interf.uninitialized_copy_n_and_update(mid_start, mid_count); + proxy.uninitialized_copy_n_and_update(this->alloc(), mid_start, mid_count); this->members_.m_start = mid_start; ::boost::container::uninitialized_move_alloc (this->alloc(), old_start, pos, new_start); this->members_.m_start = new_start; - interf.copy_n_and_update(old_start, elemsbefore); + proxy.copy_n_and_update(this->alloc(), old_start, elemsbefore); } } } @@ -1697,7 +1903,7 @@ const iterator old_finish = this->members_.m_finish; const size_type elemsafter = length - elemsbefore; if(!elemsafter){ - interf.uninitialized_copy_n_and_update(old_finish, n); + proxy.uninitialized_copy_n_and_update(this->alloc(), old_finish, n); this->members_.m_finish = new_finish; } else{ @@ -1707,16 +1913,16 @@ ::boost::container::uninitialized_move_alloc (this->alloc(), finish_n, old_finish, old_finish); this->members_.m_finish = new_finish; - boost::move_backward(pos, finish_n, old_finish); - interf.copy_n_and_update(pos, n); + boost::container::move_backward(pos, finish_n, old_finish); + proxy.copy_n_and_update(this->alloc(), pos, n); } else { const size_type raw_gap = n - elemsafter; ::boost::container::uninitialized_move_alloc (this->alloc(), pos, old_finish, old_finish + raw_gap); BOOST_TRY{ - interf.copy_n_and_update(pos, elemsafter); - interf.uninitialized_copy_n_and_update(old_finish, raw_gap); + proxy.copy_n_and_update(this->alloc(), pos, elemsafter); + proxy.uninitialized_copy_n_and_update(this->alloc(), old_finish, raw_gap); } BOOST_CATCH(...){ this->priv_destroy_range(old_finish, old_finish + elemsafter); @@ -1731,7 +1937,7 @@ } template <class InsertProxy> - iterator priv_insert_back_aux_impl(size_type n, InsertProxy interf) + iterator priv_insert_back_aux_impl(size_type n, InsertProxy proxy) { if(!this->members_.m_map){ this->priv_initialize_map(0); @@ -1739,20 +1945,20 @@ iterator new_finish = this->priv_reserve_elements_at_back(n); iterator old_finish = this->members_.m_finish; - interf.uninitialized_copy_n_and_update(old_finish, n); + proxy.uninitialized_copy_n_and_update(this->alloc(), old_finish, n); this->members_.m_finish = new_finish; return iterator(this->members_.m_finish - n); } template <class InsertProxy> - iterator priv_insert_front_aux_impl(size_type n, InsertProxy interf) + iterator priv_insert_front_aux_impl(size_type n, InsertProxy proxy) { if(!this->members_.m_map){ this->priv_initialize_map(0); } iterator new_start = this->priv_reserve_elements_at_front(n); - interf.uninitialized_copy_n_and_update(new_start, n); + proxy.uninitialized_copy_n_and_update(this->alloc(), new_start, n); this->members_.m_start = new_start; return new_start; } @@ -1767,9 +1973,9 @@ // but none of the deque's elements have yet been constructed. void priv_fill_initialize(const value_type& value) { - index_pointer cur; + index_pointer cur = this->members_.m_start.m_node; BOOST_TRY { - for (cur = this->members_.m_start.m_node; cur < this->members_.m_finish.m_node; ++cur){ + for ( ; cur < this->members_.m_finish.m_node; ++cur){ boost::container::uninitialized_fill_alloc (this->alloc(), *cur, *cur + this->s_buffer_size(), value); } @@ -1784,7 +1990,8 @@ } template <class InIt> - void priv_range_initialize(InIt first, InIt last, std::input_iterator_tag) + typename iterator_enable_if_tag<InIt, std::input_iterator_tag>::type + priv_range_initialize(InIt first, InIt last) { this->priv_initialize_map(0); BOOST_TRY { @@ -1799,19 +2006,18 @@ } template <class FwdIt> - void priv_range_initialize(FwdIt first, FwdIt last, std::forward_iterator_tag) + typename iterator_disable_if_tag<FwdIt, std::input_iterator_tag>::type + priv_range_initialize(FwdIt first, FwdIt last) { size_type n = 0; - n = std::distance(first, last); + n = boost::container::iterator_distance(first, last); this->priv_initialize_map(n); - index_pointer cur_node; + index_pointer cur_node = this->members_.m_start.m_node; BOOST_TRY { - for (cur_node = this->members_.m_start.m_node; - cur_node < this->members_.m_finish.m_node; - ++cur_node) { + for (; cur_node < this->members_.m_finish.m_node; ++cur_node) { FwdIt mid = first; - std::advance(mid, this->s_buffer_size()); + boost::container::iterator_advance(mid, this->s_buffer_size()); ::boost::container::uninitialized_copy_alloc(this->alloc(), first, mid, *cur_node); first = mid; } @@ -1825,7 +2031,7 @@ } // Called only if this->members_.m_finish.m_cur == this->members_.m_finish.m_first. - void priv_pop_back_aux() BOOST_CONTAINER_NOEXCEPT + void priv_pop_back_aux() BOOST_NOEXCEPT_OR_NOTHROW { this->priv_deallocate_node(this->members_.m_finish.m_first); this->members_.m_finish.priv_set_node(this->members_.m_finish.m_node - 1); @@ -1840,7 +2046,7 @@ // if the deque has at least one element (a precondition for this member // function), and if this->members_.m_start.m_cur == this->members_.m_start.m_last, then the deque // must have at least two nodes. - void priv_pop_front_aux() BOOST_CONTAINER_NOEXCEPT + void priv_pop_front_aux() BOOST_NOEXCEPT_OR_NOTHROW { allocator_traits_type::destroy ( this->alloc() @@ -1849,7 +2055,7 @@ this->priv_deallocate_node(this->members_.m_start.m_first); this->members_.m_start.priv_set_node(this->members_.m_start.m_node + 1); this->members_.m_start.m_cur = this->members_.m_start.m_first; - } + } iterator priv_reserve_elements_at_front(size_type n) { @@ -1869,7 +2075,7 @@ } BOOST_CATCH(...) { for (size_type j = 1; j < i; ++j) - this->priv_deallocate_node(*(this->members_.m_start.m_node - j)); + this->priv_deallocate_node(*(this->members_.m_start.m_node - j)); BOOST_RETHROW } BOOST_CATCH_END @@ -1887,14 +2093,14 @@ if (new_nodes + 1 > s){ this->priv_reallocate_map(new_nodes, false); } - size_type i; + size_type i = 1; BOOST_TRY { - for (i = 1; i <= new_nodes; ++i) + for (; i <= new_nodes; ++i) *(this->members_.m_finish.m_node + i) = this->priv_allocate_node(); } BOOST_CATCH(...) { for (size_type j = 1; j < i; ++j) - this->priv_deallocate_node(*(this->members_.m_finish.m_node + j)); + this->priv_deallocate_node(*(this->members_.m_finish.m_node + j)); BOOST_RETHROW } BOOST_CATCH_END @@ -1912,9 +2118,9 @@ new_nstart = this->members_.m_map + (this->members_.m_map_size - new_num_nodes) / 2 + (add_at_front ? nodes_to_add : 0); if (new_nstart < this->members_.m_start.m_node) - boost::move(this->members_.m_start.m_node, this->members_.m_finish.m_node + 1, new_nstart); + boost::container::move(this->members_.m_start.m_node, this->members_.m_finish.m_node + 1, new_nstart); else - boost::move_backward + boost::container::move_backward (this->members_.m_start.m_node, this->members_.m_finish.m_node + 1, new_nstart + old_num_nodes); } else { @@ -1924,7 +2130,7 @@ index_pointer new_map = this->priv_allocate_map(new_map_size); new_nstart = new_map + (new_map_size - new_num_nodes) / 2 + (add_at_front ? nodes_to_add : 0); - boost::move(this->members_.m_start.m_node, this->members_.m_finish.m_node + 1, new_nstart); + boost::container::move(this->members_.m_start.m_node, this->members_.m_finish.m_node + 1, new_nstart); this->priv_deallocate_map(this->members_.m_map, this->members_.m_map_size); this->members_.m_map = new_map; @@ -1934,45 +2140,12 @@ this->members_.m_start.priv_set_node(new_nstart); this->members_.m_finish.priv_set_node(new_nstart + old_num_nodes - 1); } - /// @endcond + #endif //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED }; -// Nonmember functions. -template <class T, class Allocator> -inline bool operator==(const deque<T, Allocator>& x, const deque<T, Allocator>& y) BOOST_CONTAINER_NOEXCEPT -{ - return x.size() == y.size() && equal(x.begin(), x.end(), y.begin()); -} - -template <class T, class Allocator> -inline bool operator<(const deque<T, Allocator>& x, const deque<T, Allocator>& y) BOOST_CONTAINER_NOEXCEPT -{ - return lexicographical_compare(x.begin(), x.end(), y.begin(), y.end()); -} - -template <class T, class Allocator> -inline bool operator!=(const deque<T, Allocator>& x, const deque<T, Allocator>& y) BOOST_CONTAINER_NOEXCEPT - { return !(x == y); } - -template <class T, class Allocator> -inline bool operator>(const deque<T, Allocator>& x, const deque<T, Allocator>& y) BOOST_CONTAINER_NOEXCEPT - { return y < x; } - -template <class T, class Allocator> -inline bool operator>=(const deque<T, Allocator>& x, const deque<T, Allocator>& y) BOOST_CONTAINER_NOEXCEPT - { return !(x < y); } - -template <class T, class Allocator> -inline bool operator<=(const deque<T, Allocator>& x, const deque<T, Allocator>& y) BOOST_CONTAINER_NOEXCEPT - { return !(y < x); } - -template <class T, class Allocator> -inline void swap(deque<T, Allocator>& x, deque<T, Allocator>& y) -{ x.swap(y); } - }} -/// @cond +#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED namespace boost { @@ -1980,12 +2153,15 @@ //!specialization for optimizations template <class T, class Allocator> struct has_trivial_destructor_after_move<boost::container::deque<T, Allocator> > - : public ::boost::has_trivial_destructor_after_move<Allocator> -{}; +{ + typedef typename ::boost::container::allocator_traits<Allocator>::pointer pointer; + static const bool value = ::boost::has_trivial_destructor_after_move<Allocator>::value && + ::boost::has_trivial_destructor_after_move<pointer>::value; +}; } -/// @endcond +#endif //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED #include <boost/container/detail/config_end.hpp>