#include <flow_vector.h>

Public Types
using	value_type = T
using	reference = T&
using	const_reference = const T&
using	pointer = T*
using	const_pointer = const T*
using	iterator = T*
using	const_iterator = const T*
using	size_type = std::size_t
using	difference_type = std::ptrdiff_t
using	allocator_type = Allocator

Public Member Functions
constexpr	Vector () noexcept
	Constructs an empty vector with default allocator and growth strategy.
constexpr	Vector (const allocator_type &allocator) noexcept(noexcept(allocator_type(allocator)))
	Constructs an empty vector with a specific allocator.
constexpr	Vector (const Vector &rhs)
	Copy-constructs a vector using the same allocator as the source.
constexpr	Vector (const Vector &rhs, const allocator_type &allocator)
	Copy-constructs a vector with a custom allocator.
constexpr	Vector (Vector &&rhs) noexcept
	Move-constructs a vector with the same allocator as the source.
constexpr	Vector (Vector &&rhs, const allocator_type &allocator)
	Move-constructs a vector with a custom allocator.
template<std::input_iterator It>
constexpr	Vector (It first, It last, const allocator_type &allocator={})
	Constructs a vector from an iterator range.
constexpr	Vector (std::initializer_list< T > list, const allocator_type &allocator={})
	Constructs a vector from an initializer list.
constexpr	Vector (std::size_t count, const allocator_type &allocator={})
	Constructs a vector with count default-initialized elements.
constexpr	Vector (std::size_t count, const T &value, const allocator_type &allocator={})
	Constructs a vector with count copies of a given value.
	~Vector ()
Vector &	operator= (Vector rhs) noexcept(std::is_nothrow_swappable_v< Vector >)
T &	operator[] (std::size_t i) noexcept
const T &	operator[] (std::size_t i) const noexcept
allocator_type	get_allocator () const noexcept
	Returns the current allocator.
iterator	begin () noexcept
constexpr const_iterator	begin () const noexcept
iterator	end () noexcept
constexpr const_iterator	end () const noexcept
constexpr std::size_t	size () const noexcept
	Returns the number of elements in the vector.
constexpr std::size_t	capacity () const noexcept
	Returns the total allocated capacity.
constexpr bool	empty () const noexcept
	Checks whether the vector is empty.
T &	front () noexcept
	Returns a reference to the first element.
constexpr const T &	front () const noexcept
	Returns a reference to the first element.
T &	back () noexcept
	Returns a reference to the last element.
constexpr const T &	back () const noexcept
	Returns a reference to the last element.
void	clear () noexcept
	Clears the contents of the vector.
void	reserve (std::size_t capacity)
	Ensures the vector can hold at least the given capacity without reallocating.
void	resize (std::size_t size)
	Resizes the vector to contain the given number of default constructed elements.
void	resize (std::size_t size, const T &value)
	Resizes the vector and fills new elements with a given value.
void	pushBack (const T &value)
	Adds an element to the end of the vector.
void	pushBack (T &&value)
	Adds an element to the end of the vector.
template<typename ... Args>
void	emplaceBack (Args &&... args)
	Constructs an element in-place at the end of the vector.
void	popBack () noexcept
	Removes the last element of the vector.
iterator	erase (iterator pos) noexcept
	Removes an element at the specified iterator position.
iterator	erase (iterator first, iterator last) noexcept
	Removes elements in the range [first, last).
template<typename ... Args>
void	emplace (iterator pos, Args &&... args)
	Constructs an element in-place at the specified iterator position.
void	insert (iterator pos, const T &value)
	Inserts a copy of an element at the specified iterator position.
void	insert (iterator pos, T &&value)
	Inserts a moved element at the specified iterator position.
void	insert (iterator pos, std::size_t count, const T &value)
	Inserts multiple copies of a value at the specified position.
template<std::input_iterator It>
void	insert (iterator pos, It first, It last)
	Inserts a range of elements at the specified position. Does not support self-insertion.
void	insert (iterator pos, std::initializer_list< T > list)
	Inserts an initializer list of elements at the specified position.

Private Types
using	allocator_trait = std::allocator_traits<Allocator>

Private Member Functions
void	updateBuffer (T *buffer, std::size_t capacity)
void	relocateBuffer (std::size_t capacity)
void	relocateBufferWithHoles (std::size_t capacity, iterator pos, std::size_t holeSize)
template<typename ... U>
void	resizeImp (std::size_t size, const U &... optionalValue)

Private Attributes
allocator_type	allocator_
Strategy	growthStrategy_
std::size_t	size_
std::size_t	capacity_
T *	buffer_

Friends
void	swap (Vector &lhs, Vector &rhs) noexcept

Detailed Description

template<typename T, typename Allocator = PolymorphicAllocator<T>, GrowthStrategy Strategy = VectorGrowthStrategy::GoldenExpand>
class flow::Vector< T, Allocator, Strategy >

Definition at line 49 of file flow_vector.h.

Member Typedef Documentation

◆ allocator_trait

template<typename T, typename Allocator = PolymorphicAllocator<T>, GrowthStrategy Strategy = VectorGrowthStrategy::GoldenExpand>

using flow::Vector< T, Allocator, Strategy >::allocator_trait = std::allocator_traits<Allocator>

private

Definition at line 65 of file flow_vector.h.

◆ allocator_type

template<typename T, typename Allocator = PolymorphicAllocator<T>, GrowthStrategy Strategy = VectorGrowthStrategy::GoldenExpand>

using flow::Vector< T, Allocator, Strategy >::allocator_type = Allocator

Definition at line 61 of file flow_vector.h.

◆ const_iterator

template<typename T, typename Allocator = PolymorphicAllocator<T>, GrowthStrategy Strategy = VectorGrowthStrategy::GoldenExpand>

using flow::Vector< T, Allocator, Strategy >::const_iterator = const T*

Definition at line 57 of file flow_vector.h.

◆ const_pointer

template<typename T, typename Allocator = PolymorphicAllocator<T>, GrowthStrategy Strategy = VectorGrowthStrategy::GoldenExpand>

using flow::Vector< T, Allocator, Strategy >::const_pointer = const T*

Definition at line 55 of file flow_vector.h.

◆ const_reference

template<typename T, typename Allocator = PolymorphicAllocator<T>, GrowthStrategy Strategy = VectorGrowthStrategy::GoldenExpand>

using flow::Vector< T, Allocator, Strategy >::const_reference = const T&

Definition at line 53 of file flow_vector.h.

◆ difference_type

template<typename T, typename Allocator = PolymorphicAllocator<T>, GrowthStrategy Strategy = VectorGrowthStrategy::GoldenExpand>

using flow::Vector< T, Allocator, Strategy >::difference_type = std::ptrdiff_t

Definition at line 59 of file flow_vector.h.

◆ iterator

template<typename T, typename Allocator = PolymorphicAllocator<T>, GrowthStrategy Strategy = VectorGrowthStrategy::GoldenExpand>

using flow::Vector< T, Allocator, Strategy >::iterator = T*

Definition at line 56 of file flow_vector.h.

◆ pointer

template<typename T, typename Allocator = PolymorphicAllocator<T>, GrowthStrategy Strategy = VectorGrowthStrategy::GoldenExpand>

using flow::Vector< T, Allocator, Strategy >::pointer = T*

Definition at line 54 of file flow_vector.h.

◆ reference

template<typename T, typename Allocator = PolymorphicAllocator<T>, GrowthStrategy Strategy = VectorGrowthStrategy::GoldenExpand>

using flow::Vector< T, Allocator, Strategy >::reference = T&

Definition at line 52 of file flow_vector.h.

◆ size_type

template<typename T, typename Allocator = PolymorphicAllocator<T>, GrowthStrategy Strategy = VectorGrowthStrategy::GoldenExpand>

using flow::Vector< T, Allocator, Strategy >::size_type = std::size_t

Definition at line 58 of file flow_vector.h.

◆ value_type

template<typename T, typename Allocator = PolymorphicAllocator<T>, GrowthStrategy Strategy = VectorGrowthStrategy::GoldenExpand>

using flow::Vector< T, Allocator, Strategy >::value_type = T

Definition at line 51 of file flow_vector.h.

Constructor & Destructor Documentation

◆ Vector() [1/10]

template<typename T, typename Allocator = PolymorphicAllocator<T>, GrowthStrategy Strategy = VectorGrowthStrategy::GoldenExpand>

flow::Vector< T, Allocator, Strategy >::Vector ( )

inlineconstexprnoexcept

Constructs an empty vector with default allocator and growth strategy.

Definition at line 75 of file flow_vector.h.

76 : Vector(allocator_type{}) {

77 }

flow::Vector::allocator_type

Allocator allocator_type

Definition flow_vector.h:61

flow::Vector::Vector

constexpr Vector() noexcept

Constructs an empty vector with default allocator and growth strategy.

Definition flow_vector.h:75

◆ Vector() [2/10]

template<typename T, typename Allocator = PolymorphicAllocator<T>, GrowthStrategy Strategy = VectorGrowthStrategy::GoldenExpand>

flow::Vector< T, Allocator, Strategy >::Vector ( const allocator_type & allocator )

inlineexplicitconstexprnoexcept

Constructs an empty vector with a specific allocator.

Parameters

allocator Memory allocator.

Definition at line 81 of file flow_vector.h.

      : allocator_(allocator),
      growthStrategy_(),
      size_(0),
      capacity_(0),
      buffer_(nullptr) {
    }

◆ Vector() [3/10]

template<typename T, typename Allocator = PolymorphicAllocator<T>, GrowthStrategy Strategy = VectorGrowthStrategy::GoldenExpand>

flow::Vector< T, Allocator, Strategy >::Vector ( const Vector< T, Allocator, Strategy > & rhs )

inlineconstexpr

Copy-constructs a vector using the same allocator as the source.

Parameters

rhs	Source vector.

Definition at line 92 of file flow_vector.h.

93 : Vector(rhs, rhs.get_allocator()) {

94 }

flow::Vector::get_allocator

allocator_type get_allocator() const noexcept

Returns the current allocator.

Definition flow_vector.h:202

◆ Vector() [4/10]

template<typename T, typename Allocator = PolymorphicAllocator<T>, GrowthStrategy Strategy = VectorGrowthStrategy::GoldenExpand>

flow::Vector< T, Allocator, Strategy >::Vector	(	const Vector< T, Allocator, Strategy > &	rhs,
		const allocator_type &	allocator )

inlineconstexpr

Copy-constructs a vector with a custom allocator.

Parameters

rhs	Source vector.
allocator	Memory allocator.

Definition at line 99 of file flow_vector.h.

      : allocator_(allocator),
      growthStrategy_(rhs.growthStrategy_),
      size_(rhs.size_),
      capacity_(rhs.capacity_),
      buffer_(allocator_trait::allocate(allocator_, rhs.capacity_)) {
      uninitializedForward(allocator_, rhs.begin(), rhs.end(), buffer_);
    }

◆ Vector() [5/10]

template<typename T, typename Allocator = PolymorphicAllocator<T>, GrowthStrategy Strategy = VectorGrowthStrategy::GoldenExpand>

flow::Vector< T, Allocator, Strategy >::Vector ( Vector< T, Allocator, Strategy > && rhs )

inlineconstexprnoexcept

Move-constructs a vector with the same allocator as the source.

Parameters

rhs	Source vector.

Definition at line 110 of file flow_vector.h.

111 : Vector(std::move(rhs), rhs.get_allocator()) {

112 }

◆ Vector() [6/10]

template<typename T, typename Allocator = PolymorphicAllocator<T>, GrowthStrategy Strategy = VectorGrowthStrategy::GoldenExpand>

flow::Vector< T, Allocator, Strategy >::Vector	(	Vector< T, Allocator, Strategy > &&	rhs,
		const allocator_type &	allocator )

inlineconstexpr

Move-constructs a vector with a custom allocator.

Parameters

rhs	Source vector.
allocator	Memory allocator.

Definition at line 117 of file flow_vector.h.

      : Vector(allocator) {
 
      // If allocator is different, then do not use the provided allocator
      // to manage the memory of an existed vector.
      if (rhs.get_allocator() == allocator) {
        swap(*this, rhs);
      } else {
        // Create a copy with new allocator, then swap over.
        Vector rhsCopy(rhs, allocator);
        swap(*this, rhsCopy);
      }
    }

◆ Vector() [7/10]

template<typename T, typename Allocator = PolymorphicAllocator<T>, GrowthStrategy Strategy = VectorGrowthStrategy::GoldenExpand>

template<std::input_iterator It>

flow::Vector< T, Allocator, Strategy >::Vector	(	It	first,
		It	last,
		const allocator_type &	allocator = {} )

inlineexplicitconstexpr

Constructs a vector from an iterator range.

Template Parameters

It	Input iterator.

Parameters

first	Start of the range.
last	End of the range.
allocator	Memory allocator.

Definition at line 137 of file flow_vector.h.

                                                                                   {})
      : allocator_(allocator),
      growthStrategy_(),
      size_(std::distance(first, last)),
      capacity_(size_),
      buffer_(allocator_trait::allocate(allocator_, capacity_)) {
      uninitializedForward(allocator_, first, last, buffer_);
    }

◆ Vector() [8/10]

template<typename T, typename Allocator = PolymorphicAllocator<T>, GrowthStrategy Strategy = VectorGrowthStrategy::GoldenExpand>

flow::Vector< T, Allocator, Strategy >::Vector	(	std::initializer_list< T >	list,
		const allocator_type &	allocator = {} )

inlineconstexpr

Constructs a vector from an initializer list.

Parameters

list	Elements to initialize the vector with.
allocator	Memory allocator.

Definition at line 149 of file flow_vector.h.

                                                                                    {})
      : Vector(list.begin(), list.end(), allocator) {
    }

◆ Vector() [9/10]

template<typename T, typename Allocator = PolymorphicAllocator<T>, GrowthStrategy Strategy = VectorGrowthStrategy::GoldenExpand>

flow::Vector< T, Allocator, Strategy >::Vector	(	std::size_t	count,
		const allocator_type &	allocator = {} )

inlineexplicitconstexpr

Constructs a vector with count default-initialized elements.

Parameters

count	Number of elements.
allocator	Memory allocator.

Definition at line 156 of file flow_vector.h.

                                                                                 {})
      : allocator_(allocator),
      growthStrategy_(),
      size_(count),
      capacity_(count),
      buffer_(allocator_trait::allocate(allocator_, count)) {
      uninitializedEmplaceN(allocator_, buffer_, count);
    }

◆ Vector() [10/10]

template<typename T, typename Allocator = PolymorphicAllocator<T>, GrowthStrategy Strategy = VectorGrowthStrategy::GoldenExpand>

flow::Vector< T, Allocator, Strategy >::Vector	(	std::size_t	count,
		const T &	value,
		const allocator_type &	allocator = {} )

inlineexplicitconstexpr

Constructs a vector with count copies of a given value.

Parameters

count	Number of elements.
value	Element value.
allocator	Memory allocator.

Definition at line 169 of file flow_vector.h.

                                                                                                 {})
      : allocator_(allocator),
      growthStrategy_(),
      size_(count),
      capacity_(count),
      buffer_(allocator_trait::allocate(allocator_, count)) {
      uninitializedFillN(allocator_, buffer_, count, value);
    }

◆ ~Vector()

template<typename T, typename Allocator = PolymorphicAllocator<T>, GrowthStrategy Strategy = VectorGrowthStrategy::GoldenExpand>

flow::Vector< T, Allocator, Strategy >::~Vector ( )

inline

Definition at line 179 of file flow_vector.h.

              {
      deleteBuffer(allocator_, buffer_, size_, capacity_);
    }

Member Function Documentation

◆ back() [1/2]

template<typename T, typename Allocator = PolymorphicAllocator<T>, GrowthStrategy Strategy = VectorGrowthStrategy::GoldenExpand>

const T & flow::Vector< T, Allocator, Strategy >::back ( ) const

inlineconstexprnoexcept

Returns a reference to the last element.

Returns: Last element.

Definition at line 264 of file flow_vector.h.

                                             {
      assert(0 < size_ && "access empty Vector back");
      return buffer_[size_ - 1];
    }

◆ back() [2/2]

template<typename T, typename Allocator = PolymorphicAllocator<T>, GrowthStrategy Strategy = VectorGrowthStrategy::GoldenExpand>

T & flow::Vector< T, Allocator, Strategy >::back ( )

inlinenoexcept

Returns a reference to the last element.

Returns: Last element.

Definition at line 257 of file flow_vector.h.

                       {
      assert(0 < size_ && "access empty Vector back");
      return buffer_[size_ - 1];
    }

Referenced by flow::Vector< T, Allocator >::emplace().

◆ begin() [1/2]

template<typename T, typename Allocator = PolymorphicAllocator<T>, GrowthStrategy Strategy = VectorGrowthStrategy::GoldenExpand>

const_iterator flow::Vector< T, Allocator, Strategy >::begin ( ) const

inlineconstexprnoexcept

Definition at line 211 of file flow_vector.h.

                                                    {
      return buffer_;
    }

◆ begin() [2/2]

template<typename T, typename Allocator = PolymorphicAllocator<T>, GrowthStrategy Strategy = VectorGrowthStrategy::GoldenExpand>

iterator flow::Vector< T, Allocator, Strategy >::begin ( )

inlinenoexcept

Definition at line 207 of file flow_vector.h.

                              {
      return buffer_;
    }

Referenced by flow::Vector< T, Allocator >::erase(), flow::Vector< T, Allocator >::erase(), flow::Vector< T, Allocator >::insert(), flow::Vector< T, Allocator >::relocateBuffer(), flow::Vector< T, Allocator >::relocateBufferWithHoles(), and flow::Vector< T, Allocator >::Vector().

◆ capacity()

template<typename T, typename Allocator = PolymorphicAllocator<T>, GrowthStrategy Strategy = VectorGrowthStrategy::GoldenExpand>

std::size_t flow::Vector< T, Allocator, Strategy >::capacity ( ) const

inlineconstexprnoexcept

Returns the total allocated capacity.

Returns: Capacity in elements.

Definition at line 231 of file flow_vector.h.

                                                  {
      return capacity_;
    }

◆ clear()

template<typename T, typename Allocator = PolymorphicAllocator<T>, GrowthStrategy Strategy = VectorGrowthStrategy::GoldenExpand>

void flow::Vector< T, Allocator, Strategy >::clear ( )

inlinenoexcept

Clears the contents of the vector.

Definition at line 270 of file flow_vector.h.

                          {
      destroyElementsN(allocator_, buffer_, size_);
      size_ = 0;
    }

◆ emplace()

template<typename T, typename Allocator = PolymorphicAllocator<T>, GrowthStrategy Strategy = VectorGrowthStrategy::GoldenExpand>

template<typename ... Args>

void flow::Vector< T, Allocator, Strategy >::emplace	(	iterator	pos,
		Args &&...	args )

inline

Constructs an element in-place at the specified iterator position.

Parameters

pos	Insertion position.
...args	Arguments to forward.

Definition at line 357 of file flow_vector.h.

                                               {
      // Special case: append at the end.
      if (pos == end()) {
        emplaceBack(std::forward<Args>(args)...);
        return;
      }
 
      if (size_ < capacity_) {
        // Enough capacity, right shift the elements.
        // Major optimization to use memcpy, copy_backward, or range move_backward instead of handroll loop. A 70% reduction in computation time.
        allocator_trait::construct(allocator_, end(), std::move(back()));
        std::move_backward(pos, end() - 1, end());
        *pos = T(std::forward<Args>(args)...);
 
      } else {
        // Not enough capacity, relocate all to a new buffer.
        std::size_t index = pos - buffer_;
        relocateBufferWithHoles(growthStrategy_(capacity_), pos, 1);
        allocator_trait::construct(allocator_, buffer_ + index, std::forward<Args>(args)...);
      }
      ++size_;
    }

Referenced by flow::Vector< T, Allocator >::insert(), and flow::Vector< T, Allocator >::insert().

◆ emplaceBack()

template<typename T, typename Allocator = PolymorphicAllocator<T>, GrowthStrategy Strategy = VectorGrowthStrategy::GoldenExpand>

template<typename ... Args>

void flow::Vector< T, Allocator, Strategy >::emplaceBack ( Args &&... args )

inline

Constructs an element in-place at the end of the vector.

Parameters

...args Arguments to forward.

Definition at line 314 of file flow_vector.h.

                                     {
      if (size_ == capacity_) {
        relocateBuffer(growthStrategy_(capacity_));
      }
      allocator_trait::construct(allocator_, buffer_ + size_, std::forward<Args>(args)...);
      ++size_;
    }

Referenced by flow::Vector< T, Allocator >::emplace(), flow::Vector< T, Allocator >::pushBack(), and flow::Vector< T, Allocator >::pushBack().

◆ empty()

template<typename T, typename Allocator = PolymorphicAllocator<T>, GrowthStrategy Strategy = VectorGrowthStrategy::GoldenExpand>

bool flow::Vector< T, Allocator, Strategy >::empty ( ) const

inlineconstexprnoexcept

Checks whether the vector is empty.

Returns: true if the vector is empty, false otherwise.

Definition at line 237 of file flow_vector.h.

                                          {
      return size_ == 0;
    }

◆ end() [1/2]

template<typename T, typename Allocator = PolymorphicAllocator<T>, GrowthStrategy Strategy = VectorGrowthStrategy::GoldenExpand>

const_iterator flow::Vector< T, Allocator, Strategy >::end ( ) const

inlineconstexprnoexcept

Definition at line 219 of file flow_vector.h.

                                                  {
      return buffer_ + size_;
    }

◆ end() [2/2]

template<typename T, typename Allocator = PolymorphicAllocator<T>, GrowthStrategy Strategy = VectorGrowthStrategy::GoldenExpand>

iterator flow::Vector< T, Allocator, Strategy >::end ( )

inlinenoexcept

Definition at line 215 of file flow_vector.h.

                            {
      return buffer_ + size_;
    }

Referenced by flow::Vector< T, Allocator >::emplace(), flow::Vector< T, Allocator >::erase(), flow::Vector< T, Allocator >::erase(), flow::Vector< T, Allocator >::insert(), flow::Vector< T, Allocator >::relocateBuffer(), flow::Vector< T, Allocator >::relocateBufferWithHoles(), and flow::Vector< T, Allocator >::Vector().

◆ erase() [1/2]

template<typename T, typename Allocator = PolymorphicAllocator<T>, GrowthStrategy Strategy = VectorGrowthStrategy::GoldenExpand>

iterator flow::Vector< T, Allocator, Strategy >::erase	(	iterator	first,
		iterator	last )

inlinenoexcept

Removes elements in the range [first, last).

Parameters

first	Start of range.
last	End of range.

Returns: Iterator to the next element.

Definition at line 343 of file flow_vector.h.

                                                           {
      assert(begin() <= first && last <= end() && "can not erase before begin() or past the end()");
      assert(first <= last && "first must be before last");
 
      iterator afterMoved = std::move(last, end(), first);
      destroyElements(allocator_, afterMoved, end());
      size_ -= last - first;
      return first;
    }

◆ erase() [2/2]

template<typename T, typename Allocator = PolymorphicAllocator<T>, GrowthStrategy Strategy = VectorGrowthStrategy::GoldenExpand>

iterator flow::Vector< T, Allocator, Strategy >::erase ( iterator pos )

inlinenoexcept

Removes an element at the specified iterator position.

Parameters

pos	Iterator to the element to remove.

Returns: Iterator to the next element.

Definition at line 332 of file flow_vector.h.

                                          {
      assert(begin() <= pos && pos < end() && "can not erase before begin() or at the end()");
      std::move(pos + 1, end(), pos);
      popBack();
      return pos;
    }

◆ front() [1/2]

template<typename T, typename Allocator = PolymorphicAllocator<T>, GrowthStrategy Strategy = VectorGrowthStrategy::GoldenExpand>

const T & flow::Vector< T, Allocator, Strategy >::front ( ) const

inlineconstexprnoexcept

Returns a reference to the first element.

Returns: First element.

Definition at line 250 of file flow_vector.h.

                                              {
      assert(0 < size_ && "access empty Vector front");
      return buffer_[0];
    }

◆ front() [2/2]

template<typename T, typename Allocator = PolymorphicAllocator<T>, GrowthStrategy Strategy = VectorGrowthStrategy::GoldenExpand>

T & flow::Vector< T, Allocator, Strategy >::front ( )

inlinenoexcept

Returns a reference to the first element.

Returns: First element.

Definition at line 243 of file flow_vector.h.

                        {
      assert(0 < size_ && "access empty Vector front");
      return buffer_[0];
    }

◆ get_allocator()

template<typename T, typename Allocator = PolymorphicAllocator<T>, GrowthStrategy Strategy = VectorGrowthStrategy::GoldenExpand>

allocator_type flow::Vector< T, Allocator, Strategy >::get_allocator ( ) const

inlinenoexcept

Returns the current allocator.

Returns: The allocator.

Definition at line 202 of file flow_vector.h.

                                                  {
      return allocator_;
    }

◆ insert() [1/5]

template<typename T, typename Allocator = PolymorphicAllocator<T>, GrowthStrategy Strategy = VectorGrowthStrategy::GoldenExpand>

void flow::Vector< T, Allocator, Strategy >::insert	(	iterator	pos,
		const T &	value )

inline

Inserts a copy of an element at the specified iterator position.

Parameters

pos	Insertion position.
value	Value to insert.

Definition at line 383 of file flow_vector.h.

                                              {
      emplace(pos, value);
    }

Referenced by flow::Vector< T, Allocator >::insert(), and flow::Vector< T, Allocator >::insert().

◆ insert() [2/5]

template<typename T, typename Allocator = PolymorphicAllocator<T>, GrowthStrategy Strategy = VectorGrowthStrategy::GoldenExpand>

template<std::input_iterator It>

void flow::Vector< T, Allocator, Strategy >::insert	(	iterator	pos,
		It	first,
		It	last )

inline

Inserts a range of elements at the specified position. Does not support self-insertion.

Template Parameters

It	Input iterator.

Parameters

pos	Insertion position.
first	Start of range.
last	End of range.

Definition at line 409 of file flow_vector.h.

                                                 {
      const std::size_t insertedElementsSize = std::distance(first, last);
      const std::size_t requiredSize = size_ + insertedElementsSize;
 
      if (capacity_ < requiredSize) {
        // Not enough capacity, relocate to a new buffer.
        std::size_t index = pos - begin();
        std::size_t newCapacity = growthStrategy_(requiredSize);
        relocateBufferWithHoles(newCapacity, pos, insertedElementsSize);
        uninitializedForward(allocator_, first, last, begin() + index);
      } else {
        // Enough capacity, shift elements.
        // Inserted that are inbound = Shifted that are outbound.
        const std::size_t shiftedElementSize = end() - pos;
        const std::size_t conflictedRangeSize = std::min(insertedElementsSize, shiftedElementSize);
        const std::size_t shiftedElementsInboundSize = shiftedElementSize - conflictedRangeSize;
        const std::size_t insertedElementsOutboundSize = insertedElementsSize - conflictedRangeSize;
 
        // Shifted elements that are on uninitialized buffer range.
        // This range can be empty if insert at end().
        uninitializedMove(allocator_, end() - conflictedRangeSize, end(), pos + insertedElementsSize + shiftedElementsInboundSize);
 
        // Shifted elements that are on initialized buffer range.
        // This range can be empty if all shifted elements must move to the uninitialized buffer from the previous step.
        std::move_backward(pos, pos + shiftedElementsInboundSize, end());
 
        // Inserted elements that are on initialized buffer range starting at pos.
        // This range can be empty if insert at end().
        for (std::size_t i = 0; i < conflictedRangeSize; ++i, ++first, ++pos) {
          *pos = *first;
        }
 
        // Inserted elements that are on uninitialized buffer range.
        // This range can be empty if insertedElementSize <= shiftedElementSize -> conflictedRangeSize = insertedElementSize.
        // Such that there are enough space in the initialized buffer range.
        uninitializedForwardN(allocator_, first, insertedElementsOutboundSize, pos);
      }
 
      size_ = requiredSize;
    }

◆ insert() [3/5]

template<typename T, typename Allocator = PolymorphicAllocator<T>, GrowthStrategy Strategy = VectorGrowthStrategy::GoldenExpand>

void flow::Vector< T, Allocator, Strategy >::insert	(	iterator	pos,
		std::initializer_list< T >	list )

inline

Inserts an initializer list of elements at the specified position.

Parameters

pos	Insertion position.
list	Elements to insert.

Definition at line 453 of file flow_vector.h.

                                                           {
      insert(pos, list.begin(), list.end());
    }

◆ insert() [4/5]

template<typename T, typename Allocator = PolymorphicAllocator<T>, GrowthStrategy Strategy = VectorGrowthStrategy::GoldenExpand>

void flow::Vector< T, Allocator, Strategy >::insert	(	iterator	pos,
		std::size_t	count,
		const T &	value )

inline

Inserts multiple copies of a value at the specified position.

Parameters

pos	Insertion position.
count	Number of copies.
value	Value to insert.

Definition at line 398 of file flow_vector.h.

                                                               {
      insert(pos, CountedValueViewIterator(value, count), CountedValueViewIterator(value));
    }

◆ insert() [5/5]

template<typename T, typename Allocator = PolymorphicAllocator<T>, GrowthStrategy Strategy = VectorGrowthStrategy::GoldenExpand>

void flow::Vector< T, Allocator, Strategy >::insert	(	iterator	pos,
		T &&	value )

inline

Inserts a moved element at the specified iterator position.

Parameters

pos	Insertion position.
value	Value to insert.

Definition at line 390 of file flow_vector.h.

                                         {
      emplace(pos, std::move(value));
    }

◆ operator=()

template<typename T, typename Allocator = PolymorphicAllocator<T>, GrowthStrategy Strategy = VectorGrowthStrategy::GoldenExpand>

Vector & flow::Vector< T, Allocator, Strategy >::operator= ( Vector< T, Allocator, Strategy > rhs )

inlinenoexcept

Definition at line 184 of file flow_vector.h.

                                                  {
      swap(*this, rhs);
      return *this;
    }

◆ operator[]() [1/2]

template<typename T, typename Allocator = PolymorphicAllocator<T>, GrowthStrategy Strategy = VectorGrowthStrategy::GoldenExpand>

const T & flow::Vector< T, Allocator, Strategy >::operator[] ( std::size_t i ) const

inlinenoexcept

Definition at line 195 of file flow_vector.h.

                                                    {
      assert(i < size_ && "index out of bound");
      return buffer_[i];
    }

◆ operator[]() [2/2]

template<typename T, typename Allocator = PolymorphicAllocator<T>, GrowthStrategy Strategy = VectorGrowthStrategy::GoldenExpand>

T & flow::Vector< T, Allocator, Strategy >::operator[] ( std::size_t i )

inlinenoexcept

Definition at line 190 of file flow_vector.h.

                                        {
      assert(i < size_ && "index out of bound");
      return buffer_[i];
    }

◆ popBack()

template<typename T, typename Allocator = PolymorphicAllocator<T>, GrowthStrategy Strategy = VectorGrowthStrategy::GoldenExpand>

void flow::Vector< T, Allocator, Strategy >::popBack ( )

inlinenoexcept

Removes the last element of the vector.

Definition at line 323 of file flow_vector.h.

                            {
      assert(0 < size_ && "can not pop back from an empty vector");
      --size_;
      allocator_trait::destroy(allocator_, buffer_ + size_);
    }

Referenced by flow::Vector< T, Allocator >::erase().

◆ pushBack() [1/2]

template<typename T, typename Allocator = PolymorphicAllocator<T>, GrowthStrategy Strategy = VectorGrowthStrategy::GoldenExpand>

void flow::Vector< T, Allocator, Strategy >::pushBack ( const T & value )

inline

Adds an element to the end of the vector.

Parameters

value Element to add.

Definition at line 298 of file flow_vector.h.

                                  {
      // https://stackoverflow.com/questions/10890653/why-would-i-ever-use-push-back-instead-of-emplace-back
      // TLDR: Consider emplace back an address when constructing unique_ptr.
      // pushBack disallows implicit constructor call.
      emplaceBack(value);
    }

◆ pushBack() [2/2]

template<typename T, typename Allocator = PolymorphicAllocator<T>, GrowthStrategy Strategy = VectorGrowthStrategy::GoldenExpand>

void flow::Vector< T, Allocator, Strategy >::pushBack ( T && value )

inline

Adds an element to the end of the vector.

Parameters

value Element to add.

Definition at line 307 of file flow_vector.h.

                             {
      emplaceBack(std::move(value));
    }

◆ relocateBuffer()

template<typename T, typename Allocator = PolymorphicAllocator<T>, GrowthStrategy Strategy = VectorGrowthStrategy::GoldenExpand>

void flow::Vector< T, Allocator, Strategy >::relocateBuffer ( std::size_t capacity )

inlineprivate

Definition at line 467 of file flow_vector.h.

                                            {
      assert(capacity_ < capacity && "new capacity is no larger than the old capacity");
 
      T* buffer = allocator_trait::allocate(allocator_, capacity);
      uninitializedMove(allocator_, begin(), end(), buffer);
      updateBuffer(buffer, capacity);
    }

Referenced by flow::Vector< T, Allocator >::emplaceBack(), flow::Vector< T, Allocator >::reserve(), and flow::Vector< T, Allocator >::resizeImp().

◆ relocateBufferWithHoles()

template<typename T, typename Allocator = PolymorphicAllocator<T>, GrowthStrategy Strategy = VectorGrowthStrategy::GoldenExpand>

void flow::Vector< T, Allocator, Strategy >::relocateBufferWithHoles	(	std::size_t	capacity,
		iterator	pos,
		std::size_t	holeSize )

inlineprivate

Definition at line 476 of file flow_vector.h.

                                                                                       {
      assert(capacity_ < capacity && "new capacity is no larger than the old capacity");
 
      T* buffer = allocator_trait::allocate(allocator_, capacity);
      iterator leftHalf = uninitializedMove(allocator_, begin(), pos, buffer); // Move left half.
      uninitializedMove(allocator_, pos, end(), leftHalf + holeSize); // Move right half.
      updateBuffer(buffer, capacity);
    }

Referenced by flow::Vector< T, Allocator >::emplace(), and flow::Vector< T, Allocator >::insert().

◆ reserve()

template<typename T, typename Allocator = PolymorphicAllocator<T>, GrowthStrategy Strategy = VectorGrowthStrategy::GoldenExpand>

void flow::Vector< T, Allocator, Strategy >::reserve ( std::size_t capacity )

inline

Ensures the vector can hold at least the given capacity without reallocating.

Parameters

capacity Desired minimum capacity.

Definition at line 277 of file flow_vector.h.

                                     {
      if (capacity_ < capacity) {
        relocateBuffer(capacity);
      }
    }

◆ resize() [1/2]

template<typename T, typename Allocator = PolymorphicAllocator<T>, GrowthStrategy Strategy = VectorGrowthStrategy::GoldenExpand>

void flow::Vector< T, Allocator, Strategy >::resize ( std::size_t size )

inline

Resizes the vector to contain the given number of default constructed elements.

Parameters

size New size.

Definition at line 285 of file flow_vector.h.

                                {
      resizeImp(size);
    }

◆ resize() [2/2]

template<typename T, typename Allocator = PolymorphicAllocator<T>, GrowthStrategy Strategy = VectorGrowthStrategy::GoldenExpand>

void flow::Vector< T, Allocator, Strategy >::resize	(	std::size_t	size,
		const T &	value )

inline

Resizes the vector and fills new elements with a given value.

Parameters

size	New size.
value	Value to fill.

Definition at line 292 of file flow_vector.h.

                                                {
      resizeImp(size, value);
    }

◆ resizeImp()

template<typename T, typename Allocator = PolymorphicAllocator<T>, GrowthStrategy Strategy = VectorGrowthStrategy::GoldenExpand>

template<typename ... U>

void flow::Vector< T, Allocator, Strategy >::resizeImp	(	std::size_t	size,
		const U &...	optionalValue )

inlineprivate

Definition at line 486 of file flow_vector.h.

                                                              {
      static_assert(sizeof...(optionalValue) <= 1, "no fill value or exactly one copy");
      if (size_ < size) {
        // Relocate if not enough capacity.
        if (capacity_ < size) {
          relocateBuffer(size);
        }
        uninitializedEmplace(allocator_, buffer_ + size_, buffer_ + size, optionalValue...);
 
      } else if (size < size_) {
        // Shrink.
        destroyElements(allocator_, buffer_ + size, buffer_ + size_);
      }
      size_ = size;
    }

Referenced by flow::Vector< T, Allocator >::resize(), and flow::Vector< T, Allocator >::resize().

◆ size()

template<typename T, typename Allocator = PolymorphicAllocator<T>, GrowthStrategy Strategy = VectorGrowthStrategy::GoldenExpand>

std::size_t flow::Vector< T, Allocator, Strategy >::size ( ) const

inlineconstexprnoexcept

Returns the number of elements in the vector.

Returns: Number of elements.

Definition at line 225 of file flow_vector.h.

                                              {
      return size_;
    }

◆ updateBuffer()

template<typename T, typename Allocator = PolymorphicAllocator<T>, GrowthStrategy Strategy = VectorGrowthStrategy::GoldenExpand>

void flow::Vector< T, Allocator, Strategy >::updateBuffer	(	T *	buffer,
		std::size_t	capacity )

inlineprivate

Definition at line 459 of file flow_vector.h.

                                                     {
      deleteBuffer(allocator_, buffer_, size_, capacity_);
      buffer_ = buffer;
      capacity_ = capacity;
    }

Referenced by flow::Vector< T, Allocator >::relocateBuffer(), and flow::Vector< T, Allocator >::relocateBufferWithHoles().

◆ swap

template<typename T, typename Allocator = PolymorphicAllocator<T>, GrowthStrategy Strategy = VectorGrowthStrategy::GoldenExpand>

void swap	(	Vector< T, Allocator, Strategy > &	lhs,
		Vector< T, Allocator, Strategy > &	rhs )

friend

Definition at line 503 of file flow_vector.h.

                                                        {
      using std::swap;
      swap(lhs.allocator_, rhs.allocator_);
      swap(lhs.growthStrategy_, rhs.growthStrategy_);
      swap(lhs.size_, rhs.size_);
      swap(lhs.capacity_, rhs.capacity_);
      swap(lhs.buffer_, rhs.buffer_);
    }

Referenced by flow::Vector< T, Allocator >::operator=(), and flow::Vector< T, Allocator >::swap.

Member Data Documentation

◆ allocator_

template<typename T, typename Allocator = PolymorphicAllocator<T>, GrowthStrategy Strategy = VectorGrowthStrategy::GoldenExpand>

allocator_type flow::Vector< T, Allocator, Strategy >::allocator_

private

Definition at line 67 of file flow_vector.h.

◆ buffer_

template<typename T, typename Allocator = PolymorphicAllocator<T>, GrowthStrategy Strategy = VectorGrowthStrategy::GoldenExpand>

T* flow::Vector< T, Allocator, Strategy >::buffer_

private

Definition at line 71 of file flow_vector.h.

◆ capacity_

template<typename T, typename Allocator = PolymorphicAllocator<T>, GrowthStrategy Strategy = VectorGrowthStrategy::GoldenExpand>

std::size_t flow::Vector< T, Allocator, Strategy >::capacity_

private

Definition at line 70 of file flow_vector.h.

◆ growthStrategy_

template<typename T, typename Allocator = PolymorphicAllocator<T>, GrowthStrategy Strategy = VectorGrowthStrategy::GoldenExpand>

Strategy flow::Vector< T, Allocator, Strategy >::growthStrategy_

private

Definition at line 68 of file flow_vector.h.

Referenced by flow::Vector< T, Allocator >::emplace(), flow::Vector< T, Allocator >::emplaceBack(), and flow::Vector< T, Allocator >::insert().

◆ size_

template<typename T, typename Allocator = PolymorphicAllocator<T>, GrowthStrategy Strategy = VectorGrowthStrategy::GoldenExpand>

std::size_t flow::Vector< T, Allocator, Strategy >::size_

private

Definition at line 69 of file flow_vector.h.

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

flow_vector.h

Public Types

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Friends

Detailed Description

Member Typedef Documentation

◆ allocator_trait

◆ allocator_type

◆ const_iterator

◆ const_pointer

◆ const_reference

◆ difference_type

◆ iterator

◆ pointer

◆ reference

◆ size_type

◆ value_type

Constructor & Destructor Documentation

◆ Vector() [1/10]

◆ Vector() [2/10]

◆ Vector() [3/10]

◆ Vector() [4/10]

◆ Vector() [5/10]

◆ Vector() [6/10]

◆ Vector() [7/10]

◆ Vector() [8/10]

◆ Vector() [9/10]

◆ Vector() [10/10]

◆ ~Vector()

Member Function Documentation

◆ back() [1/2]

◆ back() [2/2]

◆ begin() [1/2]

◆ begin() [2/2]

◆ capacity()

◆ clear()

◆ emplace()

◆ emplaceBack()

◆ empty()

◆ end() [1/2]

◆ end() [2/2]

◆ erase() [1/2]

◆ erase() [2/2]

◆ front() [1/2]

◆ front() [2/2]

◆ get_allocator()

◆ insert() [1/5]

◆ insert() [2/5]

◆ insert() [3/5]

◆ insert() [4/5]

◆ insert() [5/5]

◆ operator=()

◆ operator[]() [1/2]

◆ operator[]() [2/2]

◆ popBack()

◆ pushBack() [1/2]

◆ pushBack() [2/2]

◆ relocateBuffer()

◆ relocateBufferWithHoles()

◆ reserve()

◆ resize() [1/2]

◆ resize() [2/2]

◆ resizeImp()

◆ size()

◆ updateBuffer()

Friends And Related Symbol Documentation

◆ swap

Member Data Documentation

◆ allocator_

◆ buffer_

◆ capacity_

◆ growthStrategy_

◆ size_