Storage for partitioned data such that data within each partition is contiguous. More...

#include <PartitionedData.hpp>

Public Types
using	value_type = T

using	container_type = Container

using	bucket_type = typename container_type::value_type

using	size_type = typename container_type::size_type

using	index_type = size_type

using	allocator_type = typename container_type::allocator_type

using	partition_iterator = data_structures::partition_iterator< bucket_type, size_type >

using	const_partition_iterator = data_structures::const_partition_iterator< bucket_type, size_type >

using	reverse_partition_iterator = data_structures::reverse_partition_iterator< bucket_type, size_type >

using	const_reverse_partition_iterator = data_structures::const_reverse_partition_iterator< bucket_type, size_type >

using	partition_range = std::ranges::subrange< partition_iterator >

using	const_partition_range = std::ranges::subrange< const_partition_iterator >

Public Member Functions
	bucketed_sequence (const allocator_type &allocator) noexcept

	bucketed_sequence (std::initializer_list< std::initializer_list< T > > list, const allocator_type &allocator=allocator_type{})

	bucketed_sequence (const bucketed_sequence &)=default

	bucketed_sequence (const bucketed_sequence &other, const allocator_type &allocator)

	bucketed_sequence (bucketed_sequence &&) noexcept=default

	bucketed_sequence (bucketed_sequence &&other, const allocator_type &allocator)

bucketed_sequence &	operator= (bucketed_sequence &&) noexcept=default

bucketed_sequence &	operator= (const bucketed_sequence &)=default

void	swap (bucketed_sequence &other) noexcept(noexcept(std::ranges::swap(this->m_Buckets, other.m_Buckets)))

bool	empty () const noexcept

size_type	size () const

size_type	size_of_partition (size_type i) const

size_type	num_partitions () const noexcept

void	swap_partitions (const size_type i, const size_type j)

allocator_type	get_allocator () const

void	add_slot ()

void	insert_slot (const size_type pos)

void	erase_slot (const size_type n)

void	reserve_partition (const size_type partition, const size_type size)

size_type	partition_capacity (const size_type partition) const

void	reserve_partitions (const size_type numPartitions)

size_type	num_partitions_capacity () const noexcept

void	shrink_num_partitions_to_fit ()

void	shrink_to_fit (const size_type partition)

void	shrink_to_fit ()

void	clear () noexcept

template<class... Args>
void	push_back_to_partition (const size_type index, Args &&... args)

template<class... Args>
partition_iterator	insert_to_partition (const_partition_iterator pos, Args &&... args)

template<class... Args>
partition_iterator	insert_to_partition (const size_type index, const size_type pos, Args &&... args)

partition_iterator	erase_from_partition (const_partition_iterator iter)

partition_iterator	erase_from_partition (const_partition_iterator first, const_partition_iterator last)

partition_iterator	erase_from_partition (const size_type index, const size_type pos)

partition_iterator	begin_partition (const size_type i)

partition_iterator	end_partition (const size_type i)

const_partition_iterator	begin_partition (const size_type i) const

const_partition_iterator	end_partition (const size_type i) const

reverse_partition_iterator	rbegin_partition (const size_type i)

reverse_partition_iterator	rend_partition (const size_type i)

const_reverse_partition_iterator	rbegin_partition (const size_type i) const

const_reverse_partition_iterator	rend_partition (const size_type i) const

const_partition_iterator	cbegin_partition (const size_type i) const

const_partition_iterator	cend_partition (const size_type i) const

const_reverse_partition_iterator	crbegin_partition (const size_type i) const

const_reverse_partition_iterator	crend_partition (const size_type i) const

partition_range	partition (const size_type i)

const_partition_range	partition (const size_type i) const

const_partition_range	cpartition (const size_type i) const

const_partition_iterator	operator[] (const size_type i) const

partition_iterator	operator[] (const size_type i)

void	reset (const allocator_type &allocator) noexcept

Static Public Attributes
static constexpr auto	npos {partition_iterator::npos}

Friends
void	swap (bucketed_sequence &lhs, bucketed_sequence &rhs) noexcept(noexcept(lhs.swap(rhs)))

bool	operator== (const bucketed_sequence &lhs, const bucketed_sequence &rhs) noexcept=default

Detailed Description

template<class T, class Container = std::vector<std::vector<T>>>
class sequoia::data_structures::bucketed_sequence< T, Container >

Storage for partitioned data such that data within each partition is contiguous.

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

C:/Users/olive/sequoia/Source/sequoia/Core/DataStructures/PartitionedData.hpp

Public Types

Public Member Functions

Static Public Attributes

Friends

Detailed Description