Direct-BT v3.3.0-1-gc2d430c
Direct-BT - Direct Bluetooth Programming.
Public Types | Public Member Functions | List of all members
jau::cow_vector< Value_type, Alloc_type > Class Template Reference

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 Alloc_type allocator_type
 
typedef cow_ro_iterator< storage_t, storage_ref_t, cow_container_tconst_iterator
 
typedef const value_typeconst_pointer
 
typedef const value_typeconst_reference
 
typedef cow_vector< value_type, allocator_typecow_container_t
 
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 cow_rw_iterator< storage_t, storage_ref_t, cow_container_titerator
 
typedef value_typepointer
 
typedef value_typereference
 
typedef std::size_t size_type
 
typedef std::shared_ptr< storage_tstorage_ref_t
 
typedef std::vector< value_type, allocator_typestorage_t
 
typedef Value_type value_type
 

Public Member Functions

constexpr cow_vector () noexcept
 
constexpr cow_vector (const allocator_type &a) noexcept
 
constexpr_atomic cow_vector (const cow_vector &x)
 
constexpr cow_vector (const storage_t &x)
 
constexpr_atomic cow_vector (cow_vector &&x) noexcept
 
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 (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 (std::initializer_list< value_type > initlist, const allocator_type &alloc=allocator_type())
 Create a new instance from an initializer list. More...
 
 ~cow_vector () noexcept=default
 
constexpr iterator begin ()
 See description in jau::cow_darray::begin() More...
 
constexpr_atomic size_type capacity () const noexcept
 
constexpr const_iterator cbegin () const noexcept
 See description in jau::cow_darray::cbegin() More...
 
constexpr_atomic void clear () noexcept
 Like std::vector::clear(), but ending with zero capacity. More...
 
constexpr_atomic storage_ref_t copy_store ()
 Returns a new shared_ptr copy of the underlying store, i.e. 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 empty () const noexcept
 Like std::vector::empty(). More...
 
constexpr_atomic 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...
 
allocator_type get_allocator () const noexcept
 
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 size_type max_size () const noexcept
 Returns std::numeric_limits<difference_type>::max() as the maximum array size. More...
 
cow_vectoroperator= (const cow_vector &x)
 Like std::vector::operator=(&), assignment. More...
 
constexpr_atomic cow_vectoroperator= (cow_vector &&x)
 Like std::vector::operator=(&&), move. 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...
 
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...
 
void reserve (size_type new_capacity)
 
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 size_type size () const noexcept
 Like std::vector::size(). More...
 
constexpr_atomic storage_ref_t snapshot () const noexcept
 Returns the current snapshot of the underlying shared std::vector<T> reference. More...
 
constexpr_atomic void swap (cow_vector &x) noexcept
 Like std::vector::swap(). More...
 
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 data structure is also supporting Concurrency.

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()

See also:


Examples
test_cow_iterator_01.cpp.

Definition at line 107 of file cow_vector.hpp.

Member Typedef Documentation

◆ 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 112 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 113 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 114 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 115 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 116 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 117 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 118 of file cow_vector.hpp.

◆ 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 119 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 121 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 122 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 124 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

◆ 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

◆ 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
aone element of the equality test.
bthe other element of the equality test.
Returns
true if both are equal

Definition at line 550 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 148 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 151 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 154 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 157 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 160 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 164 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 196 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
InputIttemplate input-iterator custom type
Parameters
firsttemplate input-iterator to first element of value_type range [first, last)
lasttemplate input-iterator to last element of value_type range [first, last)
alloccustom allocator_type instance

Definition at line 249 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
initlistinitializer_list.
allocallocator

Definition at line 259 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 ( )
defaultnoexcept

Member Function Documentation

◆ 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 180 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 219 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 272 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 287 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 303 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_refthe 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 336 of file cow_vector.hpp.

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

Here is the caller graph for this function:

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

Here is the caller graph for this function:

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

Here is the caller graph for this function:

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

◆ 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 388 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 400 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 412 of file cow_vector.hpp.

Here is the caller 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 419 of file cow_vector.hpp.

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

◆ 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 453 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 473 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
xthe value to be added at the tail.

Definition at line 494 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 511 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
argsarguments to forward to the constructor of the element

Definition at line 533 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
xthe value to be added at the tail, if not existing yet.
comparatorthe 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 577 of file cow_vector.hpp.

◆ erase_matching()

template<typename Value_type , typename Alloc_type = std::allocator<Value_type>>
constexpr_atomic size_type 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
xthe value to be added at the tail, if not existing yet.
all_matchingif true, erase all matching elements, otherwise only the first matching element.
comparatorthe equal comparator to return true if both given elements are equal
Returns
number of erased elements

Definition at line 615 of file cow_vector.hpp.

◆ toString()

template<typename Value_type , typename Alloc_type = std::allocator<Value_type>>
std::string jau::cow_vector< Value_type, Alloc_type >::toString ( ) const
inlinenoexcept

Definition at line 637 of file cow_vector.hpp.

Here is the caller graph for this function:

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