folly::fbvector< T, Allocator > Class Template Reference

#include <FBVector.h>

Classes
struct	Impl

Public Types
typedef T	value_type
typedef value_type &	reference
typedef const value_type &	const_reference
typedef T *	iterator
typedef const T *	const_iterator
typedef size_t	size_type
typedef std::make_signed< size_type >::type	difference_type
typedef Allocator	allocator_type
typedef A::pointer	pointer
typedef A::const_pointer	const_pointer
typedef std::reverse_iterator< iterator >	reverse_iterator
typedef std::reverse_iterator< const_iterator >	const_reverse_iterator

Public Member Functions
	fbvector ()=default
	fbvector (const Allocator &a)
	fbvector (size_type n, const Allocator &a=Allocator())
	fbvector (size_type n, VT value, const Allocator &a=Allocator())
template<class It , class Category = typename std::iterator_traits<It>::iterator_category>
	fbvector (It first, It last, const Allocator &a=Allocator())
	fbvector (const fbvector &other)
	fbvector (fbvector &&other) noexcept
	fbvector (const fbvector &other, const Allocator &a)
	fbvector (fbvector &&other, const Allocator &a)
	fbvector (std::initializer_list< T > il, const Allocator &a=Allocator())
	~fbvector ()=default
fbvector &	operator= (const fbvector &other)
fbvector &	operator= (fbvector &&other)
fbvector &	operator= (std::initializer_list< T > il)
template<class It , class Category = typename std::iterator_traits<It>::iterator_category>
void	assign (It first, It last)
void	assign (size_type n, VT value)
void	assign (std::initializer_list< T > il)
allocator_type	get_allocator () const noexcept
iterator	begin () noexcept
const_iterator	begin () const noexcept
iterator	end () noexcept
const_iterator	end () const noexcept
reverse_iterator	rbegin () noexcept
const_reverse_iterator	rbegin () const noexcept
reverse_iterator	rend () noexcept
const_reverse_iterator	rend () const noexcept
const_iterator	cbegin () const noexcept
const_iterator	cend () const noexcept
const_reverse_iterator	crbegin () const noexcept
const_reverse_iterator	crend () const noexcept
size_type	size () const noexcept
size_type	max_size () const noexcept
void	resize (size_type n)
void	resize (size_type n, VT t)
size_type	capacity () const noexcept
bool	empty () const noexcept
void	reserve (size_type n)
void	shrink_to_fit () noexcept
reference	operator[] (size_type n)
const_reference	operator[] (size_type n) const
const_reference	at (size_type n) const
reference	at (size_type n)
reference	front ()
const_reference	front () const
reference	back ()
const_reference	back () const
T *	data () noexcept
const T *	data () const noexcept
template<class... Args>
void	emplace_back (Args &&...args)
void	push_back (const T &value)
void	push_back (T &&value)
void	pop_back ()
void	swap (fbvector &other) noexcept
void	clear () noexcept
iterator	erase (const_iterator position)
iterator	erase (const_iterator first, const_iterator last)
template<class... Args>
iterator	emplace (const_iterator cpos, Args &&...args)
iterator	insert (const_iterator cpos, const T &value)
iterator	insert (const_iterator cpos, T &&value)
iterator	insert (const_iterator cpos, size_type n, VT value)
template<class It , class Category = typename std::iterator_traits<It>::iterator_category>
iterator	insert (const_iterator cpos, It first, It last)
iterator	insert (const_iterator cpos, std::initializer_list< T > il)
bool	operator== (const fbvector &other) const
bool	operator!= (const fbvector &other) const
bool	operator< (const fbvector &other) const
bool	operator> (const fbvector &other) const
bool	operator<= (const fbvector &other) const
bool	operator>= (const fbvector &other) const

Private Types
typedef std::allocator_traits< Allocator >	A
typedef bool_constant< is_trivially_copyable< T >::value &&sizeof(T)<=16 > should_pass_by_value;typedef typename std::conditional< should_pass_by_value::value, T, const T & >::type VT;typedef typename std::conditional< should_pass_by_value::value, T, T && >::type MT;typedef bool_constant< std::is_same< Allocator, std::allocator< T > >::value > usingStdAllocator;typedef bool_constant< usingStdAllocator::value||A::propagate_on_container_move_assignment::value > moveIsSwap;private:T *M_allocate(size_type n){return impl_.D_allocate(n);}void M_deallocate(T *p, size_type n) noexcept{impl_.D_deallocate(p, n);}template< typename U, typename...Args > void M_construct(U *p, Args &&...args){if(usingStdAllocator::value){new(p) U(std::forward< Args >args)...);}else{std::allocator_traits< Allocator >::construct(impl_, p, std::forward< Args >args)...);}}template< typename U, typename...Args > static void S_construct(U *p, Args &&...args){new(p) U(std::forward< Args >args)...);}template< typename U, typename...Args > static void S_construct_a(Allocator &a, U *p, Args &&...args){std::allocator_traits< Allocator >::construct(a, p, std::forward< Args >args)...);}template< typename U, typename Enable=typename std::enable_if< std::is_scalar< U >::value >::type > void M_construct(U *p, U arg){if(usingStdAllocator::value){*p=arg;}else{std::allocator_traits< Allocator >::construct(impl_, p, arg);}}template< typename U, typename Enable=typename std::enable_if< std::is_scalar< U >::value >::type > static void S_construct(U *p, U arg){*p=arg;}template< typename U, typename Enable=typename std::enable_if< std::is_scalar< U >::value >::type > static void S_construct_a(Allocator &a, U *p, U arg){std::allocator_traits< Allocator >::construct(a, p, arg);}template< typename U, typename Enable=typename std::enable_if<!std::is_scalar< U >::value >::type > void M_construct(U *p, const U &value){if(usingStdAllocator::value){new(p) U(value);}else{std::allocator_traits< Allocator >::construct(impl_, p, value);}}template< typename U, typename Enable=typename std::enable_if<!std::is_scalar< U >::value >::type > static void S_construct(U *p, const U &value){new(p) U(value);}template< typename U, typename Enable=typename std::enable_if<!std::is_scalar< U >::value >::type > static void S_construct_a(Allocator &a, U *p, const U &value){std::allocator_traits< Allocator >::construct(a, p, value);}void M_destroy(T *p) noexcept{if(usingStdAllocator::value){if(!std::is_trivially_destructible< T >::value){p->	~T()
typedef bool_constant< folly::IsRelocatable< T >::value &&usingStdAllocator::value >	relocate_use_memcpy
typedef bool_constant< (std::is_nothrow_move_constructible< T >::value &&usingStdAllocator::value)||!std::is_copy_constructible< T >::value >	relocate_use_move

Private Member Functions
void	M_destroy_range_e (T *pos) noexcept
void	D_destroy_range_a (T *first, T *last) noexcept
void	M_uninitialized_fill_n_e (size_type sz)
void	M_uninitialized_fill_n_e (size_type sz, VT value)
void	D_uninitialized_fill_n_a (T *dest, size_type sz)
void	D_uninitialized_fill_n_a (T *dest, size_type sz, VT value)
template<typename It >
void	M_uninitialized_copy_e (It first, It last)
template<typename It >
void	M_uninitialized_move_e (It first, It last)
template<typename It >
void	D_uninitialized_copy_a (T *dest, It first, It last)
template<typename It >
void	D_uninitialized_move_a (T *dest, It first, It last)
void	M_relocate (T *newB)
void	relocate_move (T *dest, T *first, T *last)
void	relocate_move_or_memcpy (T *dest, T *first, T *last, std::true_type)
void	relocate_move_or_memcpy (T *dest, T *first, T *last, std::false_type)
void	relocate_move_or_copy (T *dest, T *first, T *last, std::true_type)
void	relocate_move_or_copy (T *dest, T *first, T *last, std::false_type)
void	relocate_done (T *, T *first, T *last) noexcept
void	relocate_undo (T *dest, T *first, T *last) noexcept
template<class ForwardIterator >
	fbvector (ForwardIterator first, ForwardIterator last, const Allocator &a, std::forward_iterator_tag)
template<class InputIterator >
	fbvector (InputIterator first, InputIterator last, const Allocator &a, std::input_iterator_tag)
void	moveFrom (fbvector &&other, std::true_type)
void	moveFrom (fbvector &&other, std::false_type)
template<class ForwardIterator >
void	assign (ForwardIterator first, ForwardIterator last, std::forward_iterator_tag)
template<class InputIterator >
void	assign (InputIterator first, InputIterator last, std::input_iterator_tag)
bool	dataIsInternalAndNotVT (const T &t)
bool	dataIsInternal (const T &t)
bool	reserve_in_place (size_type n)
size_type	computePushBackCapacity () const
template<class... Args>
void	emplace_back_aux (Args &&...args)
bool	isValid (const_iterator it)
size_type	computeInsertCapacity (size_type n)
void	make_window (iterator position, size_type n)
void	undo_window (iterator position, size_type n) noexcept
void	wrap_frame (T *ledge, size_type idx, size_type n)
bool	insert_use_fresh (bool at_end, size_type n)
template<typename IsInternalFunc , typename InsertInternalFunc , typename ConstructFunc , typename DestroyFunc >
iterator	do_real_insert (const_iterator cpos, size_type n, IsInternalFunc &&isInternalFunc, InsertInternalFunc &&insertInternalFunc, ConstructFunc &&constructFunc, DestroyFunc &&destroyFunc)
template<class FIt >
iterator	insert (const_iterator cpos, FIt first, FIt last, std::forward_iterator_tag)
template<class IIt >
iterator	insert (const_iterator cpos, IIt first, IIt last, std::input_iterator_tag)

Static Private Member Functions
static void	swap (Impl &a, Impl &b)
static void	S_destroy_range_a (Allocator &a, T *first, T *last) noexcept
static void	S_destroy_range (T *first, T *last) noexcept
template<typename... Args>
static void	S_uninitialized_fill_n_a (Allocator &a, T *dest, size_type sz, Args &&...args)
static void	S_uninitialized_fill_n (T *dest, size_type n)
static void	S_uninitialized_fill_n (T *dest, size_type n, const T &value)
template<typename It >
static void	S_uninitialized_copy_a (Allocator &a, T *dest, It first, It last)
template<typename It >
static void	S_uninitialized_copy (T *dest, It first, It last)
static void	S_uninitialized_copy_bits (T *dest, const T *first, const T *last)
static void	S_uninitialized_copy_bits (T *dest, std::move_iterator< T * > first, std::move_iterator< T * > last)
template<typename It >
static void	S_uninitialized_copy_bits (T *dest, It first, It last)
template<typename It >
static It	S_copy_n (T *dest, It first, size_type n)
static const T *	S_copy_n (T *dest, const T *first, size_type n)
static std::move_iterator< T * >	S_copy_n (T *dest, std::move_iterator< T * > mIt, size_type n)

Private Attributes
folly::fbvector::Impl	impl_
	else

Friends
template<class _T , class _A >
_T *	relinquish (fbvector< _T, _A > &)
template<class _T , class _A >
void	attach (fbvector< _T, _A > &, _T *data, size_t sz, size_t cap)

Detailed Description

template<class T, class Allocator>
class folly::fbvector< T, Allocator >

Definition at line 49 of file FBVector.h.

Member Typedef Documentation

template<class T, class Allocator>

typedef std::allocator_traits<Allocator> folly::fbvector< T, Allocator >::A

private

Definition at line 82 of file FBVector.h.

template<class T, class Allocator>

typedef Allocator folly::fbvector< T, Allocator >::allocator_type

Definition at line 209 of file FBVector.h.

template<class T, class Allocator>

typedef const T* folly::fbvector< T, Allocator >::const_iterator

Definition at line 206 of file FBVector.h.

template<class T, class Allocator>

typedef A::const_pointer folly::fbvector< T, Allocator >::const_pointer

Definition at line 211 of file FBVector.h.

template<class T, class Allocator>

typedef const value_type& folly::fbvector< T, Allocator >::const_reference

Definition at line 204 of file FBVector.h.

template<class T, class Allocator>

typedef std::reverse_iterator<const_iterator> folly::fbvector< T, Allocator >::const_reverse_iterator

Definition at line 213 of file FBVector.h.

template<class T, class Allocator>

typedef std::make_signed<size_type>::type folly::fbvector< T, Allocator >::difference_type

Definition at line 208 of file FBVector.h.

template<class T, class Allocator>

typedef T* folly::fbvector< T, Allocator >::iterator

Definition at line 205 of file FBVector.h.

template<class T, class Allocator>

typedef A::pointer folly::fbvector< T, Allocator >::pointer

Definition at line 210 of file FBVector.h.

template<class T, class Allocator>

typedef value_type& folly::fbvector< T, Allocator >::reference

Definition at line 203 of file FBVector.h.

template<class T, class Allocator>

typedef bool_constant< folly::IsRelocatable<T>::value && usingStdAllocator::value> folly::fbvector< T, Allocator >::relocate_use_memcpy

private

Definition at line 658 of file FBVector.h.

template<class T, class Allocator>

typedef bool_constant< (std::is_nothrow_move_constructible<T>::value && usingStdAllocator::value) || !std::is_copy_constructible<T>::value> folly::fbvector< T, Allocator >::relocate_use_move

private

Definition at line 664 of file FBVector.h.

template<class T, class Allocator>

typedef std::reverse_iterator<iterator> folly::fbvector< T, Allocator >::reverse_iterator

Definition at line 212 of file FBVector.h.

template<class T, class Allocator>

typedef size_t folly::fbvector< T, Allocator >::size_type

Definition at line 207 of file FBVector.h.

template<class T, class Allocator>

typedef T folly::fbvector< T, Allocator >::value_type

Definition at line 202 of file FBVector.h.

template<class T, class Allocator>

typedef bool_constant< is_trivially_copyable<T>::value && sizeof(T) <= 16 > should_pass_by_value; typedef typename std::conditional<should_pass_by_value::value, T, const T&>::type VT; typedef typename std::conditional<should_pass_by_value::value, T, T&&>::type MT; typedef bool_constant<std::is_same<Allocator, std::allocator<T> >::value> usingStdAllocator; typedef bool_constant< usingStdAllocator::value || A::propagate_on_container_move_assignment::value> moveIsSwap; private: T* M_allocate(size_type n) { return impl_.D_allocate(n); } void M_deallocate(T* p, size_type n) noexcept { impl_.D_deallocate(p, n); } template <typename U, typename... Args> void M_construct(U* p, Args&&... args) { if (usingStdAllocator::value) { new (p) U(std::forward<Args>args)...); } else { std::allocator_traits<Allocator>::construct( impl_, p, std::forward<Args>args)...); } } template <typename U, typename... Args> static void S_construct(U* p, Args&&... args) { new (p) U(std::forward<Args>args)...); } template <typename U, typename... Args> static void S_construct_a(Allocator& a, U* p, Args&&... args) { std::allocator_traits<Allocator>::construct( a, p, std::forward<Args>args)...); } template < typename U, typename Enable = typename std::enable_if<std::is_scalar<U>::value>::type> void M_construct(U* p, U arg) { if (usingStdAllocator::value) { *p = arg; } else { std::allocator_traits<Allocator>::construct(impl_, p, arg); } } template < typename U, typename Enable = typename std::enable_if<std::is_scalar<U>::value>::type> static void S_construct(U* p, U arg) { *p = arg; } template < typename U, typename Enable = typename std::enable_if<std::is_scalar<U>::value>::type> static void S_construct_a(Allocator& a, U* p, U arg) { std::allocator_traits<Allocator>::construct(a, p, arg); } template < typename U, typename Enable = typename std::enable_if<!std::is_scalar<U>::value>::type> void M_construct(U* p, const U& value) { if (usingStdAllocator::value) { new (p) U(value); } else { std::allocator_traits<Allocator>::construct(impl_, p, value); } } template < typename U, typename Enable = typename std::enable_if<!std::is_scalar<U>::value>::type> static void S_construct(U* p, const U& value) { new (p) U(value); } template < typename U, typename Enable = typename std::enable_if<!std::is_scalar<U>::value>::type> static void S_construct_a(Allocator& a, U* p, const U& value) { std::allocator_traits<Allocator>::construct(a, p, value); } void M_destroy(T* p) noexcept { if (usingStdAllocator::value) { if (!std::is_trivially_destructible<T>::value) { p-> folly::fbvector< T, Allocator >::~T()

private

Definition at line 341 of file FBVector.h.

Constructor & Destructor Documentation

template<class T, class Allocator>

folly::fbvector< T, Allocator >::fbvector ( )

default

Referenced by folly::fbvector< HTTPHeaderCode >::relocate_undo().

template<class T, class Allocator>

folly::fbvector< T, Allocator >::fbvector ( const Allocator &  a )

inlineexplicit

Definition at line 722 of file FBVector.h.

: impl_(a) {}

template<class T, class Allocator>

folly::fbvector< T, Allocator >::fbvector ( size_type  n, const Allocator &  a = Allocator()  )

inlineexplicit

Definition at line 724 of file FBVector.h.

      : impl_(n, a) {
    M_uninitialized_fill_n_e(n);

template<class T, class Allocator>

folly::fbvector< T, Allocator >::fbvector ( size_type  n, VT  value, const Allocator &  a = Allocator()  )

inline

Definition at line 729 of file FBVector.h.

      : impl_(n, a) {
    M_uninitialized_fill_n_e(n, value);

template<class T, class Allocator>

template<class It , class Category = typename std::iterator_traits<It>::iterator_category>

folly::fbvector< T, Allocator >::fbvector ( It  first, It  last, const Allocator &  a = Allocator()  )

inline

Definition at line 737 of file FBVector.h.

      : fbvector(first, last, a, Category()) {}

template<class T, class Allocator>

folly::fbvector< T, Allocator >::fbvector ( const fbvector< T, Allocator > &  other )

inline

Definition at line 740 of file FBVector.h.

      : impl_(
            other.size(),
            A::select_on_container_copy_construction(other.impl_)) {
    M_uninitialized_copy_e(other.begin(), other.end());

template<class T, class Allocator>

folly::fbvector< T, Allocator >::fbvector ( fbvector< T, Allocator > &&  other )

inlinenoexcept

Definition at line 747 of file FBVector.h.

: impl_(std::move(other.impl_)) {}

template<class T, class Allocator>

folly::fbvector< T, Allocator >::fbvector ( const fbvector< T, Allocator > &  other, const Allocator &  a  )

inline

Definition at line 749 of file FBVector.h.

      : fbvector(other.begin(), other.end(), a) {}

template<class T, class Allocator>

folly::fbvector< T, Allocator >::fbvector ( fbvector< T, Allocator > &&  other, const Allocator &  a  )

inline

Definition at line 752 of file FBVector.h.

                                                   : impl_(a) {
    if (impl_ == other.impl_) {
      impl_.swapData(other.impl_);
    } else {
      impl_.init(other.size());
      M_uninitialized_move_e(other.begin(), other.end());
    }

template<class T, class Allocator>

folly::fbvector< T, Allocator >::fbvector ( std::initializer_list< T >  il, const Allocator &  a = Allocator()  )

inline

Definition at line 761 of file FBVector.h.

      : fbvector(il.begin(), il.end(), a) {}

template<class T, class Allocator>

folly::fbvector< T, Allocator >::~fbvector ( )

default

Referenced by folly::fbvector< HTTPHeaderCode >::fbvector().

template<class T, class Allocator>

template<class ForwardIterator >

folly::fbvector< T, Allocator >::fbvector ( ForwardIterator  first, ForwardIterator  last, const Allocator &  a, std::forward_iterator_tag    )

inlineprivate

Definition at line 837 of file FBVector.h.

      : impl_(size_type(std::distance(first, last)), a) {
    M_uninitialized_copy_e(first, last);

template<class T, class Allocator>

template<class InputIterator >

folly::fbvector< T, Allocator >::fbvector ( InputIterator  first, InputIterator  last, const Allocator &  a, std::input_iterator_tag    )

inlineprivate

Definition at line 847 of file FBVector.h.

      : impl_(a) {
    for (; first != last; ++first) {
      emplace_back(*first);
    }

Member Function Documentation

template<class T, class Allocator>

template<class It , class Category = typename std::iterator_traits<It>::iterator_category>

void folly::fbvector< T, Allocator >::assign ( It  first, It  last  )

inline

Definition at line 800 of file FBVector.h.

Referenced by folly::fbvector< HTTPHeaderCode >::assign(), folly::fbvector< HTTPHeaderCode >::operator=(), and TEST().

                                 {
    assign(first, last, Category());

template<class T, class Allocator>

void folly::fbvector< T, Allocator >::assign ( size_type  n, VT  value  )

inline

Definition at line 804 of file FBVector.h.

                                     {
    if (n > capacity()) {
      // Not enough space. Do not reserve in place, since we will
      // discard the old values anyways.
      if (dataIsInternalAndNotVT(value)) {
        T copy(std::move(value));
        impl_.reset(n);
        M_uninitialized_fill_n_e(n, copy);
      } else {
        impl_.reset(n);
        M_uninitialized_fill_n_e(n, value);
      }
    } else if (n <= size()) {
      auto newE = impl_.b_ + n;
      std::fill(impl_.b_, newE, value);
      M_destroy_range_e(newE);
    } else {
      std::fill(impl_.b_, impl_.e_, value);
      M_uninitialized_fill_n_e(n - size(), value);
    }

template<class T, class Allocator>

void folly::fbvector< T, Allocator >::assign ( std::initializer_list< T >  il )

inline

Definition at line 826 of file FBVector.h.

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

template<class T, class Allocator>

template<class ForwardIterator >

void folly::fbvector< T, Allocator >::assign ( ForwardIterator  first, ForwardIterator  last, std::forward_iterator_tag    )

inlineprivate

Definition at line 873 of file FBVector.h.

                               {
    const auto newSize = size_type(std::distance(first, last));
    if (newSize > capacity()) {
      impl_.reset(newSize);
      M_uninitialized_copy_e(first, last);
    } else if (newSize <= size()) {
      auto newEnd = std::copy(first, last, impl_.b_);
      M_destroy_range_e(newEnd);
    } else {
      auto mid = S_copy_n(impl_.b_, first, size());
      M_uninitialized_copy_e<decltype(last)>(mid, last);
    }

template<class T, class Allocator>

template<class InputIterator >

void folly::fbvector< T, Allocator >::assign ( InputIterator  first, InputIterator  last, std::input_iterator_tag    )

inlineprivate

Definition at line 892 of file FBVector.h.

                                                                         {
    auto p = impl_.b_;
    for (; first != last && p != impl_.e_; ++first, ++p) {
      *p = *first;
    }
    if (p != impl_.e_) {
      M_destroy_range_e(p);
    } else {
      for (; first != last; ++first) {
        emplace_back(*first);
      }
    }

template<class T, class Allocator>

const_reference folly::fbvector< T, Allocator >::at ( size_type  n ) const

inline

Definition at line 1103 of file FBVector.h.

                                        {
    if (UNLIKELY(n >= size())) {
      throw_exception<std::out_of_range>(
          "fbvector: index is greater than size.");
    }
    return (*this)[n];

template<class T, class Allocator>

reference folly::fbvector< T, Allocator >::at ( size_type  n )

inline

Definition at line 1110 of file FBVector.h.

                            {
    auto const& cThis = *this;
    return const_cast<reference>(cThis.at(n));

template<class T, class Allocator>

reference folly::fbvector< T, Allocator >::back ( )

inline

Definition at line 1122 of file FBVector.h.

Referenced by TEST().

                   {
    assert(!empty());
    return impl_.e_[-1];

template<class T, class Allocator>

const_reference folly::fbvector< T, Allocator >::back ( ) const

inline

Definition at line 1126 of file FBVector.h.

                               {
    assert(!empty());
    return impl_.e_[-1];

template<class T, class Allocator>

iterator folly::fbvector< T, Allocator >::begin ( )

inlinenoexcept

Definition at line 922 of file FBVector.h.

Referenced by folly::fbvector< HTTPHeaderCode >::crend(), folly::fbvector< HTTPHeaderCode >::insert(), folly::fbvector< HTTPHeaderCode >::operator<(), folly::fbvector< HTTPHeaderCode >::operator==(), folly::fbvector< HTTPHeaderCode >::rend(), and TEST().

       :
  iterator begin() noexcept {
    return impl_.b_;

template<class T, class Allocator>

const_iterator folly::fbvector< T, Allocator >::begin ( ) const

inlinenoexcept

Definition at line 925 of file FBVector.h.

                                        {
    return impl_.b_;

template<class T, class Allocator>

size_type folly::fbvector< T, Allocator >::capacity ( ) const

inlinenoexcept

Definition at line 995 of file FBVector.h.

Referenced by folly::fbvector< HTTPHeaderCode >::assign(), folly::fbvector< HTTPHeaderCode >::computePushBackCapacity(), folly::fbvector< HTTPHeaderCode >::do_real_insert(), folly::fbvector< HTTPHeaderCode >::insert_use_fresh(), folly::fbvector< HTTPHeaderCode >::reserve(), folly::fbvector< HTTPHeaderCode >::resize(), folly::fbvector< HTTPHeaderCode >::shrink_to_fit(), and TEST().

                                      {
    return size_type(impl_.z_ - impl_.b_);

template<class T, class Allocator>

const_iterator folly::fbvector< T, Allocator >::cbegin ( ) const

inlinenoexcept

Definition at line 947 of file FBVector.h.

Referenced by folly::fbvector< HTTPHeaderCode >::isValid().

                                         {
    return impl_.b_;

template<class T, class Allocator>

const_iterator folly::fbvector< T, Allocator >::cend ( ) const

inlinenoexcept

Definition at line 950 of file FBVector.h.

Referenced by folly::fbvector< HTTPHeaderCode >::do_real_insert(), folly::fbvector< HTTPHeaderCode >::erase(), folly::fbvector< HTTPHeaderCode >::insert(), and folly::fbvector< HTTPHeaderCode >::isValid().

                                       {
    return impl_.e_;

template<class T, class Allocator>

void folly::fbvector< T, Allocator >::clear ( )

inlinenoexcept

Definition at line 1188 of file FBVector.h.

Referenced by proxygen::HTTPHeaders::removeAll(), and TEST().

                        {
    M_destroy_range_e(impl_.b_);

template<class T, class Allocator>

size_type folly::fbvector< T, Allocator >::computeInsertCapacity ( size_type  n )

inlineprivate

Definition at line 1271 of file FBVector.h.

Referenced by folly::fbvector< HTTPHeaderCode >::do_real_insert().

                                               {
    size_type nc = std::max(computePushBackCapacity(), size() + n);
    size_type ac = folly::goodMallocSize(nc * sizeof(T)) / sizeof(T);
    return ac;

template<class T, class Allocator>

size_type folly::fbvector< T, Allocator >::computePushBackCapacity ( ) const

inlineprivate

Definition at line 1211 of file FBVector.h.

Referenced by folly::fbvector< HTTPHeaderCode >::computeInsertCapacity(), and folly::fbvector< T, Allocator >::emplace_back_aux().

                                            {
    if (capacity() == 0) {
      return std::max(64 / sizeof(T), size_type(1));
    }
    if (capacity() < folly::jemallocMinInPlaceExpandable / sizeof(T)) {
      return capacity() * 2;
    }
    if (capacity() > 4096 * 32 / sizeof(T)) {
      return capacity() * 2;
    }
    return (capacity() * 3 + 1) / 2;

template<class T, class Allocator>

const_reverse_iterator folly::fbvector< T, Allocator >::crbegin ( ) const

inlinenoexcept

Definition at line 953 of file FBVector.h.

                                                  {
    return const_reverse_iterator(end());

template<class T, class Allocator>

const_reverse_iterator folly::fbvector< T, Allocator >::crend ( ) const

inlinenoexcept

Definition at line 956 of file FBVector.h.

                                                {
    return const_reverse_iterator(begin());

template<class T, class Allocator>

void folly::fbvector< T, Allocator >::D_destroy_range_a ( T *  first, T *  last  )

inlineprivatenoexcept

Definition at line 363 of file FBVector.h.

Referenced by folly::fbvector< HTTPHeaderCode >::erase(), folly::fbvector< HTTPHeaderCode >::insert(), folly::fbvector< HTTPHeaderCode >::M_destroy_range_e(), folly::fbvector< HTTPHeaderCode >::make_window(), folly::fbvector< HTTPHeaderCode >::relocate_done(), folly::fbvector< HTTPHeaderCode >::relocate_undo(), and folly::fbvector< HTTPHeaderCode >::undo_window().

                                                     {
    if (usingStdAllocator::value) {
      S_destroy_range(first, last);
    } else {
      S_destroy_range_a(impl_, first, last);
    }
  }

template<class T, class Allocator>

template<typename It >

void folly::fbvector< T, Allocator >::D_uninitialized_copy_a ( T *  dest, It  first, It  last  )

inlineprivate

Definition at line 505 of file FBVector.h.

Referenced by folly::fbvector< HTTPHeaderCode >::D_uninitialized_move_a(), folly::fbvector< HTTPHeaderCode >::insert(), folly::fbvector< HTTPHeaderCode >::M_uninitialized_copy_e(), and folly::fbvector< HTTPHeaderCode >::relocate_move_or_copy().

                                                          {
    if (usingStdAllocator::value) {
      if (folly::is_trivially_copyable<T>::value) {
        S_uninitialized_copy_bits(dest, first, last);
      } else {
        S_uninitialized_copy(dest, first, last);
      }
    } else {
      S_uninitialized_copy_a(impl_, dest, first, last);
    }

template<class T, class Allocator>

void folly::fbvector< T, Allocator >::D_uninitialized_fill_n_a ( T *  dest, size_type  sz  )

inlineprivate

Definition at line 412 of file FBVector.h.

Referenced by folly::fbvector< HTTPHeaderCode >::insert(), and folly::fbvector< HTTPHeaderCode >::M_uninitialized_fill_n_e().

                                                       {
    if (usingStdAllocator::value) {
      S_uninitialized_fill_n(dest, sz);
    } else {
      S_uninitialized_fill_n_a(impl_, dest, sz);
    }

template<class T, class Allocator>

void folly::fbvector< T, Allocator >::D_uninitialized_fill_n_a ( T *  dest, size_type  sz, VT  value  )

inlineprivate

Definition at line 420 of file FBVector.h.

                                                                 {
    if (usingStdAllocator::value) {
      S_uninitialized_fill_n(dest, sz, value);
    } else {
      S_uninitialized_fill_n_a(impl_, dest, sz, value);
    }

template<class T, class Allocator>

template<typename It >

void folly::fbvector< T, Allocator >::D_uninitialized_move_a ( T *  dest, It  first, It  last  )

inlineprivate

Definition at line 518 of file FBVector.h.

Referenced by folly::fbvector< HTTPHeaderCode >::M_uninitialized_move_e(), folly::fbvector< HTTPHeaderCode >::make_window(), and folly::fbvector< HTTPHeaderCode >::relocate_move_or_copy().

                                                          {
    D_uninitialized_copy_a(
        dest, std::make_move_iterator(first), std::make_move_iterator(last));

template<class T, class Allocator>

T* folly::fbvector< T, Allocator >::data ( )

inlinenoexcept

Definition at line 1135 of file FBVector.h.

Referenced by folly::attach(), proxygen::HTTPHeaders::exists(), folly::fbvector< HTTPHeaderCode >::operator>=(), and TEST().

       :
  T* data() noexcept {
    return impl_.b_;

template<class T, class Allocator>

const T* folly::fbvector< T, Allocator >::data ( ) const

inlinenoexcept

Definition at line 1138 of file FBVector.h.

                                 {
    return impl_.b_;

template<class T, class Allocator>

bool folly::fbvector< T, Allocator >::dataIsInternal ( const T &  t )

inlineprivate

Definition at line 913 of file FBVector.h.

Referenced by folly::fbvector< HTTPHeaderCode >::dataIsInternalAndNotVT(), and folly::fbvector< HTTPHeaderCode >::insert().

                                  {
    return UNLIKELY(
        impl_.b_ <= std::addressof(t) && std::addressof(t) < impl_.e_);

template<class T, class Allocator>

bool folly::fbvector< T, Allocator >::dataIsInternalAndNotVT ( const T &  t )

inlineprivate

Definition at line 907 of file FBVector.h.

Referenced by folly::fbvector< HTTPHeaderCode >::assign(), folly::fbvector< HTTPHeaderCode >::insert(), and folly::fbvector< HTTPHeaderCode >::resize().

                                          {
    if (should_pass_by_value::value) {
      return false;
    }
    return dataIsInternal(t);

template<class T, class Allocator>

template<typename IsInternalFunc , typename InsertInternalFunc , typename ConstructFunc , typename DestroyFunc >

iterator folly::fbvector< T, Allocator >::do_real_insert ( const_iterator  cpos, size_type  n, IsInternalFunc &&  isInternalFunc, InsertInternalFunc &&  insertInternalFunc, ConstructFunc &&  constructFunc, DestroyFunc &&  destroyFunc  )

inlineprivate

Definition at line 1414 of file FBVector.h.

Referenced by folly::fbvector< HTTPHeaderCode >::emplace(), and folly::fbvector< HTTPHeaderCode >::insert().

                                 {
    if (n == 0) {
      return iterator(cpos);
    }
    bool at_end = cpos == cend();
    bool fresh = insert_use_fresh(at_end, n);
    if (!at_end) {
      if (!fresh && isInternalFunc()) {
        // check for internal data (technically not required by the standard)
        return insertInternalFunc();
      }
      assert(isValid(cpos));
    }
    T* position = const_cast<T*>(cpos);
    size_type idx = size_type(std::distance(impl_.b_, position));
    T* b;
    size_type newCap; /* intentionally uninitialized */

    if (fresh) {
      newCap = computeInsertCapacity(n);
      b = M_allocate(newCap);
    } else {
      if (!at_end) {
        make_window(position, n);
      } else {
        impl_.e_ += n;
      }
      b = impl_.b_;
    }

    T* start = b + idx;
    try {
      // construct the inserted elements
      constructFunc(start);
    } catch (...) {
      if (fresh) {
        M_deallocate(b, newCap);
      } else {
        if (!at_end) {
          undo_window(position, n);
        } else {
          impl_.e_ -= n;
        }
      }
      throw;
    }

    if (fresh) {
      try {
        wrap_frame(b, idx, n);
      } catch (...) {
        // delete the inserted elements (exception has been thrown)
        destroyFunc(start);
        M_deallocate(b, newCap);
        throw;
      }
      if (impl_.b_) {
        M_deallocate(impl_.b_, capacity());
      }
      impl_.set(b, size() + n, newCap);
      return impl_.b_ + idx;
    } else {
      return position;
    }

template<class T, class Allocator>

template<class... Args>

iterator folly::fbvector< T, Allocator >::emplace ( const_iterator  cpos, Args &&...  args  )

inline

Definition at line 1488 of file FBVector.h.

                                                        {
    return do_real_insert(
        cpos,
        1,
        [&] { return false; },
        [&] { return iterator{}; },
        [&](iterator start) {
          M_construct(start, std::forward<Args>(args)...);
        },
        [&](iterator start) { M_destroy(start); });

template<class T, class Allocator>

template<class... Args>

void folly::fbvector< T, Allocator >::emplace_back ( Args &&...  args )

inline

Definition at line 1147 of file FBVector.h.

Referenced by proxygen::HTTPHeaders::add(), proxygen::HTTPHeaders::addFromCodec(), folly::fbvector< HTTPHeaderCode >::assign(), folly::fbvector< HTTPHeaderCode >::fbvector(), folly::fbvector< HTTPHeaderCode >::insert(), and TEST().

                                    {
    if (impl_.e_ != impl_.z_) {
      M_construct(impl_.e_, std::forward<Args>(args)...);
      ++impl_.e_;
    } else {
      emplace_back_aux(std::forward<Args>(args)...);
    }

template<typename T , typename Allocator >

template<class... Args>

void folly::fbvector< T, Allocator >::emplace_back_aux ( Args &&...  args )

private

Definition at line 1626 of file FBVector.h.

References folly::fbvector< T, Allocator >::Impl::b_, folly::fbvector< T, Allocator >::computePushBackCapacity(), folly::fbvector< T, Allocator >::Impl::e_, folly::goodMallocSize(), folly::fbvector< T, Allocator >::impl_, folly::jemallocMinInPlaceExpandable, folly::fbvector< T, Allocator >::M_relocate(), folly::fbvector< T, Allocator >::relocate_move(), folly::fbvector< T, Allocator >::size(), folly::T, folly::usingJEMalloc(), value, xallocx, and folly::fbvector< T, Allocator >::Impl::z_.

Referenced by folly::fbvector< HTTPHeaderCode >::computePushBackCapacity(), folly::fbvector< HTTPHeaderCode >::emplace_back(), and folly::fbvector< HTTPHeaderCode >::push_back().

                                                            {
  size_type byte_sz =
      folly::goodMallocSize(computePushBackCapacity() * sizeof(T));
  if (usingStdAllocator::value && usingJEMalloc() &&
      ((impl_.z_ - impl_.b_) * sizeof(T) >=
       folly::jemallocMinInPlaceExpandable)) {
    // Try to reserve in place.
    // Ask xallocx to allocate in place at least size()+1 and at most sz space.
    // xallocx will allocate as much as possible within that range, which
    //  is the best possible outcome: if sz space is available, take it all,
    //  otherwise take as much as possible. If nothing is available, then fail.
    // In this fashion, we never relocate if there is a possibility of
    //  expanding in place, and we never reallocate by less than the desired
    //  amount unless we cannot expand further. Hence we will not reallocate
    //  sub-optimally twice in a row (modulo the blocking memory being freed).
    size_type lower = folly::goodMallocSize(sizeof(T) + size() * sizeof(T));
    size_type upper = byte_sz;
    size_type extra = upper - lower;

    void* p = impl_.b_;
    size_t actual;

    if ((actual = xallocx(p, lower, extra, 0)) >= lower) {
      impl_.z_ = impl_.b_ + actual / sizeof(T);
      M_construct(impl_.e_, std::forward<Args>(args)...);
      ++impl_.e_;
      return;
    }
  }

  // Reallocation failed. Perform a manual relocation.
  size_type sz = byte_sz / sizeof(T);
  auto newB = M_allocate(sz);
  auto newE = newB + size();
  try {
    if (folly::IsRelocatable<T>::value && usingStdAllocator::value) {
      // For linear memory access, relocate before construction.
      // By the test condition, relocate is noexcept.
      // Note that there is no cleanup to do if M_construct throws - that's
      //  one of the beauties of relocation.
      // Benchmarks for this code have high variance, and seem to be close.
      relocate_move(newB, impl_.b_, impl_.e_);
      M_construct(newE, std::forward<Args>(args)...);
      ++newE;
    } else {
      M_construct(newE, std::forward<Args>(args)...);
      ++newE;
      try {
        M_relocate(newB);
      } catch (...) {
        M_destroy(newE - 1);
        throw;
      }
    }
  } catch (...) {
    M_deallocate(newB, sz);
    throw;
  }
  if (impl_.b_) {
    M_deallocate(impl_.b_, size());
  }
  impl_.b_ = newB;
  impl_.e_ = newE;
  impl_.z_ = newB + sz;

template<class T, class Allocator>

bool folly::fbvector< T, Allocator >::empty ( ) const

inlinenoexcept

Definition at line 999 of file FBVector.h.

Referenced by folly::fbvector< HTTPHeaderCode >::back(), folly::fbvector< HTTPHeaderCode >::front(), folly::fbvector< HTTPHeaderCode >::pop_back(), and folly::fbvector< HTTPHeaderCode >::shrink_to_fit().

                              {
    return impl_.b_ == impl_.e_;

template<class T, class Allocator>

iterator folly::fbvector< T, Allocator >::end ( )

inlinenoexcept

Definition at line 928 of file FBVector.h.

Referenced by folly::fbvector< HTTPHeaderCode >::crbegin(), folly::fbvector< HTTPHeaderCode >::erase(), folly::fbvector< HTTPHeaderCode >::insert(), folly::fbvector< HTTPHeaderCode >::operator<(), folly::fbvector< HTTPHeaderCode >::operator==(), folly::fbvector< HTTPHeaderCode >::rbegin(), and TEST().

                          {
    return impl_.e_;

template<class T, class Allocator>

const_iterator folly::fbvector< T, Allocator >::end ( ) const

inlinenoexcept

Definition at line 931 of file FBVector.h.

                                      {
    return impl_.e_;

template<class T, class Allocator>

iterator folly::fbvector< T, Allocator >::erase ( const_iterator  position )

inline

Definition at line 1231 of file FBVector.h.

Referenced by folly::fbvector< HTTPHeaderCode >::erase().

       :
  iterator erase(const_iterator position) {
    return erase(position, position + 1);

template<class T, class Allocator>

iterator folly::fbvector< T, Allocator >::erase ( const_iterator  first, const_iterator  last  )

inline

Definition at line 1235 of file FBVector.h.

                                                            {
    assert(isValid(first) && isValid(last));
    assert(first <= last);
    if (first != last) {
      if (last == end()) {
        M_destroy_range_e((iterator)first);
      } else {
        if (folly::IsRelocatable<T>::value && usingStdAllocator::value) {
          D_destroy_range_a((iterator)first, (iterator)last);
          if (last - first >= cend() - last) {
            std::memcpy((void*)first, (void*)last, (cend() - last) * sizeof(T));
          } else {
            std::memmove((iterator)first, last, (cend() - last) * sizeof(T));
          }
          impl_.e_ -= (last - first);
        } else {
          std::copy(
              std::make_move_iterator((iterator)last),
              std::make_move_iterator(end()),
              (iterator)first);
          auto newEnd = impl_.e_ - std::distance(first, last);
          M_destroy_range_e(newEnd);
        }
      }
    }
    return (iterator)first;

template<class T, class Allocator>

reference folly::fbvector< T, Allocator >::front ( )

inline

Definition at line 1114 of file FBVector.h.

Referenced by TEST().

                    {
    assert(!empty());
    return *impl_.b_;

template<class T, class Allocator>

const_reference folly::fbvector< T, Allocator >::front ( ) const

inline

Definition at line 1118 of file FBVector.h.

                                {
    assert(!empty());
    return *impl_.b_;

template<class T, class Allocator>

allocator_type folly::fbvector< T, Allocator >::get_allocator ( ) const

inlinenoexcept

Definition at line 830 of file FBVector.h.

                                                {
    return impl_;

template<class T, class Allocator>

iterator folly::fbvector< T, Allocator >::insert ( const_iterator  cpos, const T &  value  )

inline

Definition at line 1500 of file FBVector.h.

Referenced by folly::fbvector< HTTPHeaderCode >::insert(), and TEST().

                                                       {
    return do_real_insert(
        cpos,
        1,
        [&] { return dataIsInternal(value); },
        [&] { return insert(cpos, T(value)); },
        [&](iterator start) { M_construct(start, value); },
        [&](iterator start) { M_destroy(start); });

template<class T, class Allocator>

iterator folly::fbvector< T, Allocator >::insert ( const_iterator  cpos, T &&  value  )

inline

Definition at line 1510 of file FBVector.h.

                                                  {
    return do_real_insert(
        cpos,
        1,
        [&] { return dataIsInternal(value); },
        [&] { return insert(cpos, T(std::move(value))); },
        [&](iterator start) { M_construct(start, std::move(value)); },
        [&](iterator start) { M_destroy(start); });

template<class T, class Allocator>

iterator folly::fbvector< T, Allocator >::insert ( const_iterator  cpos, size_type  n, VT  value  )

inline

Definition at line 1520 of file FBVector.h.

                                                              {
    return do_real_insert(
        cpos,
        n,
        [&] { return dataIsInternalAndNotVT(value); },
        [&] { return insert(cpos, n, T(value)); },
        [&](iterator start) { D_uninitialized_fill_n_a(start, n, value); },
        [&](iterator start) { D_destroy_range_a(start, start + n); });

template<class T, class Allocator>

template<class It , class Category = typename std::iterator_traits<It>::iterator_category>

iterator folly::fbvector< T, Allocator >::insert ( const_iterator  cpos, It  first, It  last  )

inline

Definition at line 1533 of file FBVector.h.

                                                          {
    return insert(cpos, first, last, Category());

template<class T, class Allocator>

iterator folly::fbvector< T, Allocator >::insert ( const_iterator  cpos, std::initializer_list< T >  il  )

inline

Definition at line 1537 of file FBVector.h.

                                                                  {
    return insert(cpos, il.begin(), il.end());

template<class T, class Allocator>

template<class FIt >

iterator folly::fbvector< T, Allocator >::insert ( const_iterator  cpos, FIt  first, FIt  last, std::forward_iterator_tag    )

inlineprivate

Definition at line 1546 of file FBVector.h.

                                                                            {
    size_type n = size_type(std::distance(first, last));
    return do_real_insert(
        cpos,
        n,
        [&] { return false; },
        [&] { return iterator{}; },
        [&](iterator start) { D_uninitialized_copy_a(start, first, last); },
        [&](iterator start) { D_destroy_range_a(start, start + n); });

template<class T, class Allocator>

template<class IIt >

iterator folly::fbvector< T, Allocator >::insert ( const_iterator  cpos, IIt  first, IIt  last, std::input_iterator_tag    )

inlineprivate

Definition at line 1559 of file FBVector.h.

                                                                          {
    T* position = const_cast<T*>(cpos);
    assert(isValid(position));
    size_type idx = std::distance(begin(), position);

    fbvector storage(
        std::make_move_iterator(position),
        std::make_move_iterator(end()),
        A::select_on_container_copy_construction(impl_));
    M_destroy_range_e(position);
    for (; first != last; ++first) {
      emplace_back(*first);
    }
    insert(
        cend(),
        std::make_move_iterator(storage.begin()),
        std::make_move_iterator(storage.end()));
    return impl_.b_ + idx;

template<class T, class Allocator>

bool folly::fbvector< T, Allocator >::insert_use_fresh ( bool  at_end, size_type  n  )

inlineprivate

Definition at line 1388 of file FBVector.h.

Referenced by folly::fbvector< HTTPHeaderCode >::do_real_insert().

                                                  {
    if (at_end) {
      if (size() + n <= capacity()) {
        return false;
      }
      if (reserve_in_place(size() + n)) {
        return false;
      }
      return true;
    }

    if (size() + n > capacity()) {
      return true;
    }

    return false;

template<class T, class Allocator>

bool folly::fbvector< T, Allocator >::isValid ( const_iterator  it )

inlineprivate

Definition at line 1267 of file FBVector.h.

Referenced by folly::fbvector< HTTPHeaderCode >::do_real_insert(), folly::fbvector< HTTPHeaderCode >::erase(), and folly::fbvector< HTTPHeaderCode >::insert().

        : // we have the private section first because it defines some macros
  bool isValid(const_iterator it) {
    return cbegin() <= it && it <= cend();

template<class T, class Allocator>

void folly::fbvector< T, Allocator >::M_destroy_range_e ( T *  pos )

inlineprivatenoexcept

Definition at line 356 of file FBVector.h.

Referenced by folly::fbvector< HTTPHeaderCode >::assign(), folly::fbvector< HTTPHeaderCode >::clear(), folly::fbvector< HTTPHeaderCode >::erase(), folly::fbvector< HTTPHeaderCode >::insert(), and folly::fbvector< HTTPHeaderCode >::resize().

                                          {
    D_destroy_range_a(pos, impl_.e_);
    impl_.e_ = pos;
  }

template<class T, class Allocator>

void folly::fbvector< T, Allocator >::M_relocate ( T *  newB )

inlineprivate

Definition at line 650 of file FBVector.h.

Referenced by folly::fbvector< T, Allocator >::emplace_back_aux(), folly::fbvector< HTTPHeaderCode >::reserve(), and folly::fbvector< HTTPHeaderCode >::shrink_to_fit().

                           {
    relocate_move(newB, impl_.b_, impl_.e_);
    relocate_done(newB, impl_.b_, impl_.e_);

template<class T, class Allocator>

template<typename It >

void folly::fbvector< T, Allocator >::M_uninitialized_copy_e ( It  first, It  last  )

inlineprivate

Definition at line 492 of file FBVector.h.

Referenced by folly::fbvector< HTTPHeaderCode >::assign(), and folly::fbvector< HTTPHeaderCode >::fbvector().

                                                 {
    D_uninitialized_copy_a(impl_.e_, first, last);
    impl_.e_ += std::distance(first, last);

template<class T, class Allocator>

void folly::fbvector< T, Allocator >::M_uninitialized_fill_n_e ( size_type  sz )

inlineprivate

Definition at line 401 of file FBVector.h.

Referenced by folly::fbvector< HTTPHeaderCode >::assign(), folly::fbvector< HTTPHeaderCode >::fbvector(), and folly::fbvector< HTTPHeaderCode >::resize().

                                              {
    D_uninitialized_fill_n_a(impl_.e_, sz);
    impl_.e_ += sz;

template<class T, class Allocator>

void folly::fbvector< T, Allocator >::M_uninitialized_fill_n_e ( size_type  sz, VT  value  )

inlineprivate

Definition at line 406 of file FBVector.h.

                                                        {
    D_uninitialized_fill_n_a(impl_.e_, sz, value);
    impl_.e_ += sz;

template<class T, class Allocator>

template<typename It >

void folly::fbvector< T, Allocator >::M_uninitialized_move_e ( It  first, It  last  )

inlineprivate

Definition at line 498 of file FBVector.h.

Referenced by folly::fbvector< HTTPHeaderCode >::fbvector(), and folly::fbvector< HTTPHeaderCode >::moveFrom().

                                                 {
    D_uninitialized_move_a(impl_.e_, first, last);
    impl_.e_ += std::distance(first, last);

template<class T, class Allocator>

void folly::fbvector< T, Allocator >::make_window ( iterator  position, size_type  n  )

inlineprivate

Definition at line 1332 of file FBVector.h.

Referenced by folly::fbvector< HTTPHeaderCode >::do_real_insert().

                                                   {
    // The result is guaranteed to be non-negative, so use an unsigned type:
    size_type tail = size_type(std::distance(position, impl_.e_));

    if (tail <= n) {
      relocate_move(position + n, position, impl_.e_);
      relocate_done(position + n, position, impl_.e_);
      impl_.e_ += n;
    } else {
      if (folly::IsRelocatable<T>::value && usingStdAllocator::value) {
        std::memmove(position + n, position, tail * sizeof(T));
        impl_.e_ += n;
      } else {
        D_uninitialized_move_a(impl_.e_, impl_.e_ - n, impl_.e_);
        try {
          std::copy_backward(
              std::make_move_iterator(position),
              std::make_move_iterator(impl_.e_ - n),
              impl_.e_);
        } catch (...) {
          D_destroy_range_a(impl_.e_ - n, impl_.e_ + n);
          impl_.e_ -= n;
          throw;
        }
        impl_.e_ += n;
        D_destroy_range_a(position, position + n);
      }
    }

template<class T, class Allocator>

size_type folly::fbvector< T, Allocator >::max_size ( ) const

inlinenoexcept

Definition at line 968 of file FBVector.h.

                                      {
    // good luck gettin' there
    return ~size_type(0);

template<class T, class Allocator>

void folly::fbvector< T, Allocator >::moveFrom ( fbvector< T, Allocator > &&  other, std::true_type    )

inlineprivate

Definition at line 859 of file FBVector.h.

Referenced by folly::fbvector< HTTPHeaderCode >::operator=().

                                                {
    swap(impl_, other.impl_);

template<class T, class Allocator>

void folly::fbvector< T, Allocator >::moveFrom ( fbvector< T, Allocator > &&  other, std::false_type    )

inlineprivate

Definition at line 862 of file FBVector.h.

                                                 {
    if (impl_ == other.impl_) {
      impl_.swapData(other.impl_);
    } else {
      impl_.reset(other.size());
      M_uninitialized_move_e(other.begin(), other.end());
    }

template<class T, class Allocator>

bool folly::fbvector< T, Allocator >::operator!= ( const fbvector< T, Allocator > &  other ) const

inline

Definition at line 1587 of file FBVector.h.

                                               {
    return !(*this == other);

template<class T, class Allocator>

bool folly::fbvector< T, Allocator >::operator< ( const fbvector< T, Allocator > &  other ) const

inline

Definition at line 1591 of file FBVector.h.

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

template<class T, class Allocator>

bool folly::fbvector< T, Allocator >::operator<= ( const fbvector< T, Allocator > &  other ) const

inline

Definition at line 1600 of file FBVector.h.

                                               {
    return !(*this > other);

template<class T, class Allocator>

fbvector& folly::fbvector< T, Allocator >::operator= ( const fbvector< T, Allocator > &  other )

inline

Definition at line 766 of file FBVector.h.

                                             {
    if (UNLIKELY(this == &other)) {
      return *this;
    }

    if (!usingStdAllocator::value &&
        A::propagate_on_container_copy_assignment::value) {
      if (impl_ != other.impl_) {
        // can't use other's different allocator to clean up self
        impl_.reset();
      }
      (Allocator&)impl_ = (Allocator&)other.impl_;
    }

    assign(other.begin(), other.end());
    return *this;

template<class T, class Allocator>

fbvector& folly::fbvector< T, Allocator >::operator= ( fbvector< T, Allocator > &&  other )

inline

Definition at line 784 of file FBVector.h.

                                        {
    if (UNLIKELY(this == &other)) {
      return *this;
    }
    moveFrom(std::move(other), moveIsSwap());
    return *this;

template<class T, class Allocator>

fbvector& folly::fbvector< T, Allocator >::operator= ( std::initializer_list< T >  il )

inline

Definition at line 792 of file FBVector.h.

                                                 {
    assign(il.begin(), il.end());
    return *this;

template<class T, class Allocator>

bool folly::fbvector< T, Allocator >::operator== ( const fbvector< T, Allocator > &  other ) const

inline

Definition at line 1583 of file FBVector.h.

       :
  bool operator==(const fbvector& other) const {
    return size() == other.size() && std::equal(begin(), end(), other.begin());

template<class T, class Allocator>

bool folly::fbvector< T, Allocator >::operator> ( const fbvector< T, Allocator > &  other ) const

inline

Definition at line 1596 of file FBVector.h.

                                              {
    return other < *this;

template<class T, class Allocator>

bool folly::fbvector< T, Allocator >::operator>= ( const fbvector< T, Allocator > &  other ) const

inline

Definition at line 1604 of file FBVector.h.

                                               {
    return !(*this < other);

template<class T, class Allocator>

reference folly::fbvector< T, Allocator >::operator[] ( size_type  n )

inline

Definition at line 1095 of file FBVector.h.

       :
  reference operator[](size_type n) {
    assert(n < size());
    return impl_.b_[n];

template<class T, class Allocator>

const_reference folly::fbvector< T, Allocator >::operator[] ( size_type  n ) const

inline

Definition at line 1099 of file FBVector.h.

                                                {
    assert(n < size());
    return impl_.b_[n];

template<class T, class Allocator>

void folly::fbvector< T, Allocator >::pop_back ( )

inline

Definition at line 1174 of file FBVector.h.

                  {
    assert(!empty());
    --impl_.e_;
    M_destroy(impl_.e_);

template<class T, class Allocator>

void folly::fbvector< T, Allocator >::push_back ( const T &  value )

inline

Definition at line 1156 of file FBVector.h.

Referenced by proxygen::HTTPHeaders::add(), proxygen::HTTPHeaders::addFromCodec(), folly::IOBuf::appendToIov(), proxygen::HTTPHeaders::copyTo(), proxygen::HTTPHeaders::stripPerHopHeaders(), TEST(), and proxygen::HTTPHeaders::transferHeaderIfPresent().

                                 {
    if (impl_.e_ != impl_.z_) {
      M_construct(impl_.e_, value);
      ++impl_.e_;
    } else {
      emplace_back_aux(value);
    }

template<class T, class Allocator>

void folly::fbvector< T, Allocator >::push_back ( T &&  value )

inline

Definition at line 1165 of file FBVector.h.

                            {
    if (impl_.e_ != impl_.z_) {
      M_construct(impl_.e_, std::move(value));
      ++impl_.e_;
    } else {
      emplace_back_aux(std::move(value));
    }

template<class T, class Allocator>

reverse_iterator folly::fbvector< T, Allocator >::rbegin ( )

inlinenoexcept

Definition at line 934 of file FBVector.h.

                                     {
    return reverse_iterator(end());

template<class T, class Allocator>

const_reverse_iterator folly::fbvector< T, Allocator >::rbegin ( ) const

inlinenoexcept

Definition at line 937 of file FBVector.h.

                                                 {
    return const_reverse_iterator(end());

template<class T, class Allocator>

void folly::fbvector< T, Allocator >::relocate_done ( T *  , T *  first, T *  last  )

inlineprivatenoexcept

Definition at line 690 of file FBVector.h.

Referenced by folly::fbvector< HTTPHeaderCode >::M_relocate(), folly::fbvector< HTTPHeaderCode >::make_window(), and folly::fbvector< HTTPHeaderCode >::wrap_frame().

                                                       {
    if (folly::IsRelocatable<T>::value && usingStdAllocator::value) {
      // used memcpy; data has been relocated, do not call destructor
    } else {
      D_destroy_range_a(first, last);
    }

template<class T, class Allocator>

void folly::fbvector< T, Allocator >::relocate_move ( T *  dest, T *  first, T *  last  )

inlineprivate

Definition at line 667 of file FBVector.h.

Referenced by folly::fbvector< T, Allocator >::emplace_back_aux(), folly::fbvector< HTTPHeaderCode >::M_relocate(), folly::fbvector< HTTPHeaderCode >::make_window(), folly::fbvector< HTTPHeaderCode >::relocate_undo(), and folly::fbvector< HTTPHeaderCode >::wrap_frame().

                                                 {
    relocate_move_or_memcpy(dest, first, last, relocate_use_memcpy());

template<class T, class Allocator>

void folly::fbvector< T, Allocator >::relocate_move_or_copy ( T *  dest, T *  first, T *  last, std::true_type    )

inlineprivate

Definition at line 681 of file FBVector.h.

Referenced by folly::fbvector< HTTPHeaderCode >::relocate_move_or_memcpy().

                                                                       {
    D_uninitialized_move_a(dest, first, last);

template<class T, class Allocator>

void folly::fbvector< T, Allocator >::relocate_move_or_copy ( T *  dest, T *  first, T *  last, std::false_type    )

inlineprivate

Definition at line 685 of file FBVector.h.

                                                                        {
    D_uninitialized_copy_a(dest, first, last);

template<class T, class Allocator>

void folly::fbvector< T, Allocator >::relocate_move_or_memcpy ( T *  dest, T *  first, T *  last, std::true_type    )

inlineprivate

Definition at line 671 of file FBVector.h.

Referenced by folly::fbvector< HTTPHeaderCode >::relocate_move().

                                                                         {
    if (first != nullptr) {
      std::memcpy((void*)dest, (void*)first, (last - first) * sizeof(T));
    }

template<class T, class Allocator>

void folly::fbvector< T, Allocator >::relocate_move_or_memcpy ( T *  dest, T *  first, T *  last, std::false_type    )

inlineprivate

Definition at line 677 of file FBVector.h.

                                                                          {
    relocate_move_or_copy(dest, first, last, relocate_use_move());

template<class T, class Allocator>

void folly::fbvector< T, Allocator >::relocate_undo ( T *  dest, T *  first, T *  last  )

inlineprivatenoexcept

Definition at line 699 of file FBVector.h.

Referenced by folly::fbvector< HTTPHeaderCode >::wrap_frame().

                                                          {
    if (folly::IsRelocatable<T>::value && usingStdAllocator::value) {
      // used memcpy, old data is still valid, nothing to do
    } else if (
        std::is_nothrow_move_constructible<T>::value &&
        usingStdAllocator::value) {
      // noexcept move everything back, aka relocate_move
      relocate_move(first, dest, dest + (last - first));
    } else if (!std::is_copy_constructible<T>::value) {
      // weak guarantee
      D_destroy_range_a(dest, dest + (last - first));
    } else {
      // used copy, old data is still valid
      D_destroy_range_a(dest, dest + (last - first));
    }

template<class T, class Allocator>

reverse_iterator folly::fbvector< T, Allocator >::rend ( )

inlinenoexcept

Definition at line 940 of file FBVector.h.

                                   {
    return reverse_iterator(begin());

template<class T, class Allocator>

const_reverse_iterator folly::fbvector< T, Allocator >::rend ( ) const

inlinenoexcept

Definition at line 943 of file FBVector.h.

                                               {
    return const_reverse_iterator(begin());

template<class T, class Allocator>

void folly::fbvector< T, Allocator >::reserve ( size_type  n )

inline

Definition at line 1003 of file FBVector.h.

Referenced by folly::IOBuf::getIov(), proxygen::HTTPHeaders::HTTPHeaders(), folly::fbvector< HTTPHeaderCode >::resize(), and TEST().

                            {
    if (n <= capacity()) {
      return;
    }
    if (impl_.b_ && reserve_in_place(n)) {
      return;
    }

    auto newCap = folly::goodMallocSize(n * sizeof(T)) / sizeof(T);
    auto newB = M_allocate(newCap);
    try {
      M_relocate(newB);
    } catch (...) {
      M_deallocate(newB, newCap);
      throw;
    }
    if (impl_.b_) {
      M_deallocate(impl_.b_, size_type(impl_.z_ - impl_.b_));
    }
    impl_.z_ = newB + newCap;
    impl_.e_ = newB + (impl_.e_ - impl_.b_);
    impl_.b_ = newB;

template<class T, class Allocator>

bool folly::fbvector< T, Allocator >::reserve_in_place ( size_type  n )

inlineprivate

Definition at line 1071 of file FBVector.h.

Referenced by folly::fbvector< HTTPHeaderCode >::insert_use_fresh(), and folly::fbvector< HTTPHeaderCode >::reserve().

        :
  bool reserve_in_place(size_type n) {
    if (!usingStdAllocator::value || !usingJEMalloc()) {
      return false;
    }

    // jemalloc can never grow in place blocks smaller than 4096 bytes.
    if ((impl_.z_ - impl_.b_) * sizeof(T) <
        folly::jemallocMinInPlaceExpandable) {
      return false;
    }

    auto const newCapacityBytes = folly::goodMallocSize(n * sizeof(T));
    void* p = impl_.b_;
    if (xallocx(p, newCapacityBytes, 0, 0) == newCapacityBytes) {
      impl_.z_ = impl_.b_ + newCapacityBytes / sizeof(T);
      return true;
    }
    return false;

template<class T, class Allocator>

void folly::fbvector< T, Allocator >::resize ( size_type  n )

inline

Definition at line 973 of file FBVector.h.

                           {
    if (n <= size()) {
      M_destroy_range_e(impl_.b_ + n);
    } else {
      reserve(n);
      M_uninitialized_fill_n_e(n - size());
    }

template<class T, class Allocator>

void folly::fbvector< T, Allocator >::resize ( size_type  n, VT  t  )

inline

Definition at line 982 of file FBVector.h.

                                 {
    if (n <= size()) {
      M_destroy_range_e(impl_.b_ + n);
    } else if (dataIsInternalAndNotVT(t) && n > capacity()) {
      T copy(t);
      reserve(n);
      M_uninitialized_fill_n_e(n - size(), copy);
    } else {
      reserve(n);
      M_uninitialized_fill_n_e(n - size(), t);
    }

template<class T, class Allocator>

template<typename It >

static It folly::fbvector< T, Allocator >::S_copy_n ( T *  dest, It  first, size_type  n  )

inlinestaticprivate

Definition at line 582 of file FBVector.h.

Referenced by folly::fbvector< HTTPHeaderCode >::assign().

                                                     {
    auto e = dest + n;
    for (; dest != e; ++dest, ++first) {
      *dest = *first;
    }
    return first;

template<class T, class Allocator>

static const T* folly::fbvector< T, Allocator >::S_copy_n ( T *  dest, const T *  first, size_type  n  )

inlinestaticprivate

Definition at line 590 of file FBVector.h.

                                                                 {
    if (is_trivially_copyable<T>::value) {
      std::memcpy((void*)dest, (void*)first, n * sizeof(T));
      return first + n;
    } else {
      return S_copy_n<const T*>(dest, first, n);
    }

template<class T, class Allocator>

static std::move_iterator<T*> folly::fbvector< T, Allocator >::S_copy_n ( T *  dest, std::move_iterator< T * >  mIt, size_type  n  )

inlinestaticprivate

Definition at line 600 of file FBVector.h.

                                                           {
    if (is_trivially_copyable<T>::value) {
      T* first = mIt.base();
      std::memcpy((void*)dest, (void*)first, n * sizeof(T));
      return std::make_move_iterator(first + n);
    } else {
      return S_copy_n<std::move_iterator<T*>>(dest, mIt, n);
    }

template<class T, class Allocator>

static void folly::fbvector< T, Allocator >::S_destroy_range ( T *  first, T *  last  )

inlinestaticprivatenoexcept

Definition at line 379 of file FBVector.h.

Referenced by folly::fbvector< HTTPHeaderCode >::D_destroy_range_a(), folly::fbvector< T, Allocator >::Impl::destroy(), folly::fbvector< HTTPHeaderCode >::S_uninitialized_copy(), and folly::fbvector< HTTPHeaderCode >::S_uninitialized_fill_n().

                                                          {
    if (!std::is_trivially_destructible<T>::value) {
#define FOLLY_FBV_OP(p) (p)->~T()
      // EXPERIMENTAL DATA on fbvector<vector<int>> (where each vector<int> has
      //  size 0).
      // The unrolled version seems to work faster for small to medium sized
      //  fbvectors. It gets a 10% speedup on fbvectors of size 1024, 64, and
      //  16.
      // The simple loop version seems to work faster for large fbvectors. The
      //  unrolled version is about 6% slower on fbvectors on size 16384.
      // The two methods seem tied for very large fbvectors. The unrolled
      //  version is about 0.5% slower on size 262144.

      // for (; first != last; ++first) first->~T();
      FOLLY_FBV_UNROLL_PTR(first, last, FOLLY_FBV_OP)
#undef FOLLY_FBV_OP
    }

template<class T, class Allocator>

static void folly::fbvector< T, Allocator >::S_destroy_range_a ( Allocator &  a, T *  first, T *  last  )

inlinestaticprivatenoexcept

Definition at line 372 of file FBVector.h.

Referenced by folly::fbvector< HTTPHeaderCode >::D_destroy_range_a(), folly::fbvector< T, Allocator >::Impl::destroy(), folly::fbvector< HTTPHeaderCode >::S_uninitialized_copy_a(), and folly::fbvector< HTTPHeaderCode >::S_uninitialized_fill_n_a().

                                                                          {
    for (; first != last; ++first) {
      std::allocator_traits<Allocator>::destroy(a, first);
    }
  }

template<class T, class Allocator>

template<typename It >

static void folly::fbvector< T, Allocator >::S_uninitialized_copy ( T *  dest, It  first, It  last  )

inlinestaticprivate

Definition at line 539 of file FBVector.h.

Referenced by folly::fbvector< HTTPHeaderCode >::D_uninitialized_copy_a(), and folly::fbvector< HTTPHeaderCode >::S_uninitialized_copy_bits().

                                                               {
    auto b = dest;
    try {
      for (; first != last; ++first, ++b) {
        S_construct(b, *first);
      }
    } catch (...) {
      S_destroy_range(dest, b);
      throw;
    }

template<class T, class Allocator>

template<typename It >

static void folly::fbvector< T, Allocator >::S_uninitialized_copy_a ( Allocator &  a, T *  dest, It  first, It  last  )

inlinestaticprivate

Definition at line 525 of file FBVector.h.

Referenced by folly::fbvector< HTTPHeaderCode >::D_uninitialized_copy_a().

                                                                               {
    auto b = dest;
    try {
      for (; first != last; ++first, ++b) {
        std::allocator_traits<Allocator>::construct(a, b, *first);
      }
    } catch (...) {
      S_destroy_range_a(a, dest, b);
      throw;
    }

template<class T, class Allocator>

static void folly::fbvector< T, Allocator >::S_uninitialized_copy_bits ( T *  dest, const T *  first, const T *  last  )

inlinestaticprivate

Definition at line 552 of file FBVector.h.

Referenced by folly::fbvector< HTTPHeaderCode >::D_uninitialized_copy_a().

                                                                    {
    if (last != first) {
      std::memcpy((void*)dest, (void*)first, (last - first) * sizeof(T));
    }

template<class T, class Allocator>

static void folly::fbvector< T, Allocator >::S_uninitialized_copy_bits ( T *  dest, std::move_iterator< T * >  first, std::move_iterator< T * >  last  )

inlinestaticprivate

Definition at line 558 of file FBVector.h.

                                 {
    T* bFirst = first.base();
    T* bLast = last.base();
    if (bLast != bFirst) {
      std::memcpy((void*)dest, (void*)bFirst, (bLast - bFirst) * sizeof(T));
    }

template<class T, class Allocator>

template<typename It >

static void folly::fbvector< T, Allocator >::S_uninitialized_copy_bits ( T *  dest, It  first, It  last  )

inlinestaticprivate

Definition at line 570 of file FBVector.h.

                                                                    {
    S_uninitialized_copy(dest, first, last);

template<class T, class Allocator>

static void folly::fbvector< T, Allocator >::S_uninitialized_fill_n ( T *  dest, size_type  n  )

inlinestaticprivate

Definition at line 449 of file FBVector.h.

Referenced by folly::fbvector< HTTPHeaderCode >::D_uninitialized_fill_n_a().

                                                           {
    if (folly::IsZeroInitializable<T>::value) {
      if (LIKELY(n != 0)) {
        std::memset(dest, 0, sizeof(T) * n);
      }
    } else {
      auto b = dest;
      auto e = dest + n;
      try {
        for (; b != e; ++b) {
          S_construct(b);
        }
      } catch (...) {
        --b;
        for (; b >= dest; --b) {
          b->~T();
        }
        throw;
      }
    }

template<class T, class Allocator>

static void folly::fbvector< T, Allocator >::S_uninitialized_fill_n ( T *  dest, size_type  n, const T &  value  )

inlinestaticprivate

Definition at line 471 of file FBVector.h.

                                                                           {
    auto b = dest;
    auto e = dest + n;
    try {
      for (; b != e; ++b) {
        S_construct(b, value);
      }
    } catch (...) {
      S_destroy_range(dest, b);
      throw;
    }

template<class T, class Allocator>

template<typename... Args>

static void folly::fbvector< T, Allocator >::S_uninitialized_fill_n_a ( Allocator &  a, T *  dest, size_type  sz, Args &&...  args  )

inlinestaticprivate

Definition at line 430 of file FBVector.h.

Referenced by folly::fbvector< HTTPHeaderCode >::D_uninitialized_fill_n_a().

                      {
    auto b = dest;
    auto e = dest + sz;
    try {
      for (; b != e; ++b) {
        std::allocator_traits<Allocator>::construct(
            a, b, std::forward<Args>(args)...);
      }
    } catch (...) {
      S_destroy_range_a(a, dest, b);
      throw;
    }

template<class T, class Allocator>

void folly::fbvector< T, Allocator >::shrink_to_fit ( )

inlinenoexcept

Definition at line 1027 of file FBVector.h.

Referenced by TEST().

                                {
    if (empty()) {
      impl_.reset();
      return;
    }

    auto const newCapacityBytes = folly::goodMallocSize(size() * sizeof(T));
    auto const newCap = newCapacityBytes / sizeof(T);
    auto const oldCap = capacity();

    if (newCap >= oldCap) {
      return;
    }

    void* p = impl_.b_;
    // xallocx() will shrink to precisely newCapacityBytes (which was generated
    // by goodMallocSize()) if it successfully shrinks in place.
    if ((usingJEMalloc() && usingStdAllocator::value) &&
        newCapacityBytes >= folly::jemallocMinInPlaceExpandable &&
        xallocx(p, newCapacityBytes, 0, 0) == newCapacityBytes) {
      impl_.z_ += newCap - oldCap;
    } else {
      T* newB; // intentionally uninitialized
      try {
        newB = M_allocate(newCap);
        try {
          M_relocate(newB);
        } catch (...) {
          M_deallocate(newB, newCap);
          return; // swallow the error
        }
      } catch (...) {
        return;
      }
      if (impl_.b_) {
        M_deallocate(impl_.b_, size_type(impl_.z_ - impl_.b_));
      }
      impl_.z_ = newB + newCap;
      impl_.e_ = newB + (impl_.e_ - impl_.b_);
      impl_.b_ = newB;
    }

template<class T, class Allocator>

size_type folly::fbvector< T, Allocator >::size ( ) const

inlinenoexcept

Definition at line 964 of file FBVector.h.

Referenced by folly::fbvector< HTTPHeaderCode >::assign(), folly::fbvector< HTTPHeaderCode >::at(), folly::fbvector< HTTPHeaderCode >::computeInsertCapacity(), proxygen::HTTPHeaders::copyTo(), proxygen::HTTPHeaders::disposeOfHeaderNames(), folly::fbvector< HTTPHeaderCode >::do_real_insert(), folly::fbvector< T, Allocator >::emplace_back_aux(), proxygen::HTTPHeaders::exists(), proxygen::HTTPHeaders::forEach(), proxygen::HTTPHeaders::forEachWithCode(), proxygen::HTTPHeaders::HTTPHeaders(), folly::fbvector< HTTPHeaderCode >::insert_use_fresh(), proxygen::HTTPHeaders::operator=(), folly::fbvector< HTTPHeaderCode >::operator==(), folly::fbvector< HTTPHeaderCode >::operator[](), proxygen::HTTPHeaders::removeByPredicate(), folly::fbvector< HTTPHeaderCode >::resize(), folly::fbvector< HTTPHeaderCode >::shrink_to_fit(), proxygen::HTTPHeaders::size(), proxygen::HTTPHeaders::stripPerHopHeaders(), TEST(), and folly::fbvector< HTTPHeaderCode >::wrap_frame().

       :
  size_type size() const noexcept {
    return size_type(impl_.e_ - impl_.b_);

template<class T, class Allocator>

static void folly::fbvector< T, Allocator >::swap ( Impl &  a, Impl &  b  )

inlinestaticprivate

Definition at line 190 of file FBVector.h.

Referenced by folly::fbvector< HTTPHeaderCode >::moveFrom(), and folly::fbvector< HTTPHeaderCode >::swap().

                                     {
    using std::swap;
    if (!usingStdAllocator::value) {
      swap(static_cast<Allocator&>(a), static_cast<Allocator&>(b));
    }
    a.swapData(b);
  }

template<class T, class Allocator>

void folly::fbvector< T, Allocator >::swap ( fbvector< T, Allocator > &  other )

inlinenoexcept

Definition at line 1180 of file FBVector.h.

                                      {
    if (!usingStdAllocator::value && A::propagate_on_container_swap::value) {
      swap(impl_, other.impl_);
    } else {
      impl_.swapData(other.impl_);
    }

template<class T, class Allocator>

void folly::fbvector< T, Allocator >::undo_window ( iterator  position, size_type  n  )

inlineprivatenoexcept

Definition at line 1362 of file FBVector.h.

Referenced by folly::fbvector< HTTPHeaderCode >::do_real_insert().

                                                            {
    D_destroy_range_a(position + n, impl_.e_);
    impl_.e_ = position;

template<class T, class Allocator>

void folly::fbvector< T, Allocator >::wrap_frame ( T *  ledge, size_type  idx, size_type  n  )

inlineprivate

Definition at line 1370 of file FBVector.h.

Referenced by folly::fbvector< HTTPHeaderCode >::do_real_insert().

                                                        {
    assert(size() >= idx);
    assert(n != 0);

    relocate_move(ledge, impl_.b_, impl_.b_ + idx);
    try {
      relocate_move(ledge + idx + n, impl_.b_ + idx, impl_.e_);
    } catch (...) {
      relocate_undo(ledge, impl_.b_, impl_.b_ + idx);
      throw;
    }
    relocate_done(ledge, impl_.b_, impl_.b_ + idx);
    relocate_done(ledge + idx + n, impl_.b_ + idx, impl_.e_);

Friends And Related Function Documentation

template<class T, class Allocator>

template<class _T , class _A >

void attach ( fbvector< _T, _A > &  , _T *  data, size_t  sz, size_t  cap  )

friend

Referenced by folly::fbvector< HTTPHeaderCode >::operator>=().

template<class T, class Allocator>

template<class _T , class _A >

_T* relinquish ( fbvector< _T, _A > &  )

friend

Referenced by folly::fbvector< HTTPHeaderCode >::operator>=().

Member Data Documentation

template<class T, class Allocator>

folly::fbvector< T, Allocator >::else

private

Initial value:

{
      std::allocator_traits<Allocator>::destroy(impl_, p)

Definition at line 343 of file FBVector.h.

template<class T, class Allocator>

folly::fbvector::Impl folly::fbvector< T, Allocator >::impl_

private

Referenced by folly::fbvector< HTTPHeaderCode >::assign(), folly::fbvector< HTTPHeaderCode >::back(), folly::fbvector< HTTPHeaderCode >::begin(), folly::fbvector< HTTPHeaderCode >::capacity(), folly::fbvector< HTTPHeaderCode >::cbegin(), folly::fbvector< HTTPHeaderCode >::cend(), folly::fbvector< HTTPHeaderCode >::clear(), folly::fbvector< HTTPHeaderCode >::D_destroy_range_a(), folly::fbvector< HTTPHeaderCode >::D_uninitialized_copy_a(), folly::fbvector< HTTPHeaderCode >::D_uninitialized_fill_n_a(), folly::fbvector< HTTPHeaderCode >::data(), folly::fbvector< HTTPHeaderCode >::dataIsInternal(), folly::fbvector< HTTPHeaderCode >::do_real_insert(), folly::fbvector< HTTPHeaderCode >::emplace_back(), folly::fbvector< T, Allocator >::emplace_back_aux(), folly::fbvector< HTTPHeaderCode >::empty(), folly::fbvector< HTTPHeaderCode >::end(), folly::fbvector< HTTPHeaderCode >::erase(), folly::fbvector< HTTPHeaderCode >::fbvector(), folly::fbvector< HTTPHeaderCode >::front(), folly::fbvector< HTTPHeaderCode >::get_allocator(), folly::fbvector< HTTPHeaderCode >::insert(), folly::fbvector< HTTPHeaderCode >::M_destroy_range_e(), folly::fbvector< HTTPHeaderCode >::M_relocate(), folly::fbvector< HTTPHeaderCode >::M_uninitialized_copy_e(), folly::fbvector< HTTPHeaderCode >::M_uninitialized_fill_n_e(), folly::fbvector< HTTPHeaderCode >::M_uninitialized_move_e(), folly::fbvector< HTTPHeaderCode >::make_window(), folly::fbvector< HTTPHeaderCode >::moveFrom(), folly::fbvector< HTTPHeaderCode >::operator=(), folly::fbvector< HTTPHeaderCode >::operator[](), folly::fbvector< HTTPHeaderCode >::pop_back(), folly::fbvector< HTTPHeaderCode >::push_back(), folly::fbvector< HTTPHeaderCode >::reserve(), folly::fbvector< HTTPHeaderCode >::reserve_in_place(), folly::fbvector< T, Allocator >::Impl::reset(), folly::fbvector< HTTPHeaderCode >::resize(), folly::fbvector< HTTPHeaderCode >::shrink_to_fit(), folly::fbvector< HTTPHeaderCode >::size(), folly::fbvector< HTTPHeaderCode >::swap(), folly::fbvector< HTTPHeaderCode >::undo_window(), and folly::fbvector< HTTPHeaderCode >::wrap_frame().

---

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

• proxygen/folly/folly/FBVector.h