Fixed-capacity array along with cached measurement of array contents. More...

#include <chunk.hpp>

Public Types
using	search_type = itemsearch::search_in_chunk< self_type, algebra_type >

Item-specific types
using	queue_type = Fixed_capacity_queue

using	value_type = typename queue_type::value_type

using	reference = value_type &

using	const_reference = const value_type &

using	pointer = value_type *

using	const_pointer = const value_type *

using	segment_type = typename queue_type::segment_type

Cached-measurement-specific types
using	cache_type = Cached_measure

using	measured_type = typename cache_type::measured_type

using	algebra_type = typename cache_type::algebra_type

using	measure_type = typename cache_type::measure_type

Container-configuration types
using	size_type = typename cache_type::size_type

using	annotation_type = Annotation

using	self_type = chunk< queue_type, cache_type, annotation_type, Pointer_deleter1, Pointer_deep_copier1, Size_access >

Public Member Functions
void	check_cached (const measure_type &meas) const

Constructors and destructors
	chunk ()

	chunk (const self_type &other)

	~chunk ()

Capacity
bool	full () const

bool	empty () const

bool	partial () const

size_type	size () const

Cached measurement
measured_type	get_cached () const

Item access
value_type &	front () const

value_type &	back () const

void	frontn (value_type *xs, size_type nb)

void	backn (value_type *xs, size_type nb)

value_type &	operator[] (size_type ix) const

template<class Body >
void	for_each (const Body &body) const

template<class Body >
void	for_each_segment (const Body &body) const

template<class Body >
void	for_each_segment (size_type lo, size_type hi, const Body &body) const

segment_type	segment_by_index (size_type i) const

size_type	index_of_pointer (const value_type *p) const

Modifiers
void	push_front (const measure_type &meas, const value_type &x)

void	push_back (const measure_type &meas, const value_type &x)

value_type	pop_front (const measure_type &meas)

value_type	pop_back (const measure_type &meas)

void	pushn_front (const measure_type &meas, const value_type *xs, size_type nb)

void	pushn_back (const measure_type &meas, const value_type *xs, size_type nb)

template<class Body >
void	pushn_back (const measure_type &meas, const Body &body, size_type nb)

void	popn_front (const measure_type &meas, size_type nb)

void	popn_back (const measure_type &meas, size_type nb)

void	popn_front (const measure_type &meas, value_type *xs, size_type nb)

void	popn_back (const measure_type &meas, value_type *xs, size_type nb)

template<class Consumer , bool should_consume>
void	popn_back (const measure_type &meas, const Consumer &cons, size_type nb)

template<class Consumer , bool should_consume>
void	popn_front (const measure_type &meas, const Consumer &cons, size_type nb)

void	transfer_from_back_to_front (const measure_type &meas, chunk &target, size_type nb)

void	transfer_from_front_to_back (const measure_type &meas, chunk &target, size_type nb)

template<class Pred , class Search , class Search_measure >
Search::measured_type	split (const measure_type &meas, const Pred &p, const Search &search, const Search_measure &search_meas, typename Search::measured_type prefix, bool &found, value_type &x, self_type &other)

template<class Pred , class Search , class Search_measure >
Search::measured_type	split (const measure_type &meas, const Pred &p, const Search &search, const Search_measure &search_meas, typename Search::measured_type prefix, value_type &x, self_type &other)

template<class Pred , class Search , class Search_measure >
Search::measured_type	split (const measure_type &meas, const Pred &p, const Search &search, const Search_measure &search_meas, typename Search::measured_type prefix, self_type &other)

template<class Pred >
measured_type	split (const measure_type &meas, const Pred &p, measured_type prefix, value_type &x, self_type &other)

template<class Pred >
measured_type	split (const measure_type &meas, const Pred &p, measured_type prefix, self_type &other)

void	concat (const measure_type &meas, self_type &other)

void	clear ()

void	swap (self_type &other)

void	reset_cache (const measure_type &meas)

Public Attributes
queue_type	items
	queue structure to contain the items of the chunk More...

measured_type	cached
	cached measurement of the items contained in the chunk More...

annotation_type	annotation
	annotation value to be attached to the chunk More...

Static Public Attributes
static constexpr int	capacity = queue_type::capacity
	capacity in number of items More...

Detailed Description

template<class Fixed_capacity_queue, class Cached_measure, class Annotation = annotation::annotation_builder<>, class Pointer_deleter1 = Dummy_pointer_deleter, class Pointer_deep_copier1 = Dummy_pointer_deep_copier, class Size_access = itemsearch::no_size_access>
class pasl::data::chunkedseq::chunk< Fixed_capacity_queue, Cached_measure, Annotation, Pointer_deleter1, Pointer_deep_copier1, Size_access >

Template Parameters

Fixed_capacity_queue	type of the fixed-capacity array
Cached_measure	type of the policy used to maintain the cached measurement Annotation type of an annotation object that a client might want to attach, e.g., parent/sibling pointer
Pointer_deleter1	type of the policy used to manage deallocation of (pointer-value) items
Pointer_deep_copier1	type of the policy used to manage copying of (pointer-value) items

We assume that each chunk consists of one or two segments. Two segments indicates wraparound in a ringbuffer. In the future we might consider supporting unbounded segments.

Definition at line 93 of file chunk.hpp.