proxygen: folly::small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC

#include <small_vector.h>

Inheritance diagram for folly::small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC >:

Classes
union	Data

struct	HeapPtr

struct	HeapPtrWithCapacity

Public Types
typedef std::size_t	size_type

typedef Value	value_type

typedef value_type &	reference

typedef value_type const &	const_reference

typedef value_type *	iterator

typedef value_type *	pointer

typedef value_type const *	const_iterator

typedef value_type const *	const_pointer

typedef std::ptrdiff_t	difference_type

typedef std::reverse_iterator< iterator >	reverse_iterator

typedef std::reverse_iterator< const_iterator >	const_reverse_iterator

Public Member Functions
	small_vector ()=default

	small_vector (const std::allocator< Value > &)

	small_vector (small_vector const &o)

	small_vector (small_vector &&o) noexcept(std::is_nothrow_move_constructible< Value >::value)

	small_vector (std::initializer_list< value_type > il)

	small_vector (size_type n)

	small_vector (size_type n, value_type const &t)

template<class Arg >
	small_vector (Arg arg1, Arg arg2)

	~small_vector ()

small_vector &	operator= (small_vector const &o)

small_vector &	operator= (small_vector &&o)

bool	operator== (small_vector const &o) const

bool	operator< (small_vector const &o) const

size_type	size () const

bool	empty () const

iterator	begin ()

iterator	end ()

const_iterator	begin () const

const_iterator	end () const

const_iterator	cbegin () const

const_iterator	cend () const

reverse_iterator	rbegin ()

reverse_iterator	rend ()

const_reverse_iterator	rbegin () const

const_reverse_iterator	rend () const

const_reverse_iterator	crbegin () const

const_reverse_iterator	crend () const

void	swap (small_vector &o)

void	resize (size_type sz)

void	resize (size_type sz, value_type const &v)

value_type *	data () noexcept

value_type const *	data () const noexcept

template<class... Args>
iterator	emplace (const_iterator p, Args &&...args)

void	reserve (size_type sz)

size_type	capacity () const

void	shrink_to_fit ()

template<class... Args>
void	emplace_back (Args &&...args)

void	push_back (value_type &&t)

void	push_back (value_type const &t)

void	pop_back ()

iterator	insert (const_iterator constp, value_type &&t)

iterator	insert (const_iterator p, value_type const &t)

iterator	insert (const_iterator pos, size_type n, value_type const &val)

template<class Arg >
iterator	insert (const_iterator p, Arg arg1, Arg arg2)

iterator	insert (const_iterator p, std::initializer_list< value_type > il)

iterator	erase (const_iterator q)

iterator	erase (const_iterator q1, const_iterator q2)

void	clear ()

template<class Arg >
void	assign (Arg first, Arg last)

void	assign (std::initializer_list< value_type > il)

void	assign (size_type n, const value_type &t)

reference	front ()

reference	back ()

const_reference	front () const

const_reference	back () const

reference	operator[] (size_type i)

const_reference	operator[] (size_type i) const

reference	at (size_type i)

const_reference	at (size_type i) const

Static Public Member Functions
static constexpr size_type	max_size ()

Private Types
typedef detail::small_vector_base< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC >::type	BaseType

typedef BaseType::InternalSizeType	InternalSizeType

typedef std::aligned_storage< sizeof(value_type)*MaxInline, alignof(value_type)>::type	InlineStorageDataType

typedef std::conditional< sizeof(value_type)MaxInline!=0, InlineStorageDataType, void >::type	InlineStorageType

typedef std::conditional< kHasInlineCapacity, HeapPtrWithCapacity, HeapPtr >::type	PointerType

Private Member Functions
template<class It >
iterator	insertImpl (iterator pos, It first, It last, std::false_type)

iterator	insertImpl (iterator pos, size_type n, const value_type &val, std::true_type)

template<class It >
void	constructImpl (It first, It last, std::false_type)

template<typename InitFunc >
void	doConstruct (size_type n, InitFunc &&func)

void	constructImpl (size_type n, value_type const &val, std::true_type)

size_type	computeNewSize () const

void	makeSize (size_type newSize)

template<typename EmplaceFunc >
void	makeSize (size_type newSize, EmplaceFunc &&emplaceFunc, size_type pos)

template<typename EmplaceFunc >
void	makeSizeInternal (size_type newSize, bool insert, EmplaceFunc &&emplaceFunc, size_type pos)

void	setCapacity (size_type newCapacity)

Static Private Member Functions
static iterator	unconst (const_iterator it)

Private Attributes
union folly::small_vector::Data	u

Static Private Attributes
static constexpr std::size_t	MaxInline

static bool constexpr	kHasInlineCapacity

static size_t constexpr	kHeapifyCapacitySize

static size_t constexpr	kHeapifyCapacityThreshold

Detailed Description

template<class Value, std::size_t RequestedMaxInline = 1, class PolicyA = void, class PolicyB = void, class PolicyC = void>
class folly::small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC >

Definition at line 92 of file small_vector.h.

Member Typedef Documentation

template<class Value, std::size_t RequestedMaxInline = 1, class PolicyA = void, class PolicyB = void, class PolicyC = void>

typedef detail:: small_vector_base<Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC>:: type folly::small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC >::BaseType

private

Definition at line 411 of file small_vector.h.

template<class Value, std::size_t RequestedMaxInline = 1, class PolicyA = void, class PolicyB = void, class PolicyC = void>

typedef value_type const* folly::small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC >::const_iterator

Definition at line 429 of file small_vector.h.

template<class Value, std::size_t RequestedMaxInline = 1, class PolicyA = void, class PolicyB = void, class PolicyC = void>

typedef value_type const* folly::small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC >::const_pointer

Definition at line 430 of file small_vector.h.

template<class Value, std::size_t RequestedMaxInline = 1, class PolicyA = void, class PolicyB = void, class PolicyC = void>

typedef value_type const& folly::small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC >::const_reference

Definition at line 426 of file small_vector.h.

template<class Value, std::size_t RequestedMaxInline = 1, class PolicyA = void, class PolicyB = void, class PolicyC = void>

typedef std::reverse_iterator<const_iterator> folly::small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC >::const_reverse_iterator

Definition at line 434 of file small_vector.h.

template<class Value, std::size_t RequestedMaxInline = 1, class PolicyA = void, class PolicyB = void, class PolicyC = void>

typedef std::ptrdiff_t folly::small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC >::difference_type

Definition at line 431 of file small_vector.h.

template<class Value, std::size_t RequestedMaxInline = 1, class PolicyA = void, class PolicyB = void, class PolicyC = void>

typedef std::aligned_storage< sizeof(value_type) * MaxInline, alignof(value_type)>::type folly::small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC >::InlineStorageDataType

private

Definition at line 1129 of file small_vector.h.

template<class Value, std::size_t RequestedMaxInline = 1, class PolicyA = void, class PolicyB = void, class PolicyC = void>

typedef std::conditional< sizeof(value_type) * MaxInline != 0, InlineStorageDataType, void*>::type folly::small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC >::InlineStorageType

private

Definition at line 1134 of file small_vector.h.

template<class Value, std::size_t RequestedMaxInline = 1, class PolicyA = void, class PolicyB = void, class PolicyC = void>

typedef BaseType::InternalSizeType folly::small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC >::InternalSizeType

private

Definition at line 412 of file small_vector.h.

template<class Value, std::size_t RequestedMaxInline = 1, class PolicyA = void, class PolicyB = void, class PolicyC = void>

typedef value_type* folly::small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC >::iterator

Definition at line 427 of file small_vector.h.

template<class Value, std::size_t RequestedMaxInline = 1, class PolicyA = void, class PolicyB = void, class PolicyC = void>

typedef value_type* folly::small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC >::pointer

Definition at line 428 of file small_vector.h.

template<class Value, std::size_t RequestedMaxInline = 1, class PolicyA = void, class PolicyB = void, class PolicyC = void>

typedef std:: conditional<kHasInlineCapacity, HeapPtrWithCapacity, HeapPtr>::type folly::small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC >::PointerType

private

Definition at line 1150 of file small_vector.h.

template<class Value, std::size_t RequestedMaxInline = 1, class PolicyA = void, class PolicyB = void, class PolicyC = void>

typedef value_type& folly::small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC >::reference

Definition at line 425 of file small_vector.h.

template<class Value, std::size_t RequestedMaxInline = 1, class PolicyA = void, class PolicyB = void, class PolicyC = void>

typedef std::reverse_iterator<iterator> folly::small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC >::reverse_iterator

Definition at line 433 of file small_vector.h.

template<class Value, std::size_t RequestedMaxInline = 1, class PolicyA = void, class PolicyB = void, class PolicyC = void>

typedef std::size_t folly::small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC >::size_type

Definition at line 423 of file small_vector.h.

template<class Value, std::size_t RequestedMaxInline = 1, class PolicyA = void, class PolicyB = void, class PolicyC = void>

typedef Value folly::small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC >::value_type

Definition at line 424 of file small_vector.h.

Constructor & Destructor Documentation

template<class Value, std::size_t RequestedMaxInline = 1, class PolicyA = void, class PolicyB = void, class PolicyC = void>

folly::small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC >::small_vector ( )

default

template<class Value, std::size_t RequestedMaxInline = 1, class PolicyA = void, class PolicyB = void, class PolicyC = void>

folly::small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC >::small_vector ( const std::allocator< Value > & )

inline

Definition at line 439 of file small_vector.h.

439 {}

template<class Value, std::size_t RequestedMaxInline = 1, class PolicyA = void, class PolicyB = void, class PolicyC = void>

folly::small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC >::small_vector ( small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC > const & o )

inline

Definition at line 441 of file small_vector.h.

                                       {
     auto n = o.size();
     makeSize(n);
     try {
       std::uninitialized_copy(o.begin(), o.end(), begin());
     } catch (...) {
       if (this->isExtern()) {
         u.freeHeap();
       }
       throw;
     }
     this->setSize(n);
   }

template<class Value, std::size_t RequestedMaxInline = 1, class PolicyA = void, class PolicyB = void, class PolicyC = void>

folly::small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC >::small_vector ( small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC > && o )

inlinenoexcept

Definition at line 455 of file small_vector.h.

                                                     {
     if (o.isExtern()) {
       swap(o);
     } else {
       std::uninitialized_copy(
           std::make_move_iterator(o.begin()),
           std::make_move_iterator(o.end()),
           begin());
       this->setSize(o.size());
     }
   }

template<class Value, std::size_t RequestedMaxInline = 1, class PolicyA = void, class PolicyB = void, class PolicyC = void>

folly::small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC >::small_vector ( std::initializer_list< value_type > il )

inline

Definition at line 468 of file small_vector.h.

                                                    {
     constructImpl(il.begin(), il.end(), std::false_type());
   }

template<class Value, std::size_t RequestedMaxInline = 1, class PolicyA = void, class PolicyB = void, class PolicyC = void>

folly::small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC >::small_vector ( size_type n )

inlineexplicit

Definition at line 472 of file small_vector.h.

                                      {
     doConstruct(n, [&](void* p) { new (p) value_type(); });
   }

template<class Value, std::size_t RequestedMaxInline = 1, class PolicyA = void, class PolicyB = void, class PolicyC = void>

folly::small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC >::small_vector	(	size_type	n,
		value_type const &	t
	)

inline

Definition at line 476 of file small_vector.h.

                                                  {
     doConstruct(n, [&](void* p) { new (p) value_type(t); });
   }

template<class Value, std::size_t RequestedMaxInline = 1, class PolicyA = void, class PolicyB = void, class PolicyC = void>

template<class Arg >

folly::small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC >::small_vector	(	Arg	arg1,
		Arg	arg2
	)

inlineexplicit

Definition at line 481 of file small_vector.h.

                                             {
     // Forward using std::is_arithmetic to get to the proper
     // implementation; this disambiguates between the iterators and
     // (size_t, value_type) meaning for this constructor.
     constructImpl(arg1, arg2, std::is_arithmetic<Arg>());
   }

template<class Value, std::size_t RequestedMaxInline = 1, class PolicyA = void, class PolicyB = void, class PolicyC = void>

folly::small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC >::~small_vector ( )

inline

Definition at line 488 of file small_vector.h.

                   {
     for (auto& t : *this) {
       (&t)->~value_type();
     }
     if (this->isExtern()) {
       u.freeHeap();
     }
   }

Member Function Documentation

template<class Value, std::size_t RequestedMaxInline = 1, class PolicyA = void, class PolicyB = void, class PolicyC = void>

template<class Arg >

void folly::small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC >::assign	(	Arg	first,
		Arg	last
	)

inline

Definition at line 846 of file small_vector.h.

Referenced by TEST().

                                    {
     clear();
     insert(end(), first, last);
   }

template<class Value, std::size_t RequestedMaxInline = 1, class PolicyA = void, class PolicyB = void, class PolicyC = void>

void folly::small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC >::assign ( std::initializer_list< value_type > il )

inline

Definition at line 851 of file small_vector.h.

                                                   {
     assign(il.begin(), il.end());
   }

template<class Value, std::size_t RequestedMaxInline = 1, class PolicyA = void, class PolicyB = void, class PolicyC = void>

void folly::small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC >::assign	(	size_type	n,
		const value_type &	t
	)

inline

Definition at line 855 of file small_vector.h.

                                                 {
     clear();
     insert(end(), n, t);
   }

template<class Value, std::size_t RequestedMaxInline = 1, class PolicyA = void, class PolicyB = void, class PolicyC = void>

reference folly::small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC >::at ( size_type i )

inline

Definition at line 887 of file small_vector.h.

                             {
     if (i >= size()) {
       throw_exception<std::out_of_range>("index out of range");
     }
     return (*this)[i];
   }

template<class Value, std::size_t RequestedMaxInline = 1, class PolicyA = void, class PolicyB = void, class PolicyC = void>

const_reference folly::small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC >::at ( size_type i ) const

inline

Definition at line 894 of file small_vector.h.

                                         {
     if (i >= size()) {
       throw_exception<std::out_of_range>("index out of range");
     }
     return (*this)[i];
   }

template<class Value, std::size_t RequestedMaxInline = 1, class PolicyA = void, class PolicyB = void, class PolicyC = void>

reference folly::small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC >::back ( )

inline

Definition at line 864 of file small_vector.h.

Referenced by TEST().

                    {
     assert(!empty());
     return *(end() - 1);
   }

template<class Value, std::size_t RequestedMaxInline = 1, class PolicyA = void, class PolicyB = void, class PolicyC = void>

const_reference folly::small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC >::back ( ) const

inline

Definition at line 872 of file small_vector.h.

                                {
     assert(!empty());
     return *(end() - 1);
   }

template<class Value, std::size_t RequestedMaxInline = 1, class PolicyA = void, class PolicyB = void, class PolicyC = void>

iterator folly::small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC >::begin ( )

inline

Definition at line 534 of file small_vector.h.

Referenced by folly::small_vector< Observer< T > *, InlineObservers >::operator<(), folly::small_vector< Observer< T > *, InlineObservers >::operator=(), folly::small_vector< Observer< T > *, InlineObservers >::operator==(), folly::small_vector< Observer< T > *, InlineObservers >::small_vector(), and TEST().

                    {
     return data();
   }

template<class Value, std::size_t RequestedMaxInline = 1, class PolicyA = void, class PolicyB = void, class PolicyC = void>

const_iterator folly::small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC >::begin ( ) const

inline

Definition at line 540 of file small_vector.h.

                                {
     return data();
   }

template<class Value, std::size_t RequestedMaxInline = 1, class PolicyA = void, class PolicyB = void, class PolicyC = void>

size_type folly::small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC >::capacity ( ) const

inline

Definition at line 722 of file small_vector.h.

Referenced by folly::small_vector< Observer< T > *, InlineObservers >::swap(), and TEST().

                              {
     if (this->isExtern()) {
       if (u.hasCapacity()) {
         return u.getCapacity();
       }
       return malloc_usable_size(u.pdata_.heap_) / sizeof(value_type);
     }
     return MaxInline;
   }

template<class Value, std::size_t RequestedMaxInline = 1, class PolicyA = void, class PolicyB = void, class PolicyC = void>

const_iterator folly::small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC >::cbegin ( ) const

inline

Definition at line 546 of file small_vector.h.

                                 {
     return begin();
   }

template<class Value, std::size_t RequestedMaxInline = 1, class PolicyA = void, class PolicyB = void, class PolicyC = void>

const_iterator folly::small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC >::cend ( ) const

inline

Definition at line 549 of file small_vector.h.

                               {
     return end();
   }

template<class Value, std::size_t RequestedMaxInline = 1, class PolicyA = void, class PolicyB = void, class PolicyC = void>

void folly::small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC >::clear ( )

inline

Definition at line 841 of file small_vector.h.

                {
     erase(begin(), end());
   }

template<class Value, std::size_t RequestedMaxInline = 1, class PolicyA = void, class PolicyB = void, class PolicyC = void>

size_type folly::small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC >::computeNewSize ( ) const

inlineprivate

Definition at line 989 of file small_vector.h.

                                    {
     return std::min((3 * capacity()) / 2 + 1, max_size());
   }

template<class Value, std::size_t RequestedMaxInline = 1, class PolicyA = void, class PolicyB = void, class PolicyC = void>

template<class It >

void folly::small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC >::constructImpl	(	It	first,
		It	last,
		std::false_type
	)

inlineprivate

Definition at line 941 of file small_vector.h.

                                                        {
     typedef typename std::iterator_traits<It>::iterator_category categ;
     if (std::is_same<categ, std::input_iterator_tag>::value) {
       // With iterators that only allow a single pass, we can't really
       // do anything sane here.
       while (first != last) {
         emplace_back(*first++);
       }
       return;
     }
 
     auto distance = std::distance(first, last);
     makeSize(distance);
     this->setSize(distance);
     try {
       detail::populateMemForward(
           data(), distance, [&](void* p) { new (p) value_type(*first++); });
     } catch (...) {
       if (this->isExtern()) {
         u.freeHeap();
       }
       throw;
     }
   }

template<class Value, std::size_t RequestedMaxInline = 1, class PolicyA = void, class PolicyB = void, class PolicyC = void>

void folly::small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC >::constructImpl	(	size_type	n,
		value_type const &	val,
		std::true_type
	)

inlineprivate

Definition at line 982 of file small_vector.h.

                                                                        {
     doConstruct(n, [&](void* p) { new (p) value_type(val); });
   }

template<class Value, std::size_t RequestedMaxInline = 1, class PolicyA = void, class PolicyB = void, class PolicyC = void>

const_reverse_iterator folly::small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC >::crbegin ( ) const

inline

Definition at line 568 of file small_vector.h.

                                          {
     return rbegin();
   }

template<class Value, std::size_t RequestedMaxInline = 1, class PolicyA = void, class PolicyB = void, class PolicyC = void>

const_reverse_iterator folly::small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC >::crend ( ) const

inline

Definition at line 571 of file small_vector.h.

                                        {
     return rend();
   }

template<class Value, std::size_t RequestedMaxInline = 1, class PolicyA = void, class PolicyB = void, class PolicyC = void>

value_type* folly::small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC >::data ( )

inlinenoexcept

Definition at line 684 of file small_vector.h.

                               {
     return this->isExtern() ? u.heap() : u.buffer();
   }

template<class Value, std::size_t RequestedMaxInline = 1, class PolicyA = void, class PolicyB = void, class PolicyC = void>

value_type const* folly::small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC >::data ( ) const

inlinenoexcept

Definition at line 688 of file small_vector.h.

                                           {
     return this->isExtern() ? u.heap() : u.buffer();
   }

template<class Value, std::size_t RequestedMaxInline = 1, class PolicyA = void, class PolicyB = void, class PolicyC = void>

template<typename InitFunc >

void folly::small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC >::doConstruct	(	size_type	n,
		InitFunc &&	func
	)

inlineprivate

Definition at line 967 of file small_vector.h.

                                                  {
     makeSize(n);
     this->setSize(n);
     try {
       detail::populateMemForward(data(), n, std::forward<InitFunc>(func));
     } catch (...) {
       if (this->isExtern()) {
         u.freeHeap();
       }
       throw;
     }
   }

template<class Value, std::size_t RequestedMaxInline = 1, class PolicyA = void, class PolicyB = void, class PolicyC = void>

template<class... Args>

iterator folly::small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC >::emplace	(	const_iterator	p,
		Args &&...	args
	)

inline

Definition at line 693 of file small_vector.h.

Referenced by TEST().

                                                      {
     if (p == cend()) {
       emplace_back(std::forward<Args>(args)...);
       return end() - 1;
     }
 
     /*
      * We implement emplace at places other than at the back with a
      * temporary for exception safety reasons.  It is possible to
      * avoid having to do this, but it becomes hard to maintain the
      * basic exception safety guarantee (unless you respond to a copy
      * constructor throwing by clearing the whole vector).
      *
      * The reason for this is that otherwise you have to destruct an
      * element before constructing this one in its place---if the
      * constructor throws, you either need a nothrow default
      * constructor or a nothrow copy/move to get something back in the
      * "gap", and the vector requirements don't guarantee we have any
      * of these.  Clearing the whole vector is a legal response in
      * this situation, but it seems like this implementation is easy
      * enough and probably better.
      */
     return insert(p, value_type(std::forward<Args>(args)...));
   }

template<class Value, std::size_t RequestedMaxInline = 1, class PolicyA = void, class PolicyB = void, class PolicyC = void>

template<class... Args>

void folly::small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC >::emplace_back ( Args &&... args )

inline

Definition at line 742 of file small_vector.h.

Referenced by TEST().

                                     {
     if (capacity() == size()) {
       // Any of args may be references into the vector.
       // When we are reallocating, we have to be careful to construct the new
       // element before modifying the data in the old buffer.
       makeSize(
           size() + 1,
           [&](void* p) { new (p) value_type(std::forward<Args>(args)...); },
           size());
     } else {
       new (end()) value_type(std::forward<Args>(args)...);
     }
     this->setSize(size() + 1);
   }

template<class Value, std::size_t RequestedMaxInline = 1, class PolicyA = void, class PolicyB = void, class PolicyC = void>

bool folly::small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC >::empty ( ) const

inline

Definition at line 530 of file small_vector.h.

Referenced by TEST().

                      {
     return !size();
   }

template<class Value, std::size_t RequestedMaxInline = 1, class PolicyA = void, class PolicyB = void, class PolicyC = void>

iterator folly::small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC >::end ( )

inline

Definition at line 537 of file small_vector.h.

                  {
     return data() + size();
   }

template<class Value, std::size_t RequestedMaxInline = 1, class PolicyA = void, class PolicyB = void, class PolicyC = void>

const_iterator folly::small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC >::end ( ) const

inline

Definition at line 543 of file small_vector.h.

                              {
     return data() + size();
   }

template<class Value, std::size_t RequestedMaxInline = 1, class PolicyA = void, class PolicyB = void, class PolicyC = void>

iterator folly::small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC >::erase ( const_iterator q )

inline

Definition at line 822 of file small_vector.h.

Referenced by TEST().

                                    {
     std::move(unconst(q) + 1, end(), unconst(q));
     (data() + size() - 1)->~value_type();
     this->setSize(size() - 1);
     return unconst(q);
   }

template<class Value, std::size_t RequestedMaxInline = 1, class PolicyA = void, class PolicyB = void, class PolicyC = void>

iterator folly::small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC >::erase	(	const_iterator	q1,
		const_iterator	q2
	)

inline

Definition at line 829 of file small_vector.h.

                                                        {
     if (q1 == q2) {
       return unconst(q1);
     }
     std::move(unconst(q2), end(), unconst(q1));
     for (auto it = (end() - std::distance(q1, q2)); it != end(); ++it) {
       it->~value_type();
     }
     this->setSize(size() - (q2 - q1));
     return unconst(q1);
   }

template<class Value, std::size_t RequestedMaxInline = 1, class PolicyA = void, class PolicyB = void, class PolicyC = void>

reference folly::small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC >::front ( )

inline

Definition at line 860 of file small_vector.h.

Referenced by TEST().

                     {
     assert(!empty());
     return *begin();
   }

template<class Value, std::size_t RequestedMaxInline = 1, class PolicyA = void, class PolicyB = void, class PolicyC = void>

const_reference folly::small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC >::front ( ) const

inline

Definition at line 868 of file small_vector.h.

                                 {
     assert(!empty());
     return *begin();
   }

template<class Value, std::size_t RequestedMaxInline = 1, class PolicyA = void, class PolicyB = void, class PolicyC = void>

iterator folly::small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC >::insert	(	const_iterator	constp,
		value_type &&	t
	)

inline

Definition at line 769 of file small_vector.h.

Referenced by TEST().

                                                          {
     iterator p = unconst(constp);
 
     if (p == end()) {
       push_back(std::move(t));
       return end() - 1;
     }
 
     auto offset = p - begin();
 
     if (capacity() == size()) {
       makeSize(
           size() + 1,
           [&t](void* ptr) { new (ptr) value_type(std::move(t)); },
           offset);
       this->setSize(this->size() + 1);
     } else {
       detail::moveObjectsRight(
           data() + offset, data() + size(), data() + size() + 1);
       this->setSize(size() + 1);
       data()[offset] = std::move(t);
     }
     return begin() + offset;
   }

template<class Value, std::size_t RequestedMaxInline = 1, class PolicyA = void, class PolicyB = void, class PolicyC = void>

iterator folly::small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC >::insert	(	const_iterator	p,
		value_type const &	t
	)

inline

Definition at line 794 of file small_vector.h.

                                                          {
     // Make a copy and forward to the rvalue value_type&& overload
     // above.
     return insert(p, value_type(t));
   }

template<class Value, std::size_t RequestedMaxInline = 1, class PolicyA = void, class PolicyB = void, class PolicyC = void>

iterator folly::small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC >::insert	(	const_iterator	pos,
		size_type	n,
		value_type const &	val
	)

inline

Definition at line 800 of file small_vector.h.

                                                                           {
     auto offset = pos - begin();
     makeSize(size() + n);
     detail::moveObjectsRight(
         data() + offset, data() + size(), data() + size() + n);
     this->setSize(size() + n);
     std::generate_n(begin() + offset, n, [&] { return val; });
     return begin() + offset;
   }

template<class Value, std::size_t RequestedMaxInline = 1, class PolicyA = void, class PolicyB = void, class PolicyC = void>

template<class Arg >

iterator folly::small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC >::insert	(	const_iterator	p,
		Arg	arg1,
		Arg	arg2
	)

inline

Definition at line 811 of file small_vector.h.

                                                         {
     // Forward using std::is_arithmetic to get to the proper
     // implementation; this disambiguates between the iterators and
     // (size_t, value_type) meaning for this function.
     return insertImpl(unconst(p), arg1, arg2, std::is_arithmetic<Arg>());
   }

template<class Value, std::size_t RequestedMaxInline = 1, class PolicyA = void, class PolicyB = void, class PolicyC = void>

iterator folly::small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC >::insert	(	const_iterator	p,
		std::initializer_list< value_type >	il
	)

inline

Definition at line 818 of file small_vector.h.

                                                                         {
     return insert(p, il.begin(), il.end());
   }

template<class Value, std::size_t RequestedMaxInline = 1, class PolicyA = void, class PolicyB = void, class PolicyC = void>

template<class It >

iterator folly::small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC >::insertImpl	(	iterator	pos,
		It	first,
		It	last,
		std::false_type
	)

inlineprivate

Definition at line 909 of file small_vector.h.

                                                                       {
     typedef typename std::iterator_traits<It>::iterator_category categ;
     if (std::is_same<categ, std::input_iterator_tag>::value) {
       auto offset = pos - begin();
       while (first != last) {
         pos = insert(pos, *first++);
         ++pos;
       }
       return begin() + offset;
     }
 
     auto distance = std::distance(first, last);
     auto offset = pos - begin();
     makeSize(size() + distance);
     detail::moveObjectsRight(
         data() + offset, data() + size(), data() + size() + distance);
     this->setSize(size() + distance);
     std::copy_n(first, distance, begin() + offset);
     return begin() + offset;
   }

template<class Value, std::size_t RequestedMaxInline = 1, class PolicyA = void, class PolicyB = void, class PolicyC = void>

iterator folly::small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC >::insertImpl	(	iterator	pos,
		size_type	n,
		const value_type &	val,
		std::true_type
	)

inlineprivate

Definition at line 931 of file small_vector.h.

                                                                              {
     // The true_type means this should call the size_t,value_type
     // overload.  (See insert().)
     return insert(pos, n, val);
   }

template<class Value, std::size_t RequestedMaxInline = 1, class PolicyA = void, class PolicyB = void, class PolicyC = void>

void folly::small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC >::makeSize ( size_type newSize )

inlineprivate

Definition at line 993 of file small_vector.h.

                                    {
     makeSizeInternal(newSize, false, [](void*) { assume_unreachable(); }, 0);
   }

template<class Value, std::size_t RequestedMaxInline = 1, class PolicyA = void, class PolicyB = void, class PolicyC = void>

template<typename EmplaceFunc >

void folly::small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC >::makeSize	(	size_type	newSize,
		EmplaceFunc &&	emplaceFunc,
		size_type	pos
	)

inlineprivate

Definition at line 998 of file small_vector.h.

                                                                              {
     assert(size() == capacity());
     makeSizeInternal(
         newSize, true, std::forward<EmplaceFunc>(emplaceFunc), pos);
   }

template<class Value, std::size_t RequestedMaxInline = 1, class PolicyA = void, class PolicyB = void, class PolicyC = void>

template<typename EmplaceFunc >

void folly::small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC >::makeSizeInternal	(	size_type	newSize,
		bool	insert,
		EmplaceFunc &&	emplaceFunc,
		size_type	pos
	)

inlineprivate

Definition at line 1015 of file small_vector.h.

                      {
     if (newSize > max_size()) {
       throw std::length_error("max_size exceeded in small_vector");
     }
     if (newSize <= capacity()) {
       assert(!insert);
       return;
     }
 
     assert(this->kShouldUseHeap);
     // This branch isn't needed for correctness, but allows the optimizer to
     // skip generating code for the rest of this function in NoHeap
     // small_vectors.
     if (!this->kShouldUseHeap) {
       return;
     }
 
     newSize = std::max(newSize, computeNewSize());
 
     auto needBytes = newSize * sizeof(value_type);
     // If the capacity isn't explicitly stored inline, but the heap
     // allocation is grown to over some threshold, we should store
     // a capacity at the front of the heap allocation.
     bool heapifyCapacity =
         !kHasInlineCapacity && needBytes > kHeapifyCapacityThreshold;
     if (heapifyCapacity) {
       needBytes += kHeapifyCapacitySize;
     }
     auto const sizeBytes = goodMallocSize(needBytes);
     void* newh = checkedMalloc(sizeBytes);
     // We expect newh to be at least 2-aligned, because we want to
     // use its least significant bit as a flag.
     assert(!detail::pointerFlagGet(newh));
 
     value_type* newp = static_cast<value_type*>(
         heapifyCapacity ? detail::shiftPointer(newh, kHeapifyCapacitySize)
                         : newh);
 
     try {
       if (insert) {
         // move and insert the new element
         this->moveToUninitializedEmplace(
             begin(), end(), newp, pos, std::forward<EmplaceFunc>(emplaceFunc));
       } else {
         // move without inserting new element
         this->moveToUninitialized(begin(), end(), newp);
       }
     } catch (...) {
       free(newh);
       throw;
     }
     for (auto& val : *this) {
       val.~value_type();
     }
 
     if (this->isExtern()) {
       u.freeHeap();
     }
     auto availableSizeBytes = sizeBytes;
     if (heapifyCapacity) {
       u.pdata_.heap_ = detail::pointerFlagSet(newh);
       availableSizeBytes -= kHeapifyCapacitySize;
     } else {
       u.pdata_.heap_ = newh;
     }
     this->setExtern(true);
     this->setCapacity(availableSizeBytes / sizeof(value_type));
   }

template<class Value, std::size_t RequestedMaxInline = 1, class PolicyA = void, class PolicyB = void, class PolicyC = void>

static constexpr size_type folly::small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC >::max_size ( )

inlinestatic

Definition at line 522 of file small_vector.h.

Referenced by TEST().

                                         {
     return !BaseType::kShouldUseHeap ? static_cast<size_type>(MaxInline)
                                      : BaseType::policyMaxSize();
   }

template<class Value, std::size_t RequestedMaxInline = 1, class PolicyA = void, class PolicyB = void, class PolicyC = void>

bool folly::small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC >::operator< ( small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC > const & o ) const

inline

Definition at line 518 of file small_vector.h.

                                               {
     return std::lexicographical_compare(begin(), end(), o.begin(), o.end());
   }

template<class Value, std::size_t RequestedMaxInline = 1, class PolicyA = void, class PolicyB = void, class PolicyC = void>

small_vector& folly::small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC >::operator= ( small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC > const & o )

inline

Definition at line 497 of file small_vector.h.

                                                  {
     if (FOLLY_LIKELY(this != &o)) {
       assign(o.begin(), o.end());
     }
     return *this;
   }

template<class Value, std::size_t RequestedMaxInline = 1, class PolicyA = void, class PolicyB = void, class PolicyC = void>

small_vector& folly::small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC >::operator= ( small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC > && o )

inline

Definition at line 504 of file small_vector.h.

                                             {
     // TODO: optimization:
     // if both are internal, use move assignment where possible
     if (FOLLY_LIKELY(this != &o)) {
       clear();
       swap(o);
     }
     return *this;
   }

template<class Value, std::size_t RequestedMaxInline = 1, class PolicyA = void, class PolicyB = void, class PolicyC = void>

bool folly::small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC >::operator== ( small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC > const & o ) const

inline

Definition at line 514 of file small_vector.h.

                                                {
     return size() == o.size() && std::equal(begin(), end(), o.begin());
   }

template<class Value, std::size_t RequestedMaxInline = 1, class PolicyA = void, class PolicyB = void, class PolicyC = void>

reference folly::small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC >::operator[] ( size_type i )

inline

Definition at line 877 of file small_vector.h.

                                     {
     assert(i < size());
     return *(begin() + i);
   }

template<class Value, std::size_t RequestedMaxInline = 1, class PolicyA = void, class PolicyB = void, class PolicyC = void>

const_reference folly::small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC >::operator[] ( size_type i ) const

inline

Definition at line 882 of file small_vector.h.

                                                 {
     assert(i < size());
     return *(begin() + i);
   }

template<class Value, std::size_t RequestedMaxInline = 1, class PolicyA = void, class PolicyB = void, class PolicyC = void>

void folly::small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC >::pop_back ( )

inline

Definition at line 765 of file small_vector.h.

                   {
     erase(end() - 1);
   }

template<class Value, std::size_t RequestedMaxInline = 1, class PolicyA = void, class PolicyB = void, class PolicyC = void>

void folly::small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC >::push_back ( value_type && t )

inline

Definition at line 757 of file small_vector.h.

Referenced by wangle::Observable< T >::forEachObserver(), wangle::Observable< T >::observe(), and TEST().

                                  {
     return emplace_back(std::move(t));
   }

template<class Value, std::size_t RequestedMaxInline = 1, class PolicyA = void, class PolicyB = void, class PolicyC = void>

void folly::small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC >::push_back ( value_type const & t )

inline

Definition at line 761 of file small_vector.h.

                                       {
     emplace_back(t);
   }

template<class Value, std::size_t RequestedMaxInline = 1, class PolicyA = void, class PolicyB = void, class PolicyC = void>

reverse_iterator folly::small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC >::rbegin ( )

inline

Definition at line 553 of file small_vector.h.

                             {
     return reverse_iterator(end());
   }

template<class Value, std::size_t RequestedMaxInline = 1, class PolicyA = void, class PolicyB = void, class PolicyC = void>

const_reverse_iterator folly::small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC >::rbegin ( ) const

inline

Definition at line 560 of file small_vector.h.

                                         {
     return const_reverse_iterator(end());
   }

template<class Value, std::size_t RequestedMaxInline = 1, class PolicyA = void, class PolicyB = void, class PolicyC = void>

reverse_iterator folly::small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC >::rend ( )

inline

Definition at line 556 of file small_vector.h.

                           {
     return reverse_iterator(begin());
   }

template<class Value, std::size_t RequestedMaxInline = 1, class PolicyA = void, class PolicyB = void, class PolicyC = void>

const_reverse_iterator folly::small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC >::rend ( ) const

inline

Definition at line 564 of file small_vector.h.

                                       {
     return const_reverse_iterator(begin());
   }

template<class Value, std::size_t RequestedMaxInline = 1, class PolicyA = void, class PolicyB = void, class PolicyC = void>

void folly::small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC >::reserve ( size_type sz )

inline

Definition at line 718 of file small_vector.h.

Referenced by TEST().

                              {
     makeSize(sz);
   }

template<class Value, std::size_t RequestedMaxInline = 1, class PolicyA = void, class PolicyB = void, class PolicyC = void>

void folly::small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC >::resize ( size_type sz )

inline

Definition at line 662 of file small_vector.h.

Referenced by TEST().

                             {
     if (sz < size()) {
       erase(begin() + sz, end());
       return;
     }
     makeSize(sz);
     detail::populateMemForward(
         begin() + size(), sz - size(), [&](void* p) { new (p) value_type(); });
     this->setSize(sz);
   }

template<class Value, std::size_t RequestedMaxInline = 1, class PolicyA = void, class PolicyB = void, class PolicyC = void>

void folly::small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC >::resize	(	size_type	sz,
		value_type const &	v
	)

inline

Definition at line 673 of file small_vector.h.

                                                  {
     if (sz < size()) {
       erase(begin() + sz, end());
       return;
     }
     makeSize(sz);
     detail::populateMemForward(
         begin() + size(), sz - size(), [&](void* p) { new (p) value_type(v); });
     this->setSize(sz);
   }

template<class Value, std::size_t RequestedMaxInline = 1, class PolicyA = void, class PolicyB = void, class PolicyC = void>

void folly::small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC >::setCapacity ( size_type newCapacity )

inlineprivate

Definition at line 1092 of file small_vector.h.

Referenced by folly::small_vector< Observer< T > *, InlineObservers >::swap().

                                           {
     assert(this->isExtern());
     if (u.hasCapacity()) {
       assert(newCapacity < std::numeric_limits<InternalSizeType>::max());
       u.setCapacity(newCapacity);
     }
   }

template<class Value, std::size_t RequestedMaxInline = 1, class PolicyA = void, class PolicyB = void, class PolicyC = void>

void folly::small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC >::shrink_to_fit ( )

inline

Definition at line 732 of file small_vector.h.

Referenced by TEST().

                        {
     if (!this->isExtern()) {
       return;
     }
 
     small_vector tmp(begin(), end());
     tmp.swap(*this);
   }

template<class Value, std::size_t RequestedMaxInline = 1, class PolicyA = void, class PolicyB = void, class PolicyC = void>

size_type folly::small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC >::size ( ) const

inline

Definition at line 527 of file small_vector.h.

Referenced by folly::small_vector< Observer< T > *, InlineObservers >::operator==(), folly::small_vector< Observer< T > *, InlineObservers >::small_vector(), folly::small_vector< Observer< T > *, InlineObservers >::swap(), and TEST().

                          {
     return this->doSize();
   }

template<class Value, std::size_t RequestedMaxInline = 1, class PolicyA = void, class PolicyB = void, class PolicyC = void>

void folly::small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC >::swap ( small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC > & o )

inline

Definition at line 583 of file small_vector.h.

Referenced by folly::small_vector< Observer< T > *, InlineObservers >::shrink_to_fit(), and folly::swap().

                              {
     using std::swap; // Allow ADL on swap for our value_type.
 
     if (this->isExtern() && o.isExtern()) {
       this->swapSizePolicy(o);
 
       auto thisCapacity = this->capacity();
       auto oCapacity = o.capacity();
 
       auto* tmp = u.pdata_.heap_;
       u.pdata_.heap_ = o.u.pdata_.heap_;
       o.u.pdata_.heap_ = tmp;
 
       this->setCapacity(oCapacity);
       o.setCapacity(thisCapacity);
 
       return;
     }
 
     if (!this->isExtern() && !o.isExtern()) {
       auto& oldSmall = size() < o.size() ? *this : o;
       auto& oldLarge = size() < o.size() ? o : *this;
 
       for (size_type i = 0; i < oldSmall.size(); ++i) {
         swap(oldSmall[i], oldLarge[i]);
       }
 
       size_type i = oldSmall.size();
       const size_type ci = i;
       try {
         for (; i < oldLarge.size(); ++i) {
           auto addr = oldSmall.begin() + i;
           new (addr) value_type(std::move(oldLarge[i]));
           oldLarge[i].~value_type();
         }
       } catch (...) {
         oldSmall.setSize(i);
         for (; i < oldLarge.size(); ++i) {
           oldLarge[i].~value_type();
         }
         oldLarge.setSize(ci);
         throw;
       }
       oldSmall.setSize(i);
       oldLarge.setSize(ci);
       return;
     }
 
     // isExtern != o.isExtern()
     auto& oldExtern = o.isExtern() ? o : *this;
     auto& oldIntern = o.isExtern() ? *this : o;
 
     auto oldExternCapacity = oldExtern.capacity();
     auto oldExternHeap = oldExtern.u.pdata_.heap_;
 
     auto buff = oldExtern.u.buffer();
     size_type i = 0;
     try {
       for (; i < oldIntern.size(); ++i) {
         new (&buff[i]) value_type(std::move(oldIntern[i]));
         oldIntern[i].~value_type();
       }
     } catch (...) {
       for (size_type kill = 0; kill < i; ++kill) {
         buff[kill].~value_type();
       }
       for (; i < oldIntern.size(); ++i) {
         oldIntern[i].~value_type();
       }
       oldIntern.setSize(0);
       oldExtern.u.pdata_.heap_ = oldExternHeap;
       oldExtern.setCapacity(oldExternCapacity);
       throw;
     }
     oldIntern.u.pdata_.heap_ = oldExternHeap;
     this->swapSizePolicy(o);
     oldIntern.setCapacity(oldExternCapacity);
   }

template<class Value, std::size_t RequestedMaxInline = 1, class PolicyA = void, class PolicyB = void, class PolicyC = void>

static iterator folly::small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC >::unconst ( const_iterator it )

inlinestaticprivate

Definition at line 902 of file small_vector.h.

                                              {
     return const_cast<iterator>(it);
   }

Member Data Documentation

template<class Value, std::size_t RequestedMaxInline = 1, class PolicyA = void, class PolicyB = void, class PolicyC = void>

bool constexpr folly::small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC >::kHasInlineCapacity

staticprivate

Initial value:

sizeof(HeapPtrWithCapacity) < sizeof(InlineStorageType)

Definition at line 1136 of file small_vector.h.

template<class Value, std::size_t RequestedMaxInline = 1, class PolicyA = void, class PolicyB = void, class PolicyC = void>

size_t constexpr folly::small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC >::kHeapifyCapacitySize

staticprivate

Initial value:

= sizeof(
      typename std::
          aligned_storage<sizeof(InternalSizeType), alignof(value_type)>::type)

Definition at line 1140 of file small_vector.h.

template<class Value, std::size_t RequestedMaxInline = 1, class PolicyA = void, class PolicyB = void, class PolicyC = void>

size_t constexpr folly::small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC >::kHeapifyCapacityThreshold

staticprivate

Initial value:

100 * kHeapifyCapacitySize

Definition at line 1145 of file small_vector.h.

template<class Value, std::size_t RequestedMaxInline = 1, class PolicyA = void, class PolicyB = void, class PolicyC = void>

constexpr std::size_t folly::small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC >::MaxInline

staticprivate

Initial value:

{

constexpr_max(sizeof(Value*) / sizeof(Value), RequestedMaxInline)}

Definition at line 419 of file small_vector.h.

template<class Value, std::size_t RequestedMaxInline = 1, class PolicyA = void, class PolicyB = void, class PolicyC = void>

union folly::small_vector::Data folly::small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC >::u

private

Referenced by folly::small_vector< Observer< T > *, InlineObservers >::swap().

The documentation for this class was generated from the following file:

proxygen/folly/folly/small_vector.h

Classes

Public Types

Public Member Functions

Static Public Member Functions

Private Types

Private Member Functions

Static Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

template<class Value, std::size_t RequestedMaxInline = 1, class PolicyA = void, class PolicyB = void, class PolicyC = void> class folly::small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC >

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation

template<class Value, std::size_t RequestedMaxInline = 1, class PolicyA = void, class PolicyB = void, class PolicyC = void>
class folly::small_vector< Value, RequestedMaxInline, PolicyA, PolicyB, PolicyC >