folly::detail::IntegralSizePolicy< SizeType, true > Struct Template Reference

#include <small_vector.h>

Inheritance diagram for folly::detail::IntegralSizePolicy< SizeType, true >:

Public Member Functions
template<class T >
std::enable_if<!folly::is_trivially_copyable< T >::value >::type	moveToUninitialized (T *first, T *last, T *out)
template<class T >
std::enable_if< folly::is_trivially_copyable< T >::value >::type	moveToUninitialized (T *first, T *last, T *out)
template<class T , class EmplaceFunc >
void	moveToUninitializedEmplace (T *begin, T *end, T *out, SizeType pos, EmplaceFunc &&emplaceFunc)
Public Member Functions inherited from folly::detail::IntegralSizePolicyBase< SizeType, true >
	IntegralSizePolicyBase ()

Additional Inherited Members
Public Types inherited from folly::detail::IntegralSizePolicyBase< SizeType, true >
typedef SizeType	InternalSizeType
Protected Member Functions inherited from folly::detail::IntegralSizePolicyBase< SizeType, true >
std::size_t	doSize () const
std::size_t	isExtern () const
void	setExtern (bool b)
void	setSize (std::size_t sz)
void	swapSizePolicy (IntegralSizePolicyBase &o)
Static Protected Member Functions inherited from folly::detail::IntegralSizePolicyBase< SizeType, true >
static constexpr std::size_t	policyMaxSize ()
Static Protected Attributes inherited from folly::detail::IntegralSizePolicyBase< SizeType, true >
static bool constexpr	kShouldUseHeap

Detailed Description

template<class SizeType>
struct folly::detail::IntegralSizePolicy< SizeType, true >

Definition at line 221 of file small_vector.h.

Member Function Documentation

template<class SizeType >

template<class T >

std::enable_if<!folly::is_trivially_copyable<T>::value>::type folly::detail::IntegralSizePolicy< SizeType, true >::moveToUninitialized ( T *  first, T *  last, T *  out  )

inline

Definition at line 230 of file small_vector.h.

References folly::gen::first, i, folly::gen::move, T, type, and value.

                                                 {
    std::size_t idx = 0;
    try {
      for (; first != last; ++first, ++idx) {
        new (&out[idx]) T(std::move(*first));
      }
    } catch (...) {
      // Even for callers trying to give the strong guarantee
      // (e.g. push_back) it's ok to assume here that we don't have to
      // move things back and that it was a copy constructor that
      // threw: if someone throws from a move constructor the effects
      // are unspecified.
      for (std::size_t i = 0; i < idx; ++i) {
        out[i].~T();
      }
      throw;
    }
  }

template<class SizeType >

template<class T >

std::enable_if<folly::is_trivially_copyable<T>::value>::type folly::detail::IntegralSizePolicy< SizeType, true >::moveToUninitialized ( T *  first, T *  last, T *  out  )

inline

Definition at line 252 of file small_vector.h.

                                                 {
    std::memmove(out, first, (last - first) * sizeof *first);
  }

template<class SizeType >

template<class T , class EmplaceFunc >

void folly::detail::IntegralSizePolicy< SizeType, true >::moveToUninitializedEmplace ( T *  begin, T *  end, T *  out, SizeType  pos, EmplaceFunc &&  emplaceFunc  )

inline

Definition at line 263 of file small_vector.h.

References i.

                                 {
    // Must be called first so that if it throws [begin, end) is unmodified.
    // We have to support the strong exception guarantee for emplace_back().
    emplaceFunc(out + pos);
    // move old elements to the left of the new one
    try {
      this->moveToUninitialized(begin, begin + pos, out);
    } catch (...) {
      out[pos].~T();
      throw;
    }
    // move old elements to the right of the new one
    try {
      if (begin + pos < end) {
        this->moveToUninitialized(begin + pos, end, out + pos + 1);
      }
    } catch (...) {
      for (SizeType i = 0; i <= pos; ++i) {
        out[i].~T();
      }
      throw;
    }
  }

---

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

• proxygen/folly/folly/small_vector.h