GCC Middle and Back End API Reference
Public Member Functions | Static Public Member Functions | Data Fields | Friends
vec< T, A, vl_embed > Struct Template Reference

#include <vec.h>

Collaboration diagram for vec< T, A, vl_embed >:
Collaboration graph
[legend]

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 vecpfx_
T vecdata_ [1]

Friends

struct vec
struct va_gc
struct va_gc_atomic
struct va_heap
struct va_stack

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

Referenced by copy(), vec_safe_address(), and vec_safe_grow_cleared().

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 len, 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 address(), embedded_init(), len, memcpy(), T, and vec_alloc().

Referenced by vec< T, A, vl_ptr >::copy(), and vec_safe_copy().

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.

References va_stack::alloc().

Referenced by copy(), and va_gc::reserve().

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.

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

Referenced by vec_safe_is_empty().

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

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

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.
template<typename T , typename A >
unsigned vec< T, A, vl_embed >::length ( void  ) const
inline

Referenced by gt_pch_nx(), va_gc::reserve(), vec< T, A, vl_ptr >::safe_splice(), and vec_safe_length().

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

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

References T.

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

Referenced by vec_safe_grow().

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

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.

References T.

Referenced by vec_safe_insert().

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

Referenced by vec_safe_push().

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.

Referenced by vec_safe_space().

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

Referenced by vec_safe_splice().

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.

Referenced by vec_safe_truncate().

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
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 va_stack
friend
template<typename T , typename A >
friend struct vec
friend

Field Documentation

template<typename T , typename A >
T vec< T, A, vl_embed >::vecdata_[1]
template<typename T , typename A >
vec_prefix vec< T, A, vl_embed >::vecpfx_

Referenced by va_gc::reserve().

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