#include <vec.h>

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

Public Member Functions
unsigned	allocated (void) const
unsigned	length (void) const
bool	is_empty (void) const
T *	address (void)
const T *	address (void) 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 (vec &)
void	splice (vec *src)
T *	quick_push (const T &)
T &	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 *))
unsigned	lower_bound (T, bool(*)(const T &, const T &)) const
void	embedded_init (unsigned, 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
T	m_vecdata [1]

Friends
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 Function Documentation

template<typename T , typename A >

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

inline

template<typename T , typename A >

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

inline

template<typename T , typename A >

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

inline

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 offsetof, and T.

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

template<typename T , typename A >

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

inline

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

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 gt_pch_nx(), length(), and T.

template<typename T , typename A >

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

inline

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; vec<T, A>::iterate (v, ix, &ptr); ix++) continue;

Referenced by vec_alloc().

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.

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 CONST_CAST, and T.

template<typename T , typename A >

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

inline

Referenced by embedded_size().

template<typename T , typename A >

unsigned vec< T, A, vl_embed >::lower_bound	(	T	obj,
		bool(*)(const T &, const T &)	lessthan
	)		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.

References gcc_checking_assert.

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.

template<typename T , typename A >

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

inline

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.

References first, and T.

template<typename T , typename A >

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

inline

Pop and return the last element off the end of the vector.

template<typename T , typename A >

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

inline

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

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.

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.

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.

Referenced by vec_safe_iterate().

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.

Referenced by vec_safe_grow_cleared().

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.

template<typename T , typename A >

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

Referenced by vec_safe_push().

template<typename T , typename A >

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

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.

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.

Friends And Related Function Documentation

template<typename T , typename A >

friend struct va_gc

friend

The allocator types also need access to our internals.

template<typename T , typename A >

friend struct va_gc_atomic

friend

template<typename T , typename A >

friend struct va_heap

friend

template<typename T , typename A >

friend struct vec

friend

vec class can access our internal data and functions.

Field Documentation

template<typename T , typename A >

T vec< T, A, vl_embed >::m_vecdata[1]

template<typename T , typename A >

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

FIXME - These fields should be private, but we need to cater to compilers that have stricter notions of PODness for types.

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

vec.h

Public Member Functions

Static Public Member Functions

Data Fields

Friends

Detailed Description

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

Member Function Documentation

Friends And Related Function Documentation

Field Documentation

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