Implementation of a dynamic linear array storage, aka vector. More...

#include <darray.hpp>

Inheritance diagram for jau::darray< Value_type, Size_type, Alloc_type, use_memmove, use_secmem >:

Collaboration diagram for jau::darray< Value_type, Size_type, Alloc_type, use_memmove, use_secmem >:

Public Types
typedef Alloc_type	allocator_type

typedef const value_type *	const_iterator

typedef const value_type *	const_pointer

typedef const value_type &	const_reference

typedef bool	darray_tag
	Used to determine whether this type is a darray or has a darray, see ::is_darray_type<T> More...

typedef std::make_signed< size_type >::type	difference_type

typedef bool(*	equal_comparator) (const value_type &a, const value_type &b)
	Generic value_type equal comparator to be user defined for e.g. More...

typedef value_type *	iterator

typedef value_type *	pointer

typedef value_type &	reference

typedef Size_type	size_type

typedef Value_type	value_type

Public Member Functions
constexpr	darray () noexcept
	Default constructor, giving zero capacity and zero memory footprint. More...

constexpr	darray (const darray &x)
	Creates a new instance, copying all elements from the given darray. More...

constexpr	darray (const darray &x, const float growth_factor, const allocator_type &alloc)
	Creates a new instance, copying all elements from the given darray. More...

constexpr	darray (const darray &x, const size_type _capacity, const float growth_factor, const allocator_type &alloc)
	Creates a new instance with custom initial storage capacity, copying all elements from the given darray. More...

constexpr	darray (const size_type _capacity, const_iterator first, const_iterator last, const float growth_factor=DEFAULT_GROWTH_FACTOR, const allocator_type &alloc=allocator_type())
	Creates a new instance with custom initial storage capacity, copying all elements from the given const_iterator value_type range [first, last). More...

template<class InputIt >
constexpr	darray (const size_type _capacity, InputIt first, InputIt last, const float growth_factor=DEFAULT_GROWTH_FACTOR, const allocator_type &alloc=allocator_type())
	Creates a new instance with custom initial storage capacity, copying all elements from the given template input-iterator value_type range [first, last). More...

constexpr	darray (darray &&x) noexcept

constexpr	darray (darray &&x, const float growth_factor, const allocator_type &alloc) noexcept

template<class InputIt >
constexpr	darray (InputIt first, InputIt last, const allocator_type &alloc=allocator_type())
	Creates a new instance, copying all elements from the given template input-iterator value_type range [first, last). More...

constexpr	darray (size_type capacity, const float growth_factor=DEFAULT_GROWTH_FACTOR, const allocator_type &alloc=allocator_type())
	Creating an empty instance with initial capacity and other (default) properties. More...

constexpr	darray (std::initializer_list< value_type > initlist, const allocator_type &alloc=allocator_type())
	Create a new instance from an initializer list. More...

	~darray () noexcept

constexpr void	assign (const_iterator first, const_iterator last)
	Like std::vector::assign(), but non-template overload using const_iterator. More...

template<class InputIt >
constexpr void	assign (InputIt first, InputIt last)
	Like std::vector::assign() More...

reference	at (size_type i)
	Like std::vector::at(size_type), mutable reference. More...

const_reference	at (size_type i) const
	Like std::vector::at(size_type), immutable reference. More...

constexpr reference	back ()
	Like std::vector::back(), mutable access. More...

constexpr const_reference	back () const
	Like std::vector::back(), immutable access. More...

constexpr const_iterator	begin () const noexcept

constexpr iterator	begin () noexcept

constexpr size_type	capacity () const noexcept
	Return the current capacity. More...

constexpr bool	capacity_reached () const noexcept
	Returns true if capacity has been reached and the next push_back() will grow the storage and invalidates all iterators and references. More...

constexpr const_iterator	cbegin () const noexcept

constexpr const_iterator	cend () const noexcept

constexpr void	clear () noexcept
	Like std::vector::clear(), but ending with zero capacity. More...

constexpr const_pointer	data () const noexcept
	Like std::vector::data(), const immutable pointer. More...

constexpr pointer	data () noexcept
	Like std::vector::data(), mutable pointer. More...

template<typename... Args>
constexpr iterator	emplace (const_iterator pos, Args &&... args)
	Like std::vector::emplace(), construct a new element in place. More...

template<typename... Args>
constexpr reference	emplace_back (Args &&... args)
	Like std::vector::emplace_back(), construct a new element in place at the end(). More...

constexpr bool	empty () const noexcept
	Like std::vector::empty(). More...

constexpr const_iterator	end () const noexcept

constexpr iterator	end () noexcept

constexpr iterator	erase (const size_type first_idx, const size_type last_idx)
	Similar to std::vector::erase() using indices, removes the elements in the range [first_idx, last_idx). More...

constexpr iterator	erase (const size_type pos_idx)
	Similar to std::vector::erase() using an index, removes the elements at pos_idx. More...

constexpr iterator	erase (const_iterator pos)
	Like std::vector::erase(), removes the elements at pos. More...

constexpr iterator	erase (iterator first, const_iterator last)
	Like std::vector::erase(), removes the elements in the range [first, last). More...

constexpr size_type	erase_matching (const value_type &x, const bool all_matching, equal_comparator comparator)
	Erase either the first matching element or all matching elements. More...

constexpr reference	front ()
	Like std::vector::front(), mutable access. More...

constexpr const_reference	front () const
	Like std::vector::front(), immutable access. More...

allocator_type	get_allocator () const noexcept

const allocator_type &	get_allocator_ref () const noexcept

constexpr size_type	get_grown_capacity () const noexcept
	Return the current capacity() multiplied by the growth factor, minimum is max(capacity()+1, 10). More...

std::string	get_info () const noexcept

constexpr float	growth_factor () const noexcept

constexpr iterator	insert (const size_type pos_idx, const value_type &x)
	Similar to std::vector::insert() using an index, copy. More...

constexpr iterator	insert (const_iterator pos, const value_type &x)
	Like std::vector::insert(), copy. More...

template<class InputIt >
constexpr iterator	insert (const_iterator pos, InputIt first, InputIt last)
	Like std::vector::insert(), inserting the value_type range [first, last). More...

constexpr iterator	insert (const_iterator pos, value_type &&x)
	Like std::vector::insert(), move. More...

constexpr size_type	max_size () const noexcept
	Returns `std::numeric_limits<difference_type>::max()` as the maximum array size. More...

constexpr darray &	operator= (const darray &x)
	Like std::vector::operator=(&), assignment. More...

constexpr darray &	operator= (darray &&x) noexcept
	Like std::vector::operator=(&&), move. More...

const_reference	operator[] (size_type i) const noexcept
	Like std::vector::operator[](size_type), immutable reference. More...

reference	operator[] (size_type i) noexcept
	Like std::vector::operator[](size_type), mutable reference. More...

constexpr void	pop_back () noexcept
	Like std::vector::pop_back(). More...

constexpr void	push_back (const value_type &x)
	Like std::vector::push_back(), copy. More...

template<class InputIt >
constexpr void	push_back (InputIt first, InputIt last)
	Like std::vector::push_back(), but appends the value_type range [first, last). More...

constexpr void	push_back (value_type &&x)
	Like std::vector::push_back(), move. More...

template<typename... Args>
constexpr void	push_back_list (Args &&... args)
	Like push_back(), but for more multiple r-value references to move. More...

template<typename... Args>
constexpr void	push_back_list (const Args &... args)
	Like push_back(), but for more multiple const r-value to copy. More...

constexpr bool	push_back_unique (const value_type &x, equal_comparator comparator)
	Like std::vector::push_back(), but only if the newly added element does not yet exist. More...

constexpr void	push_front (const value_type &x)
	Like std::vector::push_front(), copy. More...

constexpr void	push_front (value_type &&x)
	Like std::vector::push_front(), move. More...

void	reserve (size_type new_capacity)
	Like std::vector::reserve(), increases this instance's capacity to `new_capacity`. More...

constexpr void	shrink_to_fit ()
	Like std::vector::shrink_to_fit(), but ensured `constexpr`. More...

constexpr size_type	size () const noexcept
	Like std::vector::size(). More...

constexpr void	swap (darray &x) noexcept
	Like std::vector::swap(). More...

std::string	toString () const noexcept

Static Public Attributes
static constexpr const float	DEFAULT_GROWTH_FACTOR = 1.618f
	Default growth factor using the golden ratio 1.618. More...

static constexpr const bool	uses_memmove = use_memmove

static constexpr const bool	uses_realloc = use_memmove && std::is_base_of_v<jau::callocator<Value_type>, Alloc_type>

static constexpr const bool	uses_secmem = use_secmem

Detailed Description

template<typename Value_type, typename Size_type = jau::nsize_t, typename Alloc_type = jau::callocator<Value_type>, bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>
class jau::darray< Value_type, Size_type, Alloc_type, use_memmove, use_secmem >

Implementation of a dynamic linear array storage, aka vector.

Goals are to support a high-performance CoW dynamic array implementation, jau::cow_darray,
exposing fine grained control over its underlying storage facility.
Further, jau::darray provides high-performance and efficient storage properties on its own.

This class shall be compliant with C++ named requirements for Container.

API and design differences to std::vector

jau::darray adds a parameterized growth factor aspect, default to golden ration jau::darray::DEFAULT_GROWTH_FACTOR
capacity control via constructor and operations, related to growth factor.
Iterator jau::darray::const_iterator .. are harmonized with jau::cow_ro_iterator .. used in jau:cow_darray.
...
Custom constructor and operations, supporting a more efficient jau::cow_darray implementation.
Custom template typename Size_type, defaults to jau::nsize_t.
...
Removed: size_type x value_type fill operations, e.g. assign, constructor, .... for clarity, since supporting capacity.
...
TODO: std::initializer_list<T> methods, ctor is provided.

Implementation differences to std::vector and some details

Using zero overhead value_type* as iterator type.
...
Storage is operated on three iterator: begin, end and storage_end.
Constructs and destructs value_type via placement new within the pre-allocated array capacity. Latter is managed via allocator_type.

Non-Type Template Parameter (NTTP) controlling Value_type memory

use_memmove

use_memmove can be overriden and defaults to std::is_trivially_copyable_v<Value_type>.

The default value has been chosen with care, see C++ Standard section 6.9 Types TriviallyCopyable.

See Trivial destructor being key requirement to TriviallyCopyable.

‍A trivial destructor is a destructor that performs no action. Objects with trivial destructors don't require a delete-expression and may be disposed of by simply deallocating their storage. All data types compatible with the C language (POD types) are trivially destructible.`

However, since the destructor is not being called when using memmove on elements within this container, the requirements are more relaxed and TriviallyCopyable not required nor guaranteed, see below.

memmove will be used to move an object inside this container memory only, i.e. where construction and destruction is controlled. Not requiring TriviallyCopyable constraints memmove as follows:

We can't memmove one or more objects into this container, even with an rvalue reference. The rvalue's destructor will be called and potential acquired resources are lost.
We can memmove an object around within this container, i.e. when growing or shrinking the array. (Used)
We can memmove an object out of this container to the user. (Unused)

Relaxed requirements for use_memmove are:

Not using inner class pointer to inner class fields or methods (like launching a thread).
TBD ???

Since element pointer and iterator are always invalidated for container after storage mutation, above constraints are not really anything novel and go along with normal std::vector.

Users may include typedef container_memmove_compliant in their Value_type class to enforce use_memmove as follows:

typedef std::true_type container_memmove_compliant;

use_secmem

use_secmem can be overriden and defaults to false.

use_secmem, if enabled, ensures that the underlying memory will be zeroed out after use and element erasure.

Users may include typedef enforce_secmem in their Value_type class to enforce use_secmem as follows:

typedef std::true_type enforce_secmem;

See also: cow_darray

Examples: dbt_repeater00.cpp, dbt_scanner10.cpp, and test_cow_iterator_01.cpp.

Definition at line 147 of file darray.hpp.

Member Typedef Documentation

◆ value_type

template<typename Value_type , typename Size_type = jau::nsize_t, typename Alloc_type = jau::callocator<Value_type>, bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

typedef Value_type jau::darray< Value_type, Size_type, Alloc_type, use_memmove, use_secmem >::value_type

Definition at line 159 of file darray.hpp.

◆ pointer

template<typename Value_type , typename Size_type = jau::nsize_t, typename Alloc_type = jau::callocator<Value_type>, bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

typedef value_type* jau::darray< Value_type, Size_type, Alloc_type, use_memmove, use_secmem >::pointer

Definition at line 160 of file darray.hpp.

◆ const_pointer

template<typename Value_type , typename Size_type = jau::nsize_t, typename Alloc_type = jau::callocator<Value_type>, bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

typedef const value_type* jau::darray< Value_type, Size_type, Alloc_type, use_memmove, use_secmem >::const_pointer

Definition at line 161 of file darray.hpp.

◆ reference

template<typename Value_type , typename Size_type = jau::nsize_t, typename Alloc_type = jau::callocator<Value_type>, bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

typedef value_type& jau::darray< Value_type, Size_type, Alloc_type, use_memmove, use_secmem >::reference

Definition at line 162 of file darray.hpp.

◆ const_reference

template<typename Value_type , typename Size_type = jau::nsize_t, typename Alloc_type = jau::callocator<Value_type>, bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

typedef const value_type& jau::darray< Value_type, Size_type, Alloc_type, use_memmove, use_secmem >::const_reference

Definition at line 163 of file darray.hpp.

◆ iterator

template<typename Value_type , typename Size_type = jau::nsize_t, typename Alloc_type = jau::callocator<Value_type>, bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

typedef value_type* jau::darray< Value_type, Size_type, Alloc_type, use_memmove, use_secmem >::iterator

Definition at line 164 of file darray.hpp.

◆ const_iterator

template<typename Value_type , typename Size_type = jau::nsize_t, typename Alloc_type = jau::callocator<Value_type>, bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

typedef const value_type* jau::darray< Value_type, Size_type, Alloc_type, use_memmove, use_secmem >::const_iterator

Definition at line 165 of file darray.hpp.

◆ size_type

template<typename Value_type , typename Size_type = jau::nsize_t, typename Alloc_type = jau::callocator<Value_type>, bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

typedef Size_type jau::darray< Value_type, Size_type, Alloc_type, use_memmove, use_secmem >::size_type

Definition at line 166 of file darray.hpp.

◆ difference_type

template<typename Value_type , typename Size_type = jau::nsize_t, typename Alloc_type = jau::callocator<Value_type>, bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

typedef std::make_signed<size_type>::type jau::darray< Value_type, Size_type, Alloc_type, use_memmove, use_secmem >::difference_type

Definition at line 167 of file darray.hpp.

◆ allocator_type

template<typename Value_type , typename Size_type = jau::nsize_t, typename Alloc_type = jau::callocator<Value_type>, bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

typedef Alloc_type jau::darray< Value_type, Size_type, Alloc_type, use_memmove, use_secmem >::allocator_type

Definition at line 170 of file darray.hpp.

◆ darray_tag

template<typename Value_type , typename Size_type = jau::nsize_t, typename Alloc_type = jau::callocator<Value_type>, bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

typedef bool jau::darray< Value_type, Size_type, Alloc_type, use_memmove, use_secmem >::darray_tag

Used to determine whether this type is a darray or has a darray, see ::is_darray_type<T>

Definition at line 173 of file darray.hpp.

◆ equal_comparator

template<typename Value_type , typename Size_type = jau::nsize_t, typename Alloc_type = jau::callocator<Value_type>, bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

typedef bool(* jau::darray< Value_type, Size_type, Alloc_type, use_memmove, use_secmem >::equal_comparator) (const value_type &a, const value_type &b)

Generic value_type equal comparator to be user defined for e.g.

jau::darray::push_back_unique().

Parameters

a	one element of the equality test.
b	the other element of the equality test.

Returns: true if both are equal

Definition at line 1249 of file darray.hpp.

Constructor & Destructor Documentation

◆ darray() [1/11]

template<typename Value_type , typename Size_type = jau::nsize_t, typename Alloc_type = jau::callocator<Value_type>, bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

constexpr jau::darray< Value_type, Size_type, Alloc_type, use_memmove, use_secmem >::darray ( )

inlineconstexprnoexcept

Default constructor, giving zero capacity and zero memory footprint.

Definition at line 474 of file darray.hpp.

◆ darray() [2/11]

template<typename Value_type , typename Size_type = jau::nsize_t, typename Alloc_type = jau::callocator<Value_type>, bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

constexpr jau::darray< Value_type, Size_type, Alloc_type, use_memmove, use_secmem >::darray	(	size_type	capacity,
		const float	growth_factor = `DEFAULT_GROWTH_FACTOR`,
		const allocator_type &	alloc = `allocator_type()`
	)

inlineexplicitconstexpr

Creating an empty instance with initial capacity and other (default) properties.

Parameters

capacity	initial capacity of the new instance.
growth_factor	given growth factor
alloc	given allocator_type

Definition at line 486 of file darray.hpp.

◆ darray() [3/11]

template<typename Value_type , typename Size_type = jau::nsize_t, typename Alloc_type = jau::callocator<Value_type>, bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

constexpr jau::darray< Value_type, Size_type, Alloc_type, use_memmove, use_secmem >::darray ( const darray< Value_type, Size_type, Alloc_type, use_memmove, use_secmem > & x )

inlineconstexpr

Creates a new instance, copying all elements from the given darray.

Capacity and size will equal the given array, i.e. the result is a trimmed jau::darray.

Parameters

x	the given darray, all elements will be copied into the new instance.

Definition at line 499 of file darray.hpp.

◆ darray() [4/11]

template<typename Value_type , typename Size_type = jau::nsize_t, typename Alloc_type = jau::callocator<Value_type>, bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

constexpr jau::darray< Value_type, Size_type, Alloc_type, use_memmove, use_secmem >::darray	(	const darray< Value_type, Size_type, Alloc_type, use_memmove, use_secmem > &	x,
		const float	growth_factor,
		const allocator_type &	alloc
	)

inlineexplicitconstexpr

Creates a new instance, copying all elements from the given darray.

Capacity and size will equal the given array, i.e. the result is a trimmed jau::darray.

Parameters

x	the given darray, all elements will be copied into the new instance.
growth_factor	custom growth factor
alloc	custom allocator_type instance

Definition at line 513 of file darray.hpp.

◆ darray() [5/11]

template<typename Value_type , typename Size_type = jau::nsize_t, typename Alloc_type = jau::callocator<Value_type>, bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

constexpr jau::darray< Value_type, Size_type, Alloc_type, use_memmove, use_secmem >::darray	(	const darray< Value_type, Size_type, Alloc_type, use_memmove, use_secmem > &	x,
		const size_type	_capacity,
		const float	growth_factor,
		const allocator_type &	alloc
	)

inlineexplicitconstexpr

Creates a new instance with custom initial storage capacity, copying all elements from the given darray.

Size will equal the given array.

Throws jau::IllegalArgumentException() if _capacity < x.size().

Parameters

x	the given darray, all elements will be copied into the new instance.
_capacity	custom initial storage capacity
growth_factor	custom growth factor
alloc	custom allocator_type instance

Definition at line 531 of file darray.hpp.

◆ darray() [6/11]

template<typename Value_type , typename Size_type = jau::nsize_t, typename Alloc_type = jau::callocator<Value_type>, bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

constexpr jau::darray< Value_type, Size_type, Alloc_type, use_memmove, use_secmem >::darray ( darray< Value_type, Size_type, Alloc_type, use_memmove, use_secmem > && x )

inlineconstexprnoexcept

Definition at line 565 of file darray.hpp.

◆ darray() [7/11]

template<typename Value_type , typename Size_type = jau::nsize_t, typename Alloc_type = jau::callocator<Value_type>, bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

constexpr jau::darray< Value_type, Size_type, Alloc_type, use_memmove, use_secmem >::darray	(	darray< Value_type, Size_type, Alloc_type, use_memmove, use_secmem > &&	x,
		const float	growth_factor,
		const allocator_type &	alloc
	)

inlineexplicitconstexprnoexcept

Definition at line 575 of file darray.hpp.

◆ darray() [8/11]

template<typename Value_type , typename Size_type = jau::nsize_t, typename Alloc_type = jau::callocator<Value_type>, bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

constexpr jau::darray< Value_type, Size_type, Alloc_type, use_memmove, use_secmem >::darray	(	const size_type	_capacity,
		const_iterator	first,
		const_iterator	last,
		const float	growth_factor = `DEFAULT_GROWTH_FACTOR`,
		const allocator_type &	alloc = `allocator_type()`
	)

inlineexplicitconstexpr

Creates a new instance with custom initial storage capacity, copying all elements from the given const_iterator value_type range [first, last).

Size will equal the range [first, last), i.e. size_type(last-first).

Throws jau::IllegalArgumentException() if _capacity < size_type(last - first).

Parameters

_capacity	custom initial storage capacity
first	const_iterator to first element of value_type range [first, last)
last	const_iterator to last element of value_type range [first, last)
growth_factor	custom growth factor
alloc	custom allocator_type instance

Definition at line 622 of file darray.hpp.

◆ darray() [9/11]

template<typename Value_type , typename Size_type = jau::nsize_t, typename Alloc_type = jau::callocator<Value_type>, bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

template<class InputIt >

constexpr jau::darray< Value_type, Size_type, Alloc_type, use_memmove, use_secmem >::darray	(	const size_type	_capacity,
		InputIt	first,
		InputIt	last,
		const float	growth_factor = `DEFAULT_GROWTH_FACTOR`,
		const allocator_type &	alloc = `allocator_type()`
	)

inlineexplicitconstexpr

Creates a new instance with custom initial storage capacity, copying all elements from the given template input-iterator value_type range [first, last).

Size will equal the range [first, last), i.e. size_type(last-first).

Throws jau::IllegalArgumentException() if _capacity < size_type(last - first).

Template Parameters

InputIt template input-iterator custom type

Parameters

_capacity	custom initial storage capacity
first	template input-iterator to first element of value_type range [first, last)
last	template input-iterator to last element of value_type range [first, last)
growth_factor	custom growth factor
alloc	custom allocator_type instance

Definition at line 644 of file darray.hpp.

◆ darray() [10/11]

template<typename Value_type , typename Size_type = jau::nsize_t, typename Alloc_type = jau::callocator<Value_type>, bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

template<class InputIt >

constexpr jau::darray< Value_type, Size_type, Alloc_type, use_memmove, use_secmem >::darray	(	InputIt	first,
		InputIt	last,
		const allocator_type &	alloc = `allocator_type()`
	)

inlineconstexpr

Creates a new instance, copying all elements from the given template input-iterator value_type range [first, last).

Size will equal the range [first, last), i.e. size_type(last-first).

Template Parameters

InputIt template input-iterator custom type

Parameters

first	template input-iterator to first element of value_type range [first, last)
last	template input-iterator to last element of value_type range [first, last)
alloc	custom allocator_type instance

Definition at line 661 of file darray.hpp.

◆ darray() [11/11]

template<typename Value_type , typename Size_type = jau::nsize_t, typename Alloc_type = jau::callocator<Value_type>, bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

constexpr jau::darray< Value_type, Size_type, Alloc_type, use_memmove, use_secmem >::darray	(	std::initializer_list< value_type >	initlist,
		const allocator_type &	alloc = `allocator_type()`
	)

inlineconstexpr

Create a new instance from an initializer list.

Using the std::initializer_list requires to copy the given value_type objects into this darray.

To utilize more efficient move semantics, see push_back_list() and jau::make_darray().

Parameters

initlist	initializer_list.
alloc	allocator

See also: push_back_list(); jau::make_darray()

Definition at line 679 of file darray.hpp.

◆ ~darray()

template<typename Value_type , typename Size_type = jau::nsize_t, typename Alloc_type = jau::callocator<Value_type>, bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

jau::darray< Value_type, Size_type, Alloc_type, use_memmove, use_secmem >::~darray ( )

inlinenoexcept

Definition at line 685 of file darray.hpp.

Member Function Documentation

◆ operator=() [1/2]

template<typename Value_type , typename Size_type = jau::nsize_t, typename Alloc_type = jau::callocator<Value_type>, bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

constexpr darray & jau::darray< Value_type, Size_type, Alloc_type, use_memmove, use_secmem >::operator= ( const darray< Value_type, Size_type, Alloc_type, use_memmove, use_secmem > & x )

inlineconstexpr

Like std::vector::operator=(&), assignment.

Definition at line 541 of file darray.hpp.

Here is the caller graph for this function:

◆ operator=() [2/2]

template<typename Value_type , typename Size_type = jau::nsize_t, typename Alloc_type = jau::callocator<Value_type>, bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

constexpr darray & jau::darray< Value_type, Size_type, Alloc_type, use_memmove, use_secmem >::operator= ( darray< Value_type, Size_type, Alloc_type, use_memmove, use_secmem > && x )

inlineconstexprnoexcept

Like std::vector::operator=(&&), move.

Definition at line 588 of file darray.hpp.

◆ max_size()

template<typename Value_type , typename Size_type = jau::nsize_t, typename Alloc_type = jau::callocator<Value_type>, bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

constexpr size_type jau::darray< Value_type, Size_type, Alloc_type, use_memmove, use_secmem >::max_size ( ) const

inlineconstexprnoexcept

Returns std::numeric_limits<difference_type>::max() as the maximum array size.

We rely on the signed difference_type for pointer arithmetic, deducing ranges from iterator.

Definition at line 697 of file darray.hpp.

◆ begin() [1/2]

template<typename Value_type , typename Size_type = jau::nsize_t, typename Alloc_type = jau::callocator<Value_type>, bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

constexpr iterator jau::darray< Value_type, Size_type, Alloc_type, use_memmove, use_secmem >::begin ( )

inlineconstexprnoexcept

Definition at line 701 of file darray.hpp.

Here is the caller graph for this function:

◆ begin() [2/2]

template<typename Value_type , typename Size_type = jau::nsize_t, typename Alloc_type = jau::callocator<Value_type>, bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

constexpr const_iterator jau::darray< Value_type, Size_type, Alloc_type, use_memmove, use_secmem >::begin ( ) const

inlineconstexprnoexcept

Definition at line 703 of file darray.hpp.

◆ cbegin()

template<typename Value_type , typename Size_type = jau::nsize_t, typename Alloc_type = jau::callocator<Value_type>, bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

constexpr const_iterator jau::darray< Value_type, Size_type, Alloc_type, use_memmove, use_secmem >::cbegin ( ) const

inlineconstexprnoexcept

Definition at line 705 of file darray.hpp.

Here is the caller graph for this function:

◆ end() [1/2]

template<typename Value_type , typename Size_type = jau::nsize_t, typename Alloc_type = jau::callocator<Value_type>, bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

constexpr iterator jau::darray< Value_type, Size_type, Alloc_type, use_memmove, use_secmem >::end ( )

inlineconstexprnoexcept

Definition at line 707 of file darray.hpp.

Here is the caller graph for this function:

◆ end() [2/2]

template<typename Value_type , typename Size_type = jau::nsize_t, typename Alloc_type = jau::callocator<Value_type>, bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

constexpr const_iterator jau::darray< Value_type, Size_type, Alloc_type, use_memmove, use_secmem >::end ( ) const

inlineconstexprnoexcept

Definition at line 709 of file darray.hpp.

◆ cend()

template<typename Value_type , typename Size_type = jau::nsize_t, typename Alloc_type = jau::callocator<Value_type>, bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

constexpr const_iterator jau::darray< Value_type, Size_type, Alloc_type, use_memmove, use_secmem >::cend ( ) const

inlineconstexprnoexcept

Definition at line 711 of file darray.hpp.

Here is the caller graph for this function:

◆ get_allocator_ref()

template<typename Value_type , typename Size_type = jau::nsize_t, typename Alloc_type = jau::callocator<Value_type>, bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

const allocator_type & jau::darray< Value_type, Size_type, Alloc_type, use_memmove, use_secmem >::get_allocator_ref ( ) const

inlinenoexcept

Definition at line 723 of file darray.hpp.

◆ get_allocator()

template<typename Value_type , typename Size_type = jau::nsize_t, typename Alloc_type = jau::callocator<Value_type>, bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

allocator_type jau::darray< Value_type, Size_type, Alloc_type, use_memmove, use_secmem >::get_allocator ( ) const

inlinenoexcept

Definition at line 727 of file darray.hpp.

◆ growth_factor()

template<typename Value_type , typename Size_type = jau::nsize_t, typename Alloc_type = jau::callocator<Value_type>, bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

constexpr float jau::darray< Value_type, Size_type, Alloc_type, use_memmove, use_secmem >::growth_factor ( ) const

inlineconstexprnoexcept

Definition at line 731 of file darray.hpp.

Here is the caller graph for this function:

◆ capacity()

template<typename Value_type , typename Size_type = jau::nsize_t, typename Alloc_type = jau::callocator<Value_type>, bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

constexpr size_type jau::darray< Value_type, Size_type, Alloc_type, use_memmove, use_secmem >::capacity ( ) const

inlineconstexprnoexcept

Return the current capacity.

Definition at line 738 of file darray.hpp.

Here is the caller graph for this function:

◆ get_grown_capacity()

template<typename Value_type , typename Size_type = jau::nsize_t, typename Alloc_type = jau::callocator<Value_type>, bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

constexpr size_type jau::darray< Value_type, Size_type, Alloc_type, use_memmove, use_secmem >::get_grown_capacity ( ) const

inlineconstexprnoexcept

Return the current capacity() multiplied by the growth factor, minimum is max(capacity()+1, 10).

Definition at line 743 of file darray.hpp.

◆ empty()

template<typename Value_type , typename Size_type = jau::nsize_t, typename Alloc_type = jau::callocator<Value_type>, bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

constexpr bool jau::darray< Value_type, Size_type, Alloc_type, use_memmove, use_secmem >::empty ( ) const

inlineconstexprnoexcept

Like std::vector::empty().

Definition at line 752 of file darray.hpp.

◆ capacity_reached()

template<typename Value_type , typename Size_type = jau::nsize_t, typename Alloc_type = jau::callocator<Value_type>, bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

constexpr bool jau::darray< Value_type, Size_type, Alloc_type, use_memmove, use_secmem >::capacity_reached ( ) const

inlineconstexprnoexcept

Returns true if capacity has been reached and the next push_back() will grow the storage and invalidates all iterators and references.

Definition at line 758 of file darray.hpp.

◆ size()

template<typename Value_type , typename Size_type = jau::nsize_t, typename Alloc_type = jau::callocator<Value_type>, bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

constexpr size_type jau::darray< Value_type, Size_type, Alloc_type, use_memmove, use_secmem >::size ( ) const

inlineconstexprnoexcept

Like std::vector::size().

Examples: dbt_scanner10.cpp.

Definition at line 763 of file darray.hpp.

Here is the caller graph for this function:

◆ front() [1/2]

template<typename Value_type , typename Size_type = jau::nsize_t, typename Alloc_type = jau::callocator<Value_type>, bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

constexpr reference jau::darray< Value_type, Size_type, Alloc_type, use_memmove, use_secmem >::front ( )

inlineconstexpr

Like std::vector::front(), mutable access.

Definition at line 770 of file darray.hpp.

◆ front() [2/2]

template<typename Value_type , typename Size_type = jau::nsize_t, typename Alloc_type = jau::callocator<Value_type>, bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

constexpr const_reference jau::darray< Value_type, Size_type, Alloc_type, use_memmove, use_secmem >::front ( ) const

inlineconstexpr

Like std::vector::front(), immutable access.

Definition at line 775 of file darray.hpp.

◆ back() [1/2]

template<typename Value_type , typename Size_type = jau::nsize_t, typename Alloc_type = jau::callocator<Value_type>, bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

constexpr reference jau::darray< Value_type, Size_type, Alloc_type, use_memmove, use_secmem >::back ( )

inlineconstexpr

Like std::vector::back(), mutable access.

Definition at line 780 of file darray.hpp.

◆ back() [2/2]

template<typename Value_type , typename Size_type = jau::nsize_t, typename Alloc_type = jau::callocator<Value_type>, bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

constexpr const_reference jau::darray< Value_type, Size_type, Alloc_type, use_memmove, use_secmem >::back ( ) const

inlineconstexpr

Like std::vector::back(), immutable access.

Definition at line 785 of file darray.hpp.

◆ data() [1/2]

template<typename Value_type , typename Size_type = jau::nsize_t, typename Alloc_type = jau::callocator<Value_type>, bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

constexpr const_pointer jau::darray< Value_type, Size_type, Alloc_type, use_memmove, use_secmem >::data ( ) const

inlineconstexprnoexcept

Like std::vector::data(), const immutable pointer.

Definition at line 790 of file darray.hpp.

◆ data() [2/2]

template<typename Value_type , typename Size_type = jau::nsize_t, typename Alloc_type = jau::callocator<Value_type>, bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

constexpr pointer jau::darray< Value_type, Size_type, Alloc_type, use_memmove, use_secmem >::data ( )

inlineconstexprnoexcept

Like std::vector::data(), mutable pointer.

Definition at line 795 of file darray.hpp.

◆ operator[]() [1/2]

template<typename Value_type , typename Size_type = jau::nsize_t, typename Alloc_type = jau::callocator<Value_type>, bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

const_reference jau::darray< Value_type, Size_type, Alloc_type, use_memmove, use_secmem >::operator[] ( size_type i ) const

inlinenoexcept

Like std::vector::operator[](size_type), immutable reference.

Definition at line 800 of file darray.hpp.

◆ operator[]() [2/2]

template<typename Value_type , typename Size_type = jau::nsize_t, typename Alloc_type = jau::callocator<Value_type>, bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

reference jau::darray< Value_type, Size_type, Alloc_type, use_memmove, use_secmem >::operator[] ( size_type i )

inlinenoexcept

Like std::vector::operator[](size_type), mutable reference.

Definition at line 807 of file darray.hpp.

◆ at() [1/2]

template<typename Value_type , typename Size_type = jau::nsize_t, typename Alloc_type = jau::callocator<Value_type>, bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

const_reference jau::darray< Value_type, Size_type, Alloc_type, use_memmove, use_secmem >::at ( size_type i ) const

inline

Like std::vector::at(size_type), immutable reference.

Examples: dbt_scanner10.cpp.

Definition at line 814 of file darray.hpp.

Here is the caller graph for this function:

◆ at() [2/2]

template<typename Value_type , typename Size_type = jau::nsize_t, typename Alloc_type = jau::callocator<Value_type>, bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

reference jau::darray< Value_type, Size_type, Alloc_type, use_memmove, use_secmem >::at ( size_type i )

inline

Like std::vector::at(size_type), mutable reference.

Definition at line 824 of file darray.hpp.

◆ reserve()

template<typename Value_type , typename Size_type = jau::nsize_t, typename Alloc_type = jau::callocator<Value_type>, bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

void jau::darray< Value_type, Size_type, Alloc_type, use_memmove, use_secmem >::reserve ( size_type new_capacity )

inline

Like std::vector::reserve(), increases this instance's capacity to new_capacity.

Only creates a new storage and invalidates iterators if new_capacity is greater than the current jau::darray::capacity().

Definition at line 840 of file darray.hpp.

Here is the caller graph for this function:

◆ shrink_to_fit()

template<typename Value_type , typename Size_type = jau::nsize_t, typename Alloc_type = jau::callocator<Value_type>, bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

constexpr void jau::darray< Value_type, Size_type, Alloc_type, use_memmove, use_secmem >::shrink_to_fit ( )

inlineconstexpr

Like std::vector::shrink_to_fit(), but ensured constexpr.

If capacity() > size(), reallocate storage to size().

Definition at line 852 of file darray.hpp.

◆ assign() [1/2]

template<typename Value_type , typename Size_type = jau::nsize_t, typename Alloc_type = jau::callocator<Value_type>, bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

template<class InputIt >

constexpr void jau::darray< Value_type, Size_type, Alloc_type, use_memmove, use_secmem >::assign	(	InputIt	first,
		InputIt	last
	)

inlineconstexpr

Like std::vector::assign()

Template Parameters

InputIt foreign input-iterator to range of value_type [first, last)

Parameters

first	first foreign input-iterator to range of value_type [first, last)
last	last foreign input-iterator to range of value_type [first, last)

Definition at line 867 of file darray.hpp.

◆ assign() [2/2]

template<typename Value_type , typename Size_type = jau::nsize_t, typename Alloc_type = jau::callocator<Value_type>, bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

constexpr void jau::darray< Value_type, Size_type, Alloc_type, use_memmove, use_secmem >::assign	(	const_iterator	first,
		const_iterator	last
	)

inlineconstexpr

Like std::vector::assign(), but non-template overload using const_iterator.

Parameters

first	first const_iterator to range of value_type [first, last)
last	last const_iterator to range of value_type [first, last)

Definition at line 886 of file darray.hpp.

◆ clear()

template<typename Value_type , typename Size_type = jau::nsize_t, typename Alloc_type = jau::callocator<Value_type>, bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

constexpr void jau::darray< Value_type, Size_type, Alloc_type, use_memmove, use_secmem >::clear ( )

inlineconstexprnoexcept

Like std::vector::clear(), but ending with zero capacity.

Definition at line 904 of file darray.hpp.

Here is the caller graph for this function:

◆ swap()

template<typename Value_type , typename Size_type = jau::nsize_t, typename Alloc_type = jau::callocator<Value_type>, bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

constexpr void jau::darray< Value_type, Size_type, Alloc_type, use_memmove, use_secmem >::swap ( darray< Value_type, Size_type, Alloc_type, use_memmove, use_secmem > & x )

inlineconstexprnoexcept

Like std::vector::swap().

Definition at line 915 of file darray.hpp.

◆ pop_back()

template<typename Value_type , typename Size_type = jau::nsize_t, typename Alloc_type = jau::callocator<Value_type>, bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

constexpr void jau::darray< Value_type, Size_type, Alloc_type, use_memmove, use_secmem >::pop_back ( )

inlineconstexprnoexcept

Like std::vector::pop_back().

Definition at line 930 of file darray.hpp.

Here is the caller graph for this function:

◆ erase() [1/4]

template<typename Value_type , typename Size_type = jau::nsize_t, typename Alloc_type = jau::callocator<Value_type>, bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

constexpr iterator jau::darray< Value_type, Size_type, Alloc_type, use_memmove, use_secmem >::erase ( const_iterator pos )

inlineconstexpr

Like std::vector::erase(), removes the elements at pos.

Returns: iterator following the last removed element.

Definition at line 940 of file darray.hpp.

Here is the caller graph for this function:

◆ erase() [2/4]

template<typename Value_type , typename Size_type = jau::nsize_t, typename Alloc_type = jau::callocator<Value_type>, bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

constexpr iterator jau::darray< Value_type, Size_type, Alloc_type, use_memmove, use_secmem >::erase	(	iterator	first,
		const_iterator	last
	)

inlineconstexpr

Like std::vector::erase(), removes the elements in the range [first, last).

Returns: iterator following the last removed element.

Definition at line 956 of file darray.hpp.

◆ erase() [3/4]

template<typename Value_type , typename Size_type = jau::nsize_t, typename Alloc_type = jau::callocator<Value_type>, bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

constexpr iterator jau::darray< Value_type, Size_type, Alloc_type, use_memmove, use_secmem >::erase ( const size_type pos_idx )

inlineconstexpr

Similar to std::vector::erase() using an index, removes the elements at pos_idx.

Returns: iterator following the last removed element.

Definition at line 972 of file darray.hpp.

◆ erase() [4/4]

template<typename Value_type , typename Size_type = jau::nsize_t, typename Alloc_type = jau::callocator<Value_type>, bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

constexpr iterator jau::darray< Value_type, Size_type, Alloc_type, use_memmove, use_secmem >::erase	(	const size_type	first_idx,
		const size_type	last_idx
	)

inlineconstexpr

Similar to std::vector::erase() using indices, removes the elements in the range [first_idx, last_idx).

Returns: iterator following the last removed element.

Definition at line 980 of file darray.hpp.

◆ insert() [1/4]

template<typename Value_type , typename Size_type = jau::nsize_t, typename Alloc_type = jau::callocator<Value_type>, bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

constexpr iterator jau::darray< Value_type, Size_type, Alloc_type, use_memmove, use_secmem >::insert	(	const_iterator	pos,
		const value_type &	x
	)

inlineconstexpr

Like std::vector::insert(), copy.

Inserts the element before pos and moves all elements from there to the right beforehand.

size will be increased by one.

Parameters

pos	iterator before which the content will be inserted. pos may be the end() iterator
x	element value to insert

Definition at line 996 of file darray.hpp.

Here is the caller graph for this function:

◆ insert() [2/4]

template<typename Value_type , typename Size_type = jau::nsize_t, typename Alloc_type = jau::callocator<Value_type>, bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

constexpr iterator jau::darray< Value_type, Size_type, Alloc_type, use_memmove, use_secmem >::insert	(	const size_type	pos_idx,
		const value_type &	x
	)

inlineconstexpr

Similar to std::vector::insert() using an index, copy.

Parameters

pos_idx	index before which the content will be inserted. index may be the end size() index
x	element value to insert

Definition at line 1021 of file darray.hpp.

◆ insert() [3/4]

template<typename Value_type , typename Size_type = jau::nsize_t, typename Alloc_type = jau::callocator<Value_type>, bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

constexpr iterator jau::darray< Value_type, Size_type, Alloc_type, use_memmove, use_secmem >::insert	(	const_iterator	pos,
		value_type &&	x
	)

inlineconstexpr

Like std::vector::insert(), move.

Inserts the element before the given position and moves all elements from there to the right beforehand.

size will be increased by one.

Parameters

pos	iterator before which the content will be inserted. pos may be the end() iterator
x	element value to be moved into

Definition at line 1037 of file darray.hpp.

◆ emplace()

template<typename Value_type , typename Size_type = jau::nsize_t, typename Alloc_type = jau::callocator<Value_type>, bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

template<typename... Args>

constexpr iterator jau::darray< Value_type, Size_type, Alloc_type, use_memmove, use_secmem >::emplace	(	const_iterator	pos,
		Args &&...	args
	)

inlineconstexpr

Like std::vector::emplace(), construct a new element in place.

Constructs the element before the given position using placement new and moves all elements from there to the right beforehand.

size will be increased by one.

Parameters

pos	iterator before which the content will be inserted. pos may be the end() iterator
args	arguments to forward to the constructor of the element

Definition at line 1070 of file darray.hpp.

◆ insert() [4/4]

template<typename Value_type , typename Size_type = jau::nsize_t, typename Alloc_type = jau::callocator<Value_type>, bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

template<class InputIt >

constexpr iterator jau::darray< Value_type, Size_type, Alloc_type, use_memmove, use_secmem >::insert	(	const_iterator	pos,
		InputIt	first,
		InputIt	last
	)

inlineconstexpr

Like std::vector::insert(), inserting the value_type range [first, last).

Template Parameters

InputIt foreign input-iterator to range of value_type [first, last)

Parameters

pos	iterator before which the content will be inserted. pos may be the end() iterator
first	first foreign input-iterator to range of value_type [first, last)
last	last foreign input-iterator to range of value_type [first, last)

Returns: Iterator pointing to the first element inserted, or pos if first==last.

Definition at line 1099 of file darray.hpp.

◆ push_back() [1/3]

template<typename Value_type , typename Size_type = jau::nsize_t, typename Alloc_type = jau::callocator<Value_type>, bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

constexpr void jau::darray< Value_type, Size_type, Alloc_type, use_memmove, use_secmem >::push_back ( const value_type & x )

inlineconstexpr

Like std::vector::push_back(), copy.

Parameters

x	the value to be added at the tail.

Definition at line 1124 of file darray.hpp.

Here is the caller graph for this function:

◆ push_back() [2/3]

template<typename Value_type , typename Size_type = jau::nsize_t, typename Alloc_type = jau::callocator<Value_type>, bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

constexpr void jau::darray< Value_type, Size_type, Alloc_type, use_memmove, use_secmem >::push_back ( value_type && x )

inlineconstexpr

Like std::vector::push_back(), move.

Parameters

x	the value to be added at the tail.

Definition at line 1136 of file darray.hpp.

◆ push_front() [1/2]

template<typename Value_type , typename Size_type = jau::nsize_t, typename Alloc_type = jau::callocator<Value_type>, bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

constexpr void jau::darray< Value_type, Size_type, Alloc_type, use_memmove, use_secmem >::push_front ( const value_type & x )

inlineconstexpr

Like std::vector::push_front(), copy.

Parameters

x	the value to be added at the front.

Definition at line 1148 of file darray.hpp.

◆ push_front() [2/2]

template<typename Value_type , typename Size_type = jau::nsize_t, typename Alloc_type = jau::callocator<Value_type>, bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

constexpr void jau::darray< Value_type, Size_type, Alloc_type, use_memmove, use_secmem >::push_front ( value_type && x )

inlineconstexpr

Like std::vector::push_front(), move.

Parameters

x	the value to be added at the front.

Definition at line 1156 of file darray.hpp.

◆ emplace_back()

template<typename Value_type , typename Size_type = jau::nsize_t, typename Alloc_type = jau::callocator<Value_type>, bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

template<typename... Args>

constexpr reference jau::darray< Value_type, Size_type, Alloc_type, use_memmove, use_secmem >::emplace_back ( Args &&... args )

inlineconstexpr

Like std::vector::emplace_back(), construct a new element in place at the end().

Constructs the element at the end() using placement new.

size will be increased by one.

Parameters

args	arguments to forward to the constructor of the element

Definition at line 1171 of file darray.hpp.

Here is the caller graph for this function:

◆ push_back() [3/3]

template<typename Value_type , typename Size_type = jau::nsize_t, typename Alloc_type = jau::callocator<Value_type>, bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

template<class InputIt >

constexpr void jau::darray< Value_type, Size_type, Alloc_type, use_memmove, use_secmem >::push_back	(	InputIt	first,
		InputIt	last
	)

inlineconstexpr

Like std::vector::push_back(), but appends the value_type range [first, last).

Template Parameters

InputIt foreign input-iterator to range of value_type [first, last)

Parameters

first	first foreign input-iterator to range of value_type [first, last)
last	last foreign input-iterator to range of value_type [first, last)

Definition at line 1188 of file darray.hpp.

◆ push_back_list() [1/2]

template<typename Value_type , typename Size_type = jau::nsize_t, typename Alloc_type = jau::callocator<Value_type>, bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

template<typename... Args>

constexpr void jau::darray< Value_type, Size_type, Alloc_type, use_memmove, use_secmem >::push_back_list ( const Args &... args )

inlineconstexpr

Like push_back(), but for more multiple const r-value to copy.

Template Parameters

Args

Parameters

args	r-value references to copy into this storage

Definition at line 1205 of file darray.hpp.

Here is the caller graph for this function:

◆ push_back_list() [2/2]

template<typename Value_type , typename Size_type = jau::nsize_t, typename Alloc_type = jau::callocator<Value_type>, bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

template<typename... Args>

constexpr void jau::darray< Value_type, Size_type, Alloc_type, use_memmove, use_secmem >::push_back_list ( Args &&... args )

inlineconstexpr

Like push_back(), but for more multiple r-value references to move.

Template Parameters

Args

Parameters

args	r-value references to move into this storage

See also: jau::make_darray()

Definition at line 1228 of file darray.hpp.

◆ push_back_unique()

template<typename Value_type , typename Size_type = jau::nsize_t, typename Alloc_type = jau::callocator<Value_type>, bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

constexpr bool jau::darray< Value_type, Size_type, Alloc_type, use_memmove, use_secmem >::push_back_unique	(	const value_type &	x,
		equal_comparator	comparator
	)

inlineconstexpr

Like std::vector::push_back(), but only if the newly added element does not yet exist.

Examples

    static jau::darray<Thing>::equal_comparator thingEqComparator =
                 [](const Thing &a, const Thing &b) -> bool { return a == b; };
    ...
    jau::darray<Thing> list;

    bool added = list.push_back_unique(new_element, thingEqComparator);
    ...
    darray<std::shared_ptr<Thing>> listOfRefs;
    bool added = listOfRefs.push_back_unique(new_element,
                   [](const std::shared_ptr<Thing> &a, const std::shared_ptr<Thing> &b) -> bool { return *a == *b; });

Parameters

x	the value to be added at the tail, if not existing yet.
comparator	the equal comparator to return true if both given elements are equal

Returns: true if the element has been uniquely added, otherwise false

Definition at line 1272 of file darray.hpp.

◆ erase_matching()

template<typename Value_type , typename Size_type = jau::nsize_t, typename Alloc_type = jau::callocator<Value_type>, bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

constexpr size_type jau::darray< Value_type, Size_type, Alloc_type, use_memmove, use_secmem >::erase_matching	(	const value_type &	x,
		const bool	all_matching,
		equal_comparator	comparator
	)

inlineconstexpr

Erase either the first matching element or all matching elements.

Examples

    darray<Thing> list;
    int count = list.erase_matching(element, true,
                   [](const Thing &a, const Thing &b) -> bool { return a == b; });
    ...
    static jau::darray<Thing>::equal_comparator thingRefEqComparator =
                 [](const std::shared_ptr<Thing> &a, const std::shared_ptr<Thing> &b) -> bool { return *a == *b; };
    ...
    darray<std::shared_ptr<Thing>> listOfRefs;
    int count = listOfRefs.erase_matching(element, false, thingRefEqComparator);

Parameters

x	the value to be added at the tail, if not existing yet.
all_matching	if true, erase all matching elements, otherwise only the first matching element.
comparator	the equal comparator to return true if both given elements are equal

Returns: number of erased elements

Definition at line 1305 of file darray.hpp.

◆ toString()

template<typename Value_type , typename Size_type = jau::nsize_t, typename Alloc_type = jau::callocator<Value_type>, bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

std::string jau::darray< Value_type, Size_type, Alloc_type, use_memmove, use_secmem >::toString ( ) const

inlinenoexcept

Definition at line 1319 of file darray.hpp.

Here is the caller graph for this function:

◆ get_info()

template<typename Value_type , typename Size_type = jau::nsize_t, typename Alloc_type = jau::callocator<Value_type>, bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

std::string jau::darray< Value_type, Size_type, Alloc_type, use_memmove, use_secmem >::get_info ( ) const

inlinenoexcept

Definition at line 1330 of file darray.hpp.

Here is the caller graph for this function:

Member Data Documentation

◆ DEFAULT_GROWTH_FACTOR

template<typename Value_type , typename Size_type = jau::nsize_t, typename Alloc_type = jau::callocator<Value_type>, bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

constexpr const float jau::darray< Value_type, Size_type, Alloc_type, use_memmove, use_secmem >::DEFAULT_GROWTH_FACTOR = 1.618f

staticconstexpr

Default growth factor using the golden ratio 1.618.

Definition at line 151 of file darray.hpp.

◆ uses_memmove

template<typename Value_type , typename Size_type = jau::nsize_t, typename Alloc_type = jau::callocator<Value_type>, bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

constexpr const bool jau::darray< Value_type, Size_type, Alloc_type, use_memmove, use_secmem >::uses_memmove = use_memmove

staticconstexpr

Definition at line 153 of file darray.hpp.

◆ uses_secmem

template<typename Value_type , typename Size_type = jau::nsize_t, typename Alloc_type = jau::callocator<Value_type>, bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

constexpr const bool jau::darray< Value_type, Size_type, Alloc_type, use_memmove, use_secmem >::uses_secmem = use_secmem

staticconstexpr

Definition at line 154 of file darray.hpp.

◆ uses_realloc

template<typename Value_type , typename Size_type = jau::nsize_t, typename Alloc_type = jau::callocator<Value_type>, bool use_memmove = std::is_trivially_copyable_v<Value_type> || is_container_memmove_compliant_v<Value_type>, bool use_secmem = is_enforcing_secmem_v<Value_type>>

constexpr const bool jau::darray< Value_type, Size_type, Alloc_type, use_memmove, use_secmem >::uses_realloc = use_memmove && std::is_base_of_v<jau::callocator<Value_type>, Alloc_type>

staticconstexpr

Definition at line 155 of file darray.hpp.

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

jaulib/include/jau/darray.hpp

Public Types

Public Member Functions

Static Public Attributes

Detailed Description

Non-Type Template Parameter (NTTP) controlling Value_type memory

use_memmove

use_secmem

Member Typedef Documentation

◆ value_type

◆ pointer

◆ const_pointer

◆ reference

◆ const_reference

◆ iterator

◆ const_iterator

◆ size_type

◆ difference_type

◆ allocator_type

◆ darray_tag

◆ equal_comparator

Constructor & Destructor Documentation

◆ darray() [1/11]

◆ darray() [2/11]

◆ darray() [3/11]

◆ darray() [4/11]

◆ darray() [5/11]

◆ darray() [6/11]

◆ darray() [7/11]

◆ darray() [8/11]

◆ darray() [9/11]

◆ darray() [10/11]

◆ darray() [11/11]

◆ ~darray()

Member Function Documentation

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ max_size()

◆ begin() [1/2]

◆ begin() [2/2]

◆ cbegin()

◆ end() [1/2]

◆ end() [2/2]

◆ cend()

◆ get_allocator_ref()

◆ get_allocator()

◆ growth_factor()

◆ capacity()

◆ get_grown_capacity()

◆ empty()

◆ capacity_reached()

◆ size()

◆ front() [1/2]

◆ front() [2/2]

◆ back() [1/2]

◆ back() [2/2]

◆ data() [1/2]

◆ data() [2/2]

◆ operator[]() [1/2]

◆ operator[]() [2/2]

◆ at() [1/2]

◆ at() [2/2]

◆ reserve()

◆ shrink_to_fit()

◆ assign() [1/2]

◆ assign() [2/2]

◆ clear()

◆ swap()

◆ pop_back()

◆ erase() [1/4]

◆ erase() [2/4]

◆ erase() [3/4]

◆ erase() [4/4]

◆ insert() [1/4]

◆ insert() [2/4]

◆ insert() [3/4]

◆ emplace()

◆ insert() [4/4]

◆ push_back() [1/3]

◆ push_back() [2/3]

◆ push_front() [1/2]