#include <boost/container/detail/config_begin.hpp>
#include <boost/container/detail/workaround.hpp>
#include <boost/container/container_fwd.hpp>
#include <memory>
#include <iterator>
#include <utility>
#include <initializer_list>
#include <boost/core/no_exceptions_support.hpp>
#include <boost/assert.hpp>
#include <boost/move/utility_core.hpp>
#include <boost/move/iterator.hpp>
#include <boost/move/algorithm.hpp>
#include <boost/move/detail/move_helpers.hpp>
#include <boost/move/traits.hpp>
#include <boost/container/detail/version_type.hpp>
#include <boost/container/detail/allocation_type.hpp>
#include <boost/container/detail/utilities.hpp>
#include <boost/container/detail/iterators.hpp>
#include <boost/container/detail/algorithms.hpp>
#include <boost/container/detail/destroyers.hpp>
#include <boost/container/allocator_traits.hpp>
#include <boost/container/detail/allocator_version_traits.hpp>
#include <boost/container/throw_exception.hpp>
#include <boost/container/detail/mpl.hpp>
#include <boost/container/detail/type_traits.hpp>
#include <boost/container/detail/advanced_insert_int.hpp>
#include <boost/intrusive/pointer_traits.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/type_traits/has_nothrow_constructor.hpp>
#include <BOOST_PP_LOCAL_ITERATE()>
#include <boost/container/detail/config_end.hpp>

Include dependency graph for vector.hpp:

This graph shows which files directly or indirectly include this file:

Classes
class	boost::container::container_detail::vec_iterator< Pointer, IsConst >

struct	boost::container::container_detail::uninitialized_size_t

struct	boost::container::container_detail::vector_value_traits_base< T >

struct	boost::container::container_detail::vector_value_traits< Allocator >

struct	boost::container::container_detail::vector_alloc_holder< Allocator, AllocatorVersion >
	This struct deallocates and allocated memory. More...

struct	boost::container::container_detail::vector_alloc_holder< Allocator, container_detail::integral_constant< unsigned, 0 > >
	This struct deallocates and allocated memory. More...

class	boost::container::vector< T, BOOST_CONTAINER_DOCONLY >
	A vector is a sequence that supports random access to elements, constant time insertion and removal of elements at the end, and linear time insertion and removal of elements at the beginning or in the middle. More...

Namespaces
	boost
	Duration formatting facet for input.

	boost::container

	boost::container::container_detail

Macros
#define	BOOST_PP_LOCAL_MACRO(n)

#define	BOOST_PP_LOCAL_LIMITS (0, BOOST_CONTAINER_MAX_CONSTRUCTOR_PARAMETERS)

#define	BOOST_PP_LOCAL_MACRO(n)

#define	BOOST_PP_LOCAL_LIMITS (0, BOOST_CONTAINER_MAX_CONSTRUCTOR_PARAMETERS)

Functions
template<class Pointer , bool IsConst>
const Pointer &	boost::container::vector_iterator_get_ptr (const container_detail::vec_iterator< Pointer, IsConst > &it) BOOST_CONTAINER_NOEXCEPT

template<class Pointer , bool IsConst>
Pointer &	boost::container::get_ptr (container_detail::vec_iterator< Pointer, IsConst > &it) BOOST_CONTAINER_NOEXCEPT

Macro Definition Documentation

#define BOOST_PP_LOCAL_LIMITS (0, BOOST_CONTAINER_MAX_CONSTRUCTOR_PARAMETERS)

#define BOOST_PP_LOCAL_MACRO ( n )

Value:

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, _))                              \
   {                                                                                                  \
      T* const back_pos = container_detail::to_raw_pointer                                            \
         (this->m_holder.start()) + this->m_holder.m_size;                                            \
      if (BOOST_LIKELY(this->m_holder.m_size < this->m_holder.capacity())){                                         \
         allocator_traits_type::construct (this->m_holder.alloc()                                     \
            , back_pos BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_PARAM_FORWARD, _) );              \
         ++this->m_holder.m_size;                                                                     \
      }                                                                                               \
      else{                                                                                           \
         typedef container_detail::BOOST_PP_CAT(insert_emplace_proxy_arg, n)                          \
            <Allocator, T* BOOST_PP_ENUM_TRAILING_PARAMS(n, P)> type;                                 \
         this->priv_forward_range_insert_no_capacity                                                  \
            ( vector_iterator_get_ptr(this->cend()), 1                                                \
            , type(BOOST_PP_ENUM(n, BOOST_CONTAINER_PP_PARAM_FORWARD, _)), alloc_version());          \
      }                                                                                               \
   }                                                                                                  \
                                                                                                      \
   BOOST_PP_EXPR_IF(n, template<) BOOST_PP_ENUM_PARAMS(n, class P) BOOST_PP_EXPR_IF(n, >)             \
   iterator emplace(const_iterator pos                                                                \
                    BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_PARAM_LIST, _))                      \
   {                                                                                                  \
      typedef container_detail::BOOST_PP_CAT(insert_emplace_proxy_arg, n)                             \
         <Allocator, T* BOOST_PP_ENUM_TRAILING_PARAMS(n, P)> type;                                    \
      return this->priv_forward_range_insert                                                          \
         ( container_detail::to_raw_pointer(vector_iterator_get_ptr(pos)), 1                          \
         , type(BOOST_PP_ENUM(n, BOOST_CONTAINER_PP_PARAM_FORWARD, _)), alloc_version());             \
   }                                                                                                  \

#define BOOST_PP_LOCAL_MACRO ( n )

Value:

BOOST_PP_EXPR_IF(n, template<) BOOST_PP_ENUM_PARAMS(n, class P) BOOST_PP_EXPR_IF(n, >)    \
   bool stable_emplace_back(BOOST_PP_ENUM(n, BOOST_CONTAINER_PP_PARAM_LIST, _))              \
   {                                                                                         \
      const bool room_enough = this->m_holder.m_size < this->m_holder.capacity();            \
      if (BOOST_LIKELY(room_enough)){                                                                      \
         T* const back_pos = container_detail::to_raw_pointer                                \
            (this->m_holder.start()) + this->m_holder.m_size;                                \
         allocator_traits_type::construct (this->m_holder.alloc()                            \
            , back_pos BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_PARAM_FORWARD, _) );     \
         ++this->m_holder.m_size;                                                            \
      }                                                                                      \
      return room_enough;                                                                    \
   }                                                                                         \

Classes

Namespaces

Macros

Functions

Macro Definition Documentation