Implementation of a Copy-On-Write (CoW) using std::vector as the underlying storage, exposing lock-free read operations using SC-DRF atomic synchronization. More...

#include <cow_vector.hpp>

Collaboration diagram for jau::cow_vector< Value_type, Alloc_type >:

Public Types
typedef Value_type	value_type

typedef value_type *	pointer

typedef const value_type *	const_pointer

typedef value_type &	reference

typedef const value_type &	const_reference

typedef std::size_t	size_type

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

typedef Alloc_type	allocator_type

typedef std::vector< value_type, allocator_type >	storage_t

typedef std::shared_ptr< storage_t >	storage_ref_t

typedef cow_vector< value_type, allocator_type >	cow_container_t

typedef cow_ro_iterator< storage_t, storage_ref_t, cow_container_t >	const_iterator

typedef cow_rw_iterator< storage_t, storage_ref_t, cow_container_t >	iterator

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...

Public Member Functions
constexpr	cow_vector () noexcept

constexpr	cow_vector (const allocator_type &a) noexcept

constexpr	cow_vector (size_type n, const allocator_type &a=allocator_type())

constexpr	cow_vector (size_type n, const value_type &value, const allocator_type &a=allocator_type())

constexpr	cow_vector (const storage_t &x)

constexpr_atomic	cow_vector (const cow_vector &x)

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

constexpr_atomic	cow_vector (cow_vector &&x) noexcept

constexpr_atomic cow_vector &	operator= (cow_vector &&x)
	Like std::vector::operator=(&&), move. More...

template<class InputIt >
constexpr	cow_vector (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	cow_vector (std::initializer_list< value_type > initlist, const allocator_type &alloc=allocator_type())
	Create a new instance from an initializer list. More...

	~cow_vector () noexcept

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

constexpr std::recursive_mutex &	get_write_mutex () noexcept
	Returns this instances' recursive write mutex, allowing user to implement more complex mutable write operations. More...

constexpr_atomic storage_ref_t	copy_store ()
	Returns a new shared_ptr copy of the underlying store, i.e. More...

constexpr_atomic void	set_store (storage_ref_t &&new_store_ref) noexcept
	Special case facility allowing the user to replace the current store with the given value, potentially acquired via jau::cow_vector::copy_store() and mutated while holding the jau::cow_vector::get_write_mutex() lock. More...

constexpr_atomic storage_ref_t	snapshot () const noexcept
	Returns the current snapshot of the underlying shared std::vector<T> reference. More...

constexpr const_iterator	cbegin () const noexcept
	See description in jau::cow_darray::cbegin() More...

constexpr iterator	begin ()
	See description in jau::cow_darray::begin() More...

allocator_type	get_allocator () const noexcept

constexpr_atomic size_type	capacity () const noexcept

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

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

void	reserve (size_type new_capacity)

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

constexpr_atomic void	swap (cow_vector &x) noexcept
	Like std::vector::swap(). More...

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

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

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

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

constexpr_atomic 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_atomic int	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_cxx20 std::string	toString () const noexcept

Detailed Description

template<typename Value_type, typename Alloc_type = std::allocator<Value_type>>
class jau::cow_vector< Value_type, Alloc_type >

Implementation of a Copy-On-Write (CoW) using std::vector as the underlying storage, exposing lock-free read operations using SC-DRF atomic synchronization.

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

The vector's store is owned using a shared reference to the data structure, allowing its replacement on Copy-On-Write (CoW).

Writing to the store utilizes a mutex lock to avoid data races on the instances' write operations only, leaving read operations lock-free.
Write operations replace the store reference with a new instance using jau::sc_atomic_critical to synchronize with read operations.

Reading from the store is lock-free and accesses the store reference using jau::sc_atomic_critical to synchronizing with write operations.

Immutable storage const_iterators are supported via jau::cow_ro_iterator, which are constructed lock-free.
jau::cow_ro_iterator hold a snapshot retrieved via jau::cow_vector::snapshot() until its destruction.

Mutable storage iterators are supported via jau::cow_rw_iterator, which holds a copy of this CoW storage and locks its write mutex until jau::cow_rw_iterator::write_back() or its destruction.
After completing all mutable operations but before this iterator's destruction, the user might want to write back this iterators' storage to this CoW using jau::cow_rw_iterator::write_back().

Index operation via ::operator[](size_type) or ::at(size_type) are not supported, since they would be only valid if value_type itself is a std::shared_ptr and hence prohibit the destruction of the object if mutating the storage, e.g. via jau::cow_vector::push_back().

Custom mutable write operations are also supported via jau::cow_vector::get_write_mutex(), jau::cow_vector::copy_store() and jau::cow_vector::set_store().
See example in jau::cow_vector::set_store()

Member Typedef Documentation

◆ allocator_type

template<typename Value_type , typename Alloc_type = std::allocator<Value_type>>

typedef Alloc_type jau::cow_vector< Value_type, Alloc_type >::allocator_type

Definition at line 118 of file cow_vector.hpp.

◆ const_iterator

template<typename Value_type , typename Alloc_type = std::allocator<Value_type>>

typedef cow_ro_iterator<storage_t, storage_ref_t, cow_container_t> jau::cow_vector< Value_type, Alloc_type >::const_iterator

See also: jau::cow_darray::const_iterator; jau::cow_ro_iterator

Definition at line 129 of file cow_vector.hpp.

◆ const_pointer

template<typename Value_type , typename Alloc_type = std::allocator<Value_type>>

typedef const value_type* jau::cow_vector< Value_type, Alloc_type >::const_pointer

Definition at line 113 of file cow_vector.hpp.

◆ const_reference

template<typename Value_type , typename Alloc_type = std::allocator<Value_type>>

typedef const value_type& jau::cow_vector< Value_type, Alloc_type >::const_reference

Definition at line 115 of file cow_vector.hpp.

◆ cow_container_t

template<typename Value_type , typename Alloc_type = std::allocator<Value_type>>

typedef cow_vector<value_type, allocator_type> jau::cow_vector< Value_type, Alloc_type >::cow_container_t

Definition at line 123 of file cow_vector.hpp.

◆ difference_type

template<typename Value_type , typename Alloc_type = std::allocator<Value_type>>

typedef std::make_signed<size_type>::type jau::cow_vector< Value_type, Alloc_type >::difference_type

Definition at line 117 of file cow_vector.hpp.

◆ equal_comparator

template<typename Value_type , typename Alloc_type = std::allocator<Value_type>>

typedef bool(* jau::cow_vector< Value_type, Alloc_type >::equal_comparator) (const value_type &a, const value_type &b)

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

jau::cow_vector::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 549 of file cow_vector.hpp.

◆ iterator

template<typename Value_type , typename Alloc_type = std::allocator<Value_type>>

typedef cow_rw_iterator<storage_t, storage_ref_t, cow_container_t> jau::cow_vector< Value_type, Alloc_type >::iterator

See also: jau::cow_darray::iterator; jau::cow_rw_iterator

Definition at line 135 of file cow_vector.hpp.

◆ pointer

template<typename Value_type , typename Alloc_type = std::allocator<Value_type>>

typedef value_type* jau::cow_vector< Value_type, Alloc_type >::pointer

Definition at line 112 of file cow_vector.hpp.

◆ reference

template<typename Value_type , typename Alloc_type = std::allocator<Value_type>>

typedef value_type& jau::cow_vector< Value_type, Alloc_type >::reference

Definition at line 114 of file cow_vector.hpp.

◆ size_type

template<typename Value_type , typename Alloc_type = std::allocator<Value_type>>

typedef std::size_t jau::cow_vector< Value_type, Alloc_type >::size_type

Definition at line 116 of file cow_vector.hpp.

◆ storage_ref_t

template<typename Value_type , typename Alloc_type = std::allocator<Value_type>>

typedef std::shared_ptr<storage_t> jau::cow_vector< Value_type, Alloc_type >::storage_ref_t

Definition at line 121 of file cow_vector.hpp.

◆ storage_t

template<typename Value_type , typename Alloc_type = std::allocator<Value_type>>

typedef std::vector<value_type, allocator_type> jau::cow_vector< Value_type, Alloc_type >::storage_t

Definition at line 120 of file cow_vector.hpp.

◆ value_type

template<typename Value_type , typename Alloc_type = std::allocator<Value_type>>

typedef Value_type jau::cow_vector< Value_type, Alloc_type >::value_type

Definition at line 111 of file cow_vector.hpp.

Constructor & Destructor Documentation

◆ cow_vector() [1/9]

template<typename Value_type , typename Alloc_type = std::allocator<Value_type>>

constexpr jau::cow_vector< Value_type, Alloc_type >::cow_vector ( )

inlineconstexprnoexcept

Definition at line 147 of file cow_vector.hpp.

◆ cow_vector() [2/9]

template<typename Value_type , typename Alloc_type = std::allocator<Value_type>>

constexpr jau::cow_vector< Value_type, Alloc_type >::cow_vector ( const allocator_type & a )

inlineexplicitconstexprnoexcept

Definition at line 150 of file cow_vector.hpp.

◆ cow_vector() [3/9]

template<typename Value_type , typename Alloc_type = std::allocator<Value_type>>

constexpr jau::cow_vector< Value_type, Alloc_type >::cow_vector	(	size_type	n,
		const allocator_type &	a = `allocator_type()`
	)

inlineexplicitconstexpr

Definition at line 153 of file cow_vector.hpp.

◆ cow_vector() [4/9]

template<typename Value_type , typename Alloc_type = std::allocator<Value_type>>

constexpr jau::cow_vector< Value_type, Alloc_type >::cow_vector	(	size_type	n,
		const value_type &	value,
		const allocator_type &	a = `allocator_type()`
	)

inlineconstexpr

Definition at line 156 of file cow_vector.hpp.

◆ cow_vector() [5/9]

template<typename Value_type , typename Alloc_type = std::allocator<Value_type>>

constexpr jau::cow_vector< Value_type, Alloc_type >::cow_vector ( const storage_t & x )

inlineexplicitconstexpr

Definition at line 159 of file cow_vector.hpp.

◆ cow_vector() [6/9]

template<typename Value_type , typename Alloc_type = std::allocator<Value_type>>

constexpr_atomic jau::cow_vector< Value_type, Alloc_type >::cow_vector ( const cow_vector< Value_type, Alloc_type > & x )

inline

Definition at line 163 of file cow_vector.hpp.

◆ cow_vector() [7/9]

template<typename Value_type , typename Alloc_type = std::allocator<Value_type>>

constexpr_atomic jau::cow_vector< Value_type, Alloc_type >::cow_vector ( cow_vector< Value_type, Alloc_type > && x )

inlinenoexcept

Definition at line 195 of file cow_vector.hpp.

◆ cow_vector() [8/9]

template<typename Value_type , typename Alloc_type = std::allocator<Value_type>>

template<class InputIt >

constexpr jau::cow_vector< Value_type, Alloc_type >::cow_vector	(	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 248 of file cow_vector.hpp.

◆ cow_vector() [9/9]

template<typename Value_type , typename Alloc_type = std::allocator<Value_type>>

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

inlineconstexpr

Create a new instance from an initializer list.

Parameters

initlist	initializer_list.
alloc	allocator

Definition at line 258 of file cow_vector.hpp.

◆ ~cow_vector()

template<typename Value_type , typename Alloc_type = std::allocator<Value_type>>

jau::cow_vector< Value_type, Alloc_type >::~cow_vector ( )

inlinenoexcept

Definition at line 262 of file cow_vector.hpp.

Member Function Documentation

◆ begin()

template<typename Value_type , typename Alloc_type = std::allocator<Value_type>>

constexpr iterator jau::cow_vector< Value_type, Alloc_type >::begin ( )

inlineconstexpr

See description in jau::cow_darray::begin()

Definition at line 375 of file cow_vector.hpp.

Here is the caller graph for this function:

◆ capacity()

template<typename Value_type , typename Alloc_type = std::allocator<Value_type>>

constexpr_atomic size_type jau::cow_vector< Value_type, Alloc_type >::capacity ( ) const

inlinenoexcept

Definition at line 387 of file cow_vector.hpp.

◆ cbegin()

template<typename Value_type , typename Alloc_type = std::allocator<Value_type>>

constexpr const_iterator jau::cow_vector< Value_type, Alloc_type >::cbegin ( ) const

inlineconstexprnoexcept

See description in jau::cow_darray::cbegin()

Definition at line 366 of file cow_vector.hpp.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ clear()

template<typename Value_type , typename Alloc_type = std::allocator<Value_type>>

constexpr_atomic void jau::cow_vector< Value_type, Alloc_type >::clear ( )

inlinenoexcept

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

This write operation uses a mutex lock and is blocking this instances' write operations.

Definition at line 436 of file cow_vector.hpp.

◆ copy_store()

template<typename Value_type , typename Alloc_type = std::allocator<Value_type>>

constexpr_atomic storage_ref_t jau::cow_vector< Value_type, Alloc_type >::copy_store ( )

inline

Returns a new shared_ptr copy of the underlying store, i.e.

using a new copy-constructed vectore.

See example in jau::cow_vector::set_store()

This special operation uses a mutex lock and is blocking this instances' write operations only.

See also: jau::cow_vector::get_write_mutex(); jau::cow_vector::copy_store(); jau::cow_vector::set_store()

Definition at line 302 of file cow_vector.hpp.

◆ emplace_back()

template<typename Value_type , typename Alloc_type = std::allocator<Value_type>>

template<typename... Args>

constexpr_atomic reference jau::cow_vector< Value_type, Alloc_type >::emplace_back ( Args &&... args )

inline

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 532 of file cow_vector.hpp.

◆ empty()

template<typename Value_type , typename Alloc_type = std::allocator<Value_type>>

constexpr_atomic bool jau::cow_vector< Value_type, Alloc_type >::empty ( ) const

inlinenoexcept

Like std::vector::empty().

This read operation is lock-free.

Definition at line 399 of file cow_vector.hpp.

◆ erase_matching()

template<typename Value_type , typename Alloc_type = std::allocator<Value_type>>

constexpr_atomic int jau::cow_vector< Value_type, Alloc_type >::erase_matching	(	const value_type &	x,
		const bool	all_matching,
		equal_comparator	comparator
	)

inline

Erase either the first matching element or all matching elements.

This write operation uses a mutex lock and is blocking this instances' write operations only.

Examples

    cow_vector<Thing> list;
    int count = list.erase_matching(element, true,
                   [](const Thing &a, const Thing &b) -> bool { return a == b; });
    ...
    static jau::cow_vector<Thing>::equal_comparator thingRefEqComparator =
                 [](const std::shared_ptr<Thing> &a, const std::shared_ptr<Thing> &b) -> bool { return *a == *b; };
    ...
    cow_vector<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 614 of file cow_vector.hpp.

◆ get_allocator()

template<typename Value_type , typename Alloc_type = std::allocator<Value_type>>

allocator_type jau::cow_vector< Value_type, Alloc_type >::get_allocator ( ) const

inlinenoexcept

Definition at line 381 of file cow_vector.hpp.

◆ get_write_mutex()

template<typename Value_type , typename Alloc_type = std::allocator<Value_type>>

constexpr std::recursive_mutex& jau::cow_vector< Value_type, Alloc_type >::get_write_mutex ( )

inlineconstexprnoexcept

Returns this instances' recursive write mutex, allowing user to implement more complex mutable write operations.

See example in jau::cow_vector::set_store()

See also: jau::cow_vector::get_write_mutex(); jau::cow_vector::copy_store(); jau::cow_vector::set_store()

Definition at line 286 of file cow_vector.hpp.

◆ max_size()

template<typename Value_type , typename Alloc_type = std::allocator<Value_type>>

constexpr size_type jau::cow_vector< Value_type, Alloc_type >::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 271 of file cow_vector.hpp.

◆ operator=() [1/2]

template<typename Value_type , typename Alloc_type = std::allocator<Value_type>>

cow_vector& jau::cow_vector< Value_type, Alloc_type >::operator= ( const cow_vector< Value_type, Alloc_type > & x )

inline

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

This write operation uses a mutex lock and is blocking this instances' write operations only.

Definition at line 179 of file cow_vector.hpp.

◆ operator=() [2/2]

template<typename Value_type , typename Alloc_type = std::allocator<Value_type>>

constexpr_atomic cow_vector& jau::cow_vector< Value_type, Alloc_type >::operator= ( cow_vector< Value_type, Alloc_type > && x )

inline

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

This write operation uses a mutex lock and is blocking both cow_vector instance's write operations.

Definition at line 218 of file cow_vector.hpp.

◆ pop_back()

template<typename Value_type , typename Alloc_type = std::allocator<Value_type>>

constexpr_atomic void jau::cow_vector< Value_type, Alloc_type >::pop_back ( )

inlinenoexcept

Like std::vector::pop_back().

This write operation uses a mutex lock and is blocking this instances' write operations only.

Definition at line 472 of file cow_vector.hpp.

◆ push_back() [1/2]

template<typename Value_type , typename Alloc_type = std::allocator<Value_type>>

constexpr_atomic void jau::cow_vector< Value_type, Alloc_type >::push_back ( const value_type & x )

inline

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

This write operation uses a mutex lock and is blocking this instances' write operations only.

Parameters

x	the value to be added at the tail.

Definition at line 493 of file cow_vector.hpp.

Here is the caller graph for this function:

◆ push_back() [2/2]

template<typename Value_type , typename Alloc_type = std::allocator<Value_type>>

constexpr_atomic void jau::cow_vector< Value_type, Alloc_type >::push_back ( value_type && x )

inline

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

This write operation uses a mutex lock and is blocking this instances' write operations only.

Definition at line 510 of file cow_vector.hpp.

◆ push_back_unique()

template<typename Value_type , typename Alloc_type = std::allocator<Value_type>>

constexpr_atomic bool jau::cow_vector< Value_type, Alloc_type >::push_back_unique	(	const value_type &	x,
		equal_comparator	comparator
	)

inline

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

This write operation uses a mutex lock and is blocking this instances' write operations only.

Examples

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

    bool added = list.push_back_unique(new_element, thingEqComparator);
    ...
    cow_vector<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 576 of file cow_vector.hpp.

Here is the call graph for this function:

◆ reserve()

template<typename Value_type , typename Alloc_type = std::allocator<Value_type>>

void jau::cow_vector< Value_type, Alloc_type >::reserve ( size_type new_capacity )

inline

Definition at line 418 of file cow_vector.hpp.

◆ set_store()

template<typename Value_type , typename Alloc_type = std::allocator<Value_type>>

constexpr_atomic void jau::cow_vector< Value_type, Alloc_type >::set_store ( storage_ref_t && new_store_ref )

inlinenoexcept

Special case facility allowing the user to replace the current store with the given value, potentially acquired via jau::cow_vector::copy_store() and mutated while holding the jau::cow_vector::get_write_mutex() lock.

This is a move operation, i.e. the given new_store_ref is invalid on the caller side after this operation.
User shall pass the store via std::move()

    cow_vector<std::shared_ptr<Thing>> list;
    ...
    {
        std::lock_guard<std::recursive_mutex> lock(list.get_write_mutex());
        std::shared_ptr<std::vector<std::shared_ptr<Thing>>> snapshot = list.copy_store();
        ...
        some fancy mutation
        ...
        list.set_store(std::move(snapshot));
    }

Parameters

new_store_ref the user store to be moved here, replacing the current store.

See also: jau::cow_vector::get_write_mutex(); jau::cow_vector::copy_store(); jau::cow_vector::set_store()

Definition at line 335 of file cow_vector.hpp.

◆ size()

template<typename Value_type , typename Alloc_type = std::allocator<Value_type>>

constexpr_atomic size_type jau::cow_vector< Value_type, Alloc_type >::size ( ) const

inlinenoexcept

Like std::vector::size().

This read operation is lock-free.

Definition at line 411 of file cow_vector.hpp.

Here is the caller graph for this function:

◆ snapshot()

template<typename Value_type , typename Alloc_type = std::allocator<Value_type>>

constexpr_atomic storage_ref_t jau::cow_vector< Value_type, Alloc_type >::snapshot ( ) const

inlinenoexcept

Returns the current snapshot of the underlying shared std::vector<T> reference.

Note that this snapshot will be outdated by the next (concurrent) write operation.
The returned referenced vector is still valid and not mutated, but does not represent the current content of this cow_vector instance.

This read operation is lock-free.

See also: jau::for_each_cow

Definition at line 354 of file cow_vector.hpp.

Here is the caller graph for this function:

◆ swap()

template<typename Value_type , typename Alloc_type = std::allocator<Value_type>>

constexpr_atomic void jau::cow_vector< Value_type, Alloc_type >::swap ( cow_vector< Value_type, Alloc_type > & x )

inlinenoexcept

Like std::vector::swap().

This write operation uses a mutex lock and is blocking both cow_vector instance's write operations.

Definition at line 452 of file cow_vector.hpp.

◆ toString()

template<typename Value_type , typename Alloc_type = std::allocator<Value_type>>

constexpr_cxx20 std::string jau::cow_vector< Value_type, Alloc_type >::toString ( ) const

inlinenoexcept

Definition at line 636 of file cow_vector.hpp.

Here is the call graph for this function:

Here is the caller graph for this function:

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

/usr/local/projects/direct_bt/jaulib/include/jau/cow_vector.hpp

Public Types

Public Member Functions

Detailed Description

template<typename Value_type, typename Alloc_type = std::allocator<Value_type>> class jau::cow_vector< Value_type, Alloc_type >

Member Typedef Documentation

◆ allocator_type

◆ const_iterator

◆ const_pointer

◆ const_reference

◆ cow_container_t

◆ difference_type

◆ equal_comparator

◆ iterator

◆ pointer

◆ reference

◆ size_type

◆ storage_ref_t

◆ storage_t

◆ value_type

Constructor & Destructor Documentation

◆ cow_vector() [1/9]

◆ cow_vector() [2/9]

◆ cow_vector() [3/9]

◆ cow_vector() [4/9]

◆ cow_vector() [5/9]

◆ cow_vector() [6/9]

◆ cow_vector() [7/9]

◆ cow_vector() [8/9]

◆ cow_vector() [9/9]

◆ ~cow_vector()

Member Function Documentation

◆ begin()

◆ capacity()

◆ cbegin()

◆ clear()

◆ copy_store()

◆ emplace_back()

◆ empty()

◆ erase_matching()

◆ get_allocator()

◆ get_write_mutex()

◆ max_size()

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ pop_back()

◆ push_back() [1/2]

◆ push_back() [2/2]

◆ push_back_unique()

◆ reserve()

◆ set_store()

◆ size()

◆ snapshot()

◆ swap()

◆ toString()

template<typename Value_type, typename Alloc_type = std::allocator<Value_type>>
class jau::cow_vector< Value_type, Alloc_type >