agg::pod_vector< T > Class Template Reference

#include <src/agg/agg_array.h>

Inheritance diagram for agg::pod_vector< T >:

Public Types
typedef T	value_type

Public Member Functions
	~pod_vector ()
	pod_vector ()
	pod_vector (unsigned cap, unsigned extra_tail=0)
	pod_vector (const pod_vector< T > &)
const pod_vector< T > &	operator= (const pod_vector< T > &)
void	capacity (unsigned cap, unsigned extra_tail=0)
unsigned	capacity () const
void	allocate (unsigned size, unsigned extra_tail=0)
void	resize (unsigned new_size)
void	zero ()
void	add (const T &v)
void	push_back (const T &v)
void	insert_at (unsigned pos, const T &val)
void	inc_size (unsigned size)
unsigned	size () const
unsigned	byte_size () const
void	serialize (int8u *ptr) const
void	deserialize (const int8u *data, unsigned byte_size)
const T &	operator[] (unsigned i) const
T &	operator[] (unsigned i)
const T &	at (unsigned i) const
T &	at (unsigned i)
T	value_at (unsigned i) const
const T *	data () const
T *	data ()
void	remove_all ()
void	clear ()
void	cut_at (unsigned num)

Private Attributes
unsigned	m_size
unsigned	m_capacity
T *	m_array

Detailed Description

template<class T>
class agg::pod_vector< T >

Member Typedef Documentation

value_type

template<class T >

typedef T agg::pod_vector< T >::value_type

Constructor & Destructor Documentation

~pod_vector()

template<class T >

agg::pod_vector< T >::~pod_vector ( )

inline

{ pod_allocator<T>::deallocate(m_array, m_capacity); }

References agg::pod_allocator< T >::deallocate(), agg::pod_vector< T >::m_array, and agg::pod_vector< T >::m_capacity.

Here is the call graph for this function:

pod_vector() [1/3]

template<class T >

agg::pod_vector< T >::pod_vector ( )

inline

: m_size(0), m_capacity(0), m_array(0) {}

pod_vector() [2/3]

template<class T >

agg::pod_vector< T >::pod_vector	(	unsigned	cap,
		unsigned	extra_tail = 0
	)

                                                                                 :
        m_size(0), 
        m_capacity(cap + extra_tail), 
        m_array(pod_allocator<T>::allocate(m_capacity)) {}

pod_vector() [3/3]

template<class T >

agg::pod_vector< T >::pod_vector

(

const pod_vector< T > &

v

)

                                                                      :
        m_size(v.m_size),
        m_capacity(v.m_capacity),
        m_array(v.m_capacity ? pod_allocator<T>::allocate(v.m_capacity) : 0)
    {
        memcpy(m_array, v.m_array, sizeof(T) * v.m_size);
    }

References agg::pod_vector< T >::m_array, and agg::pod_vector< T >::m_size.

Member Function Documentation

add()

template<class T >

void agg::pod_vector< T >::add ( const T &  v )

inline

{ m_array[m_size++] = v; }

References agg::pod_vector< T >::m_array, and agg::pod_vector< T >::m_size.

allocate()

template<class T >

void agg::pod_vector< T >::allocate	(	unsigned	size,
		unsigned	extra_tail = 0
	)

    {
        capacity(size, extra_tail);
        m_size = size;
    }

at() [1/2]

template<class T >

T & agg::pod_vector< T >::at ( unsigned  i )

inline

{ return m_array[i]; }

References agg::pod_vector< T >::m_array.

at() [2/2]

template<class T >

const T & agg::pod_vector< T >::at ( unsigned  i ) const

inline

{ return m_array[i]; }

References agg::pod_vector< T >::m_array.

byte_size()

template<class T >

unsigned agg::pod_vector< T >::byte_size ( ) const

inline

{ return m_size * sizeof(T); }

References agg::pod_vector< T >::m_size.

capacity() [1/2]

template<class T >

unsigned agg::pod_vector< T >::capacity ( ) const

inline

{ return m_capacity; }

References agg::pod_vector< T >::m_capacity.

capacity() [2/2]

template<class T >

void agg::pod_vector< T >::capacity	(	unsigned	cap,
		unsigned	extra_tail = 0
	)

    {
        m_size = 0;
        if(cap > m_capacity)
        {
            pod_allocator<T>::deallocate(m_array, m_capacity);
            m_capacity = cap + extra_tail;
            m_array = m_capacity ? pod_allocator<T>::allocate(m_capacity) : 0;
        }
    }

References agg::pod_allocator< T >::allocate(), and agg::pod_allocator< T >::deallocate().

Here is the call graph for this function:

clear()

template<class T >

void agg::pod_vector< T >::clear ( )

inline

{ m_size = 0; }

References agg::pod_vector< T >::m_size.

cut_at()

template<class T >

void agg::pod_vector< T >::cut_at ( unsigned  num )

inline

{ if(num < m_size) m_size = num; }

References agg::pod_vector< T >::m_size.

data() [1/2]

template<class T >

T * agg::pod_vector< T >::data ( )

inline

{ return m_array; }

References agg::pod_vector< T >::m_array.

data() [2/2]

template<class T >

const T * agg::pod_vector< T >::data ( ) const

inline

{ return m_array; }

References agg::pod_vector< T >::m_array.

Referenced by agg::rasterizer_cells_aa< Cell >::scanline_cells().

Here is the caller graph for this function:

deserialize()

template<class T >

void agg::pod_vector< T >::deserialize	(	const int8u *	data,
		unsigned	byte_size
	)

    {
        byte_size /= sizeof(T);
        allocate(byte_size);
        if(byte_size) memcpy(m_array, data, byte_size * sizeof(T));
    }

inc_size()

template<class T >

void agg::pod_vector< T >::inc_size ( unsigned  size )

inline

{ m_size += size; }

References agg::pod_vector< T >::m_size, and agg::pod_vector< T >::size().

Here is the call graph for this function:

insert_at()

template<class T >

void agg::pod_vector< T >::insert_at	(	unsigned	pos,
		const T &	val
	)

    {
        if(pos >= m_size) 
        {
            m_array[m_size] = val;
        }
        else
        {
            memmove(m_array + pos + 1, m_array + pos, (m_size - pos) * sizeof(T));
            m_array[pos] = val;
        }
        ++m_size;
    }

operator=()

template<class T >

const pod_vector< T > & agg::pod_vector< T >::operator=

(

const pod_vector< T > &

v

)

    {
        allocate(v.m_size);
        if(v.m_size) memcpy(m_array, v.m_array, sizeof(T) * v.m_size);
        return *this;
    }

References agg::pod_vector< T >::m_array, and agg::pod_vector< T >::m_size.

operator[]() [1/2]

template<class T >

T & agg::pod_vector< T >::operator[] ( unsigned  i )

inline

{ return m_array[i]; }

References agg::pod_vector< T >::m_array.

operator[]() [2/2]

template<class T >

const T & agg::pod_vector< T >::operator[] ( unsigned  i ) const

inline

{ return m_array[i]; }

References agg::pod_vector< T >::m_array.

push_back()

template<class T >

void agg::pod_vector< T >::push_back ( const T &  v )

inline

{ m_array[m_size++] = v; }

References agg::pod_vector< T >::m_array, and agg::pod_vector< T >::m_size.

remove_all()

template<class T >

void agg::pod_vector< T >::remove_all ( )

inline

{ m_size = 0; }

References agg::pod_vector< T >::m_size.

resize()

template<class T >

void agg::pod_vector< T >::resize

(

unsigned

new_size

)

    {
        if(new_size > m_size)
        {
            if(new_size > m_capacity)
            {
                T* data = pod_allocator<T>::allocate(new_size);
                memcpy(data, m_array, m_size * sizeof(T));
                pod_allocator<T>::deallocate(m_array, m_capacity);
                m_array = data;
            }
        }
        else
        {
            m_size = new_size;
        }
    }

References agg::pod_allocator< T >::allocate(), and agg::pod_allocator< T >::deallocate().

Here is the call graph for this function:

serialize()

template<class T >

void agg::pod_vector< T >::serialize

(

int8u *

ptr

)

const

    { 
        if(m_size) memcpy(ptr, m_array, m_size * sizeof(T)); 
    }

size()

template<class T >

unsigned agg::pod_vector< T >::size ( ) const

inline

{ return m_size; }

References agg::pod_vector< T >::m_size.

Referenced by agg::pod_vector< T >::inc_size().

Here is the caller graph for this function:

value_at()

template<class T >

T agg::pod_vector< T >::value_at ( unsigned  i ) const

inline

{ return m_array[i]; }

References agg::pod_vector< T >::m_array.

zero()

template<class T >

void agg::pod_vector< T >::zero ( )

inline

        {
            memset(m_array, 0, sizeof(T) * m_size);
        }

References agg::pod_vector< T >::m_array, and agg::pod_vector< T >::m_size.

Member Data Documentation

m_array

template<class T >

T* agg::pod_vector< T >::m_array

private

Referenced by agg::pod_vector< T >::pod_vector(), agg::pod_vector< T >::~pod_vector(), agg::pod_vector< T >::add(), agg::pod_vector< T >::at(), agg::pod_vector< T >::at(), agg::pod_vector< T >::data(), agg::pod_vector< T >::data(), agg::pod_vector< T >::operator=(), agg::pod_vector< T >::operator[](), agg::pod_vector< T >::operator[](), agg::pod_vector< T >::push_back(), agg::pod_vector< T >::value_at(), and agg::pod_vector< T >::zero().

m_capacity

template<class T >

unsigned agg::pod_vector< T >::m_capacity

private

Referenced by agg::pod_vector< T >::~pod_vector(), and agg::pod_vector< T >::capacity().

m_size

template<class T >

unsigned agg::pod_vector< T >::m_size

private

Referenced by agg::pod_vector< T >::pod_vector(), agg::pod_vector< T >::add(), agg::pod_vector< T >::byte_size(), agg::pod_vector< T >::clear(), agg::pod_vector< T >::cut_at(), agg::pod_vector< T >::inc_size(), agg::pod_vector< T >::operator=(), agg::pod_vector< T >::push_back(), agg::pod_vector< T >::remove_all(), agg::pod_vector< T >::size(), and agg::pod_vector< T >::zero().

---

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

• src/agg/agg_array.h