#include <vec.h>

Collaboration diagram for vec< T, A, vl_embed >:

Public Types
using	pop_ret_type

Public Member Functions
unsigned	allocated (void) const

unsigned	length (void) const

bool	is_empty (void) const

T *	address (void)

const T *	address (void) const

T *	begin ()

const T *	begin () const

T *	end ()

const T *	end () const

const T &	operator[] (unsigned) const

T &	operator[] (unsigned)

T &	last (void)

bool	space (unsigned) const

bool	iterate (unsigned, T *) const

bool	iterate (unsigned, T **) const

vec *	copy (ALONE_CXX_MEM_STAT_INFO) const

void	splice (const vec &)

void	splice (const vec *src)

T *	quick_push (const T &)

pop_ret_type	pop (void)

void	truncate (unsigned)

void	quick_insert (unsigned, const T &)

void	ordered_remove (unsigned)

void	unordered_remove (unsigned)

void	block_remove (unsigned, unsigned)

void	qsort (int()(const void , const void *))

void	sort (int()(const void , const void , void ), void *)

void	stablesort (int()(const void , const void , void ), void *)

T *	bsearch (const void key, int(compar)(const void , const void ))

T *	bsearch (const void key, int(compar)(const void , const void , void ), void )

unsigned	lower_bound (const T &, bool(*)(const T &, const T &)) const

bool	contains (const T &search) const

void	embedded_init (unsigned, unsigned=0, unsigned=0)

void	quick_grow (unsigned len)

void	quick_grow_cleared (unsigned len)

Static Public Member Functions
static size_t	embedded_size (unsigned)

Data Fields
vec_prefix	m_vecpfx

Friends
template<typename , typename , typename >
struct	vec

struct	va_gc

struct	va_gc_atomic

struct	va_heap

Detailed Description

template<typename T, typename A>
struct vec< T, A, vl_embed >

Embeddable vector.  These vectors are suitable to be embedded
in other data structures so that they can be pre-allocated in a
contiguous memory block.

Embeddable vectors are implemented using the trailing array idiom,
thus they are not resizeable without changing the address of the
vector object itself.  This means you cannot have variables or
fields of embeddable vector type -- always use a pointer to a
vector.  The one exception is the final field of a structure, which
could be a vector type.

You will have to use the embedded_size & embedded_init calls to
create such objects, and they will not be resizeable (so the 'safe'
allocation variants are not available).

Properties:

     - The whole vector and control data are allocated in a single
       contiguous block.  It uses the trailing-vector idiom, so
       allocation must reserve enough space for all the elements
       in the vector plus its control data.
     - The vector cannot be re-allocated.
     - The vector cannot grow nor shrink.
     - No indirections needed for access/manipulation.
     - It requires 2 words of storage (prior to vector allocation).

Member Typedef Documentation

◆ pop_ret_type

template<typename T , typename A >

using vec< T, A, vl_embed >::pop_ret_type

Initial value:

typename std::conditional <std::is_trivially_destructible <T>::value,

T &, void>::type

type

Definition gengtype.h:252

Member Function Documentation

◆ address() [1/2]

template<typename T , typename A >

T * vec< T, A, vl_embed >::address ( void )

inline

◆ address() [2/2]

template<typename T , typename A >

const T * vec< T, A, vl_embed >::address ( void ) const

inline

◆ allocated()

template<typename T , typename A >

unsigned vec< T, A, vl_embed >::allocated ( void ) const

inline

◆ begin() [1/2]

template<typename T , typename A >

T * vec< T, A, vl_embed >::begin ( )

inline

◆ begin() [2/2]

template<typename T , typename A >

const T * vec< T, A, vl_embed >::begin ( ) const

inline

◆ block_remove()

template<typename T , typename A >

void vec< T, A, vl_embed >::block_remove	(	unsigned	ix,
		unsigned	len )

inline

Remove LEN elements starting at the IXth.  Ordering is retained.
This is an O(N) operation due to memmove.

References gcc_checking_assert.

◆ bsearch() [1/2]

template<typename T , typename A >

T * vec< T, A, vl_embed >::bsearch	(	const void *	key,
		int(*	compar )(const void , const void ) )

inline

Search the contents of the sorted vector with a binary search.
CMP is the comparison function to pass to bsearch.

References NULL, and T.

◆ bsearch() [2/2]

template<typename T , typename A >

T * vec< T, A, vl_embed >::bsearch	(	const void *	key,
		int(*	compar )(const void , const void , void *),
		void *	data )

inline

Search the contents of the sorted vector with a binary search.
CMP is the comparison function to pass to bsearch.

References NULL, and T.

◆ contains()

template<typename T , typename A >

bool vec< T, A, vl_embed >::contains ( const T & search ) const

inline

Return true if SEARCH is an element of V.  Note that this is O(N) in the
size of the vector and so should be used with care.

References i.

◆ copy()

template<typename T , typename A >

vec< T, A, vl_embed > * vec< T, A, vl_embed >::copy ( ALONE_CXX_MEM_STAT_INFO ) const

inline

Return a pointer to a copy of this vector.

References NULL, PASS_MEM_STAT, vec_alloc(), and vec_copy_construct().

Referenced by vec_safe_copy().

◆ embedded_init()

template<typename T , typename A >

void vec< T, A, vl_embed >::embedded_init	(	unsigned	alloc,
		unsigned	num = 0,
		unsigned	aut = 0 )

inline

Initialize the vector to contain room for ALLOC elements and
NUM active elements.

◆ embedded_size()

template<typename T , typename A >

size_t vec< T, A, vl_embed >::embedded_size ( unsigned alloc )

inlinestatic

Return the number of bytes needed to embed an instance of an
embeddable vec inside another data structure.

Use these methods to determine the required size and initialization
of a vector V of type T embedded within another structure (as the
final member):

size_t vec<T, A, vl_embed>::embedded_size (unsigned alloc);
void v->embedded_init (unsigned alloc, unsigned num);

These allow the caller to perform the memory allocation.

References T.

◆ end() [1/2]

template<typename T , typename A >

T * vec< T, A, vl_embed >::end ( )

inline

◆ end() [2/2]

template<typename T , typename A >

const T * vec< T, A, vl_embed >::end ( ) const

inline

◆ is_empty()

template<typename T , typename A >

bool vec< T, A, vl_embed >::is_empty ( void ) const

inline

◆ iterate() [1/2]

template<typename T , typename A >

bool vec< T, A, vl_embed >::iterate	(	unsigned	ix,
		T *	ptr ) const

inline

Return iteration condition and update *PTR to (a copy of) the IX'th
element of this vector.  Use this to iterate over the elements of a
vector as follows,

  for (ix = 0; v->iterate (ix, &val); ix++)
    continue;

◆ iterate() [2/2]

template<typename T , typename A >

bool vec< T, A, vl_embed >::iterate	(	unsigned	ix,
		T **	ptr ) const

inline

Return iteration condition and update *PTR to point to the
IX'th element of this vector.  Use this to iterate over the
elements of a vector as follows,

  for (ix = 0; v->iterate (ix, &ptr); ix++)
    continue;

This variant is for vectors of objects.

References CONST_CAST.

◆ last()

template<typename T , typename A >

T & vec< T, A, vl_embed >::last ( void )

inline

Get the final element of the vector, which must not be empty.

References gcc_checking_assert.

◆ length()

template<typename T , typename A >

unsigned vec< T, A, vl_embed >::length ( void ) const

inline

◆ lower_bound()

template<typename T , typename A >

unsigned vec< T, A, vl_embed >::lower_bound	(	const T &	obj,
		bool(*	lessthan )(const T &, const T &) ) const

Find and return the first position in which OBJ could be inserted
without changing the ordering of this vector.  LESSTHAN is a
function that returns true if the first argument is strictly less
than the second.

◆ operator[]() [1/2]

template<typename T , typename A >

T & vec< T, A, vl_embed >::operator[] ( unsigned ix )

inline

References gcc_checking_assert.

◆ operator[]() [2/2]

template<typename T , typename A >

const T & vec< T, A, vl_embed >::operator[] ( unsigned ix ) const

inline

Index into vector.  Return the IX'th element.  IX must be in the
domain of the vector.

References gcc_checking_assert.

◆ ordered_remove()

template<typename T , typename A >

void vec< T, A, vl_embed >::ordered_remove ( unsigned ix )

inline

Remove an element from the IXth position of this vector.  Ordering of
remaining elements is preserved.  This is an O(N) operation due to
memmove.  Not suitable for non-trivially copyable types.

References gcc_checking_assert.

◆ pop()

template<typename T , typename A >

vec< T, A, vl_embed >::pop_ret_type vec< T, A, vl_embed >::pop ( void )

inline

Pop and return a reference to the last element off the end of the
vector.  If T has non-trivial destructor, this method just pops
the element and returns void type.

References gcc_checking_assert, and last.

◆ qsort()

template<typename T , typename A >

void vec< T, A, vl_embed >::qsort ( int(* cmp )(const void *, const void *) )

inline

Sort the contents of this vector with qsort.  CMP is the comparison
function to pass to qsort.

References gcc_qsort().

◆ quick_grow()

template<typename T , typename A >

void vec< T, A, vl_embed >::quick_grow ( unsigned len )

inline

Grow the vector to a specific length.  LEN must be as long or longer than
the current length.  The new elements are uninitialized.

References gcc_checking_assert.

◆ quick_grow_cleared()

template<typename T , typename A >

void vec< T, A, vl_embed >::quick_grow_cleared ( unsigned len )

inline

Grow the vector to a specific length.  LEN must be as long or longer than
the current length.  The new elements are initialized to zero.

References gcc_checking_assert, and vec_default_construct().

◆ quick_insert()

template<typename T , typename A >

void vec< T, A, vl_embed >::quick_insert	(	unsigned	ix,
		const T &	obj )

inline

Insert an element, OBJ, at the IXth position of this vector.  There
must be sufficient space.  This operation is not suitable for non-trivially
copyable types.

References gcc_checking_assert.

◆ quick_push()

template<typename T , typename A >

T * vec< T, A, vl_embed >::quick_push ( const T & obj )

inline

Push OBJ (a new element) onto the end of the vector.  There must be
sufficient space in the vector.  Return a pointer to the slot
where OBJ was inserted.

References gcc_checking_assert, and T.

◆ sort()

template<typename T , typename A >

void vec< T, A, vl_embed >::sort	(	int(*	cmp )(const void , const void , void *),
		void *	data )

inline

Sort the contents of this vector with qsort.  CMP is the comparison
function to pass to qsort.

References gcc_sort_r().

◆ space()

template<typename T , typename A >

bool vec< T, A, vl_embed >::space ( unsigned nelems ) const

inline

If this vector has space for NELEMS additional entries, return
true.  You usually only need to use this if you are doing your
own vector reallocation, for instance on an embedded vector.  This
returns true in exactly the same circumstances that vec::reserve
will.

◆ splice() [1/2]

template<typename T , typename A >

void vec< T, A, vl_embed >::splice ( const vec< T, A, vl_embed > & )

◆ splice() [2/2]

template<typename T , typename A >

void vec< T, A, vl_embed >::splice ( const vec< T, A, vl_embed > * src )

◆ stablesort()

template<typename T , typename A >

void vec< T, A, vl_embed >::stablesort	(	int(*	cmp )(const void , const void , void *),
		void *	data )

inline

Sort the contents of this vector with gcc_stablesort_r.  CMP is the
comparison function to pass to qsort.

References gcc_stablesort_r().

◆ truncate()

template<typename T , typename A >

void vec< T, A, vl_embed >::truncate ( unsigned size )

inline

Set the length of the vector to SIZE.  The new length must be less
than or equal to the current length.  This is an O(1) operation.

References gcc_checking_assert, and vec_destruct().

◆ unordered_remove()

template<typename T , typename A >

void vec< T, A, vl_embed >::unordered_remove ( unsigned ix )

inline

Remove an element from the IXth position of this vector.  Ordering of
remaining elements is destroyed.  This is an O(1) operation.

References gcc_checking_assert.

Friends And Related Symbol Documentation

◆ va_gc

template<typename T , typename A >

friend struct va_gc

friend

◆ va_gc_atomic

template<typename T , typename A >

friend struct va_gc_atomic

friend

◆ va_heap

template<typename T , typename A >

friend struct va_heap

friend

◆ vec

template<typename T , typename A >

template<typename , typename , typename >

friend struct vec

friend

Field Documentation

◆ m_vecpfx

template<typename T , typename A >

vec_prefix vec< T, A, vl_embed >::m_vecpfx

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

vec.h

Public Types

Public Member Functions

Static Public Member Functions

Data Fields

Friends

Detailed Description

Member Typedef Documentation

◆ pop_ret_type

Member Function Documentation

◆ address() [1/2]

◆ address() [2/2]

◆ allocated()

◆ begin() [1/2]

◆ begin() [2/2]

◆ block_remove()

◆ bsearch() [1/2]

◆ bsearch() [2/2]

◆ contains()

◆ copy()

◆ embedded_init()

◆ embedded_size()

◆ end() [1/2]

◆ end() [2/2]

◆ is_empty()

◆ iterate() [1/2]

◆ iterate() [2/2]

◆ last()

◆ length()

◆ lower_bound()

◆ operator[]() [1/2]

◆ operator[]() [2/2]

◆ ordered_remove()

◆ pop()

◆ qsort()

◆ quick_grow()

◆ quick_grow_cleared()

◆ quick_insert()

◆ quick_push()

◆ sort()

◆ space()

◆ splice() [1/2]

◆ splice() [2/2]

◆ stablesort()

◆ truncate()

◆ unordered_remove()

Friends And Related Symbol Documentation

◆ va_gc

◆ va_gc_atomic

◆ va_heap

◆ vec

Field Documentation

◆ m_vecpfx