agg::vertex_block_storage< T, BlockShift, BlockPool > Class Template Reference

#include <src/agg/agg_path_storage.h>

Public Types
enum	block_scale_e { block_shift = BlockShift , block_size = 1 << block_shift , block_mask = block_size - 1 , block_pool = BlockPool }
typedef T	value_type
typedef vertex_block_storage< T, BlockShift, BlockPool >	self_type

Public Member Functions
	~vertex_block_storage ()
	vertex_block_storage ()
	vertex_block_storage (const self_type &v)
const self_type &	operator= (const self_type &ps)
void	remove_all ()
void	free_all ()
void	add_vertex (double x, double y, unsigned cmd)
void	modify_vertex (unsigned idx, double x, double y)
void	modify_vertex (unsigned idx, double x, double y, unsigned cmd)
void	modify_command (unsigned idx, unsigned cmd)
void	swap_vertices (unsigned v1, unsigned v2)
unsigned	last_command () const
unsigned	last_vertex (double *x, double *y) const
unsigned	prev_vertex (double *x, double *y) const
double	last_x () const
double	last_y () const
unsigned	total_vertices () const
unsigned	vertex (unsigned idx, double *x, double *y) const
unsigned	command (unsigned idx) const

Private Member Functions
void	allocate_block (unsigned nb)
int8u *	storage_ptrs (T **xy_ptr)

Private Attributes
unsigned	m_total_vertices
unsigned	m_total_blocks
unsigned	m_max_blocks
T **	m_coord_blocks
int8u **	m_cmd_blocks

Detailed Description

template<class T, unsigned BlockShift = 8, unsigned BlockPool = 256>
class agg::vertex_block_storage< T, BlockShift, BlockPool >

Member Typedef Documentation

self_type

template<class T , unsigned BlockShift = 8, unsigned BlockPool = 256>

typedef vertex_block_storage<T, BlockShift, BlockPool> agg::vertex_block_storage< T, BlockShift, BlockPool >::self_type

value_type

template<class T , unsigned BlockShift = 8, unsigned BlockPool = 256>

typedef T agg::vertex_block_storage< T, BlockShift, BlockPool >::value_type

Member Enumeration Documentation

block_scale_e

template<class T , unsigned BlockShift = 8, unsigned BlockPool = 256>

enum agg::vertex_block_storage::block_scale_e

Enumerator
block_shift
block_size
block_mask
block_pool

        {
            block_shift = BlockShift,
            block_size  = 1 << block_shift,
            block_mask  = block_size - 1,
            block_pool  = BlockPool
        };

Constructor & Destructor Documentation

~vertex_block_storage()

template<class T , unsigned S, unsigned P>

agg::vertex_block_storage< T, S, P >::~vertex_block_storage

    {
        free_all();
    }

vertex_block_storage() [1/2]

template<class T , unsigned S, unsigned P>

agg::vertex_block_storage< T, S, P >::vertex_block_storage

                                                      :
        m_total_vertices(0),
        m_total_blocks(0),
        m_max_blocks(0),
        m_coord_blocks(0),
        m_cmd_blocks(0)
    {
    }

vertex_block_storage() [2/2]

template<class T , unsigned BlockShift = 8, unsigned BlockPool = 256>

agg::vertex_block_storage< T, BlockShift, BlockPool >::vertex_block_storage

(

const self_type &

v

)

Member Function Documentation

add_vertex()

template<class T , unsigned S, unsigned P>

void agg::vertex_block_storage< T, S, P >::add_vertex ( double  x, double  y, unsigned  cmd  )

inline

    {
        T* coord_ptr = 0;
        *storage_ptrs(&coord_ptr) = (int8u)cmd;
        coord_ptr[0] = T(x);
        coord_ptr[1] = T(y);
        m_total_vertices++;
    }

References cmd.

allocate_block()

template<class T , unsigned S, unsigned P>

void agg::vertex_block_storage< T, S, P >::allocate_block ( unsigned  nb )

private

    {
        if(nb >= m_max_blocks) 
        {
            T** new_coords = 
                pod_allocator<T*>::allocate((m_max_blocks + block_pool) * 2);
 
            unsigned char** new_cmds = 
                (unsigned char**)(new_coords + m_max_blocks + block_pool);
 
            if(m_coord_blocks)
            {
                memcpy(new_coords, 
                       m_coord_blocks, 
                       m_max_blocks * sizeof(T*));
 
                memcpy(new_cmds, 
                       m_cmd_blocks, 
                       m_max_blocks * sizeof(unsigned char*));
 
                pod_allocator<T*>::deallocate(m_coord_blocks, m_max_blocks * 2);
            }
            m_coord_blocks = new_coords;
            m_cmd_blocks   = new_cmds;
            m_max_blocks  += block_pool;
        }
        m_coord_blocks[nb] = 
            pod_allocator<T>::allocate(block_size * 2 + 
                   block_size / (sizeof(T) / sizeof(unsigned char)));
 
        m_cmd_blocks[nb]  = 
            (unsigned char*)(m_coord_blocks[nb] + block_size * 2);
 
        m_total_blocks++;
    }

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

Here is the call graph for this function:

command()

template<class T , unsigned S, unsigned P>

unsigned agg::vertex_block_storage< T, S, P >::command ( unsigned  idx ) const

inline

    {
        return m_cmd_blocks[idx >> block_shift][idx & block_mask];
    }

free_all()

template<class T , unsigned S, unsigned P>

void agg::vertex_block_storage< T, S, P >::free_all

    {
        if(m_total_blocks)
        {
            T** coord_blk = m_coord_blocks + m_total_blocks - 1;
            while(m_total_blocks--)
            {
                pod_allocator<T>::deallocate(
                    *coord_blk,
                    block_size * 2 + 
                    block_size / (sizeof(T) / sizeof(unsigned char)));
                --coord_blk;
            }
            pod_allocator<T*>::deallocate(m_coord_blocks, m_max_blocks * 2);
            m_total_blocks   = 0;
            m_max_blocks     = 0;
            m_coord_blocks   = 0;
            m_cmd_blocks     = 0;
            m_total_vertices = 0;
        }
    }

References agg::pod_allocator< T >::deallocate().

Here is the call graph for this function:

last_command()

template<class T , unsigned S, unsigned P>

unsigned agg::vertex_block_storage< T, S, P >::last_command

inline

    {
        if(m_total_vertices) return command(m_total_vertices - 1);
        return path_cmd_stop;
    }

References agg::path_cmd_stop.

last_vertex()

template<class T , unsigned S, unsigned P>

unsigned agg::vertex_block_storage< T, S, P >::last_vertex ( double *  x, double *  y  ) const

inline

    {
        if(m_total_vertices) return vertex(m_total_vertices - 1, x, y);
        return path_cmd_stop;
    }

References agg::path_cmd_stop.

last_x()

template<class T , unsigned S, unsigned P>

double agg::vertex_block_storage< T, S, P >::last_x

inline

    {
        if(m_total_vertices)
        {
            unsigned idx = m_total_vertices - 1;
            return m_coord_blocks[idx >> block_shift][(idx & block_mask) << 1];
        }
        return 0.0;
    }

last_y()

template<class T , unsigned S, unsigned P>

double agg::vertex_block_storage< T, S, P >::last_y

inline

    {
        if(m_total_vertices)
        {
            unsigned idx = m_total_vertices - 1;
            return m_coord_blocks[idx >> block_shift][((idx & block_mask) << 1) + 1];
        }
        return 0.0;
    }

modify_command()

template<class T , unsigned S, unsigned P>

void agg::vertex_block_storage< T, S, P >::modify_command ( unsigned  idx, unsigned  cmd  )

inline

    {
        m_cmd_blocks[idx >> block_shift][idx & block_mask] = (int8u)cmd;
    }

References cmd.

modify_vertex() [1/2]

template<class T , unsigned S, unsigned P>

void agg::vertex_block_storage< T, S, P >::modify_vertex ( unsigned  idx, double  x, double  y  )

inline

    {
        T* pv = m_coord_blocks[idx >> block_shift] + ((idx & block_mask) << 1);
        pv[0] = T(x);
        pv[1] = T(y);
    }

modify_vertex() [2/2]

template<class T , unsigned S, unsigned P>

void agg::vertex_block_storage< T, S, P >::modify_vertex ( unsigned  idx, double  x, double  y, unsigned  cmd  )

inline

    {
        unsigned block = idx >> block_shift;
        unsigned offset = idx & block_mask;
        T* pv = m_coord_blocks[block] + (offset << 1);
        pv[0] = T(x);
        pv[1] = T(y);
        m_cmd_blocks[block][offset] = (int8u)cmd;
    }

References block(), and cmd.

Here is the call graph for this function:

operator=()

template<class T , unsigned BlockShift = 8, unsigned BlockPool = 256>

const vertex_block_storage< T, S, P > & agg::vertex_block_storage< T, S, P >::operator=

(

const self_type &

ps

)

    {
        remove_all();
        unsigned i;
        for(i = 0; i < v.total_vertices(); i++)
        {
            double x, y;
            unsigned cmd = v.vertex(i, &x, &y);
            add_vertex(x, y, cmd);
        }
      return *this;
    }

References cmd, agg::vertex_block_storage< T, BlockShift, BlockPool >::total_vertices(), and agg::vertex_block_storage< T, BlockShift, BlockPool >::vertex().

Here is the call graph for this function:

prev_vertex()

template<class T , unsigned S, unsigned P>

unsigned agg::vertex_block_storage< T, S, P >::prev_vertex ( double *  x, double *  y  ) const

inline

    {
        if(m_total_vertices > 1) return vertex(m_total_vertices - 2, x, y);
        return path_cmd_stop;
    }

References agg::path_cmd_stop.

remove_all()

template<class T , unsigned S, unsigned P>

void agg::vertex_block_storage< T, S, P >::remove_all

inline

    {
        m_total_vertices = 0;
    }

storage_ptrs()

template<class T , unsigned S, unsigned P>

int8u * agg::vertex_block_storage< T, S, P >::storage_ptrs ( T **  xy_ptr )

private

    {
        unsigned nb = m_total_vertices >> block_shift;
        if(nb >= m_total_blocks)
        {
            allocate_block(nb);
        }
        *xy_ptr = m_coord_blocks[nb] + ((m_total_vertices & block_mask) << 1);
        return m_cmd_blocks[nb] + (m_total_vertices & block_mask);
    }

swap_vertices()

template<class T , unsigned S, unsigned P>

void agg::vertex_block_storage< T, S, P >::swap_vertices ( unsigned  v1, unsigned  v2  )

inline

    {
        unsigned b1 = v1 >> block_shift;
        unsigned b2 = v2 >> block_shift;
        unsigned o1 = v1 & block_mask;
        unsigned o2 = v2 & block_mask;
        T* pv1 = m_coord_blocks[b1] + (o1 << 1);
        T* pv2 = m_coord_blocks[b2] + (o2 << 1);
        T  val;
        val = pv1[0]; pv1[0] = pv2[0]; pv2[0] = val;
        val = pv1[1]; pv1[1] = pv2[1]; pv2[1] = val;
        int8u cmd = m_cmd_blocks[b1][o1];
        m_cmd_blocks[b1][o1] = m_cmd_blocks[b2][o2];
        m_cmd_blocks[b2][o2] = cmd;
    }

References cmd.

total_vertices()

template<class T , unsigned S, unsigned P>

unsigned agg::vertex_block_storage< T, S, P >::total_vertices

inline

    {
        return m_total_vertices;
    }

Referenced by agg::vertex_block_storage< T, BlockShift, BlockPool >::operator=().

Here is the caller graph for this function:

vertex()

template<class T , unsigned S, unsigned P>

unsigned agg::vertex_block_storage< T, S, P >::vertex ( unsigned  idx, double *  x, double *  y  ) const

inline

    {
        unsigned nb = idx >> block_shift;
        const T* pv = m_coord_blocks[nb] + ((idx & block_mask) << 1);
        *x = pv[0];
        *y = pv[1];
        return m_cmd_blocks[nb][idx & block_mask];
    }

Referenced by agg::vertex_block_storage< T, BlockShift, BlockPool >::operator=().

Here is the caller graph for this function:

Member Data Documentation

m_cmd_blocks

template<class T , unsigned BlockShift = 8, unsigned BlockPool = 256>

int8u** agg::vertex_block_storage< T, BlockShift, BlockPool >::m_cmd_blocks

private

m_coord_blocks

template<class T , unsigned BlockShift = 8, unsigned BlockPool = 256>

T** agg::vertex_block_storage< T, BlockShift, BlockPool >::m_coord_blocks

private

m_max_blocks

template<class T , unsigned BlockShift = 8, unsigned BlockPool = 256>

unsigned agg::vertex_block_storage< T, BlockShift, BlockPool >::m_max_blocks

private

m_total_blocks

template<class T , unsigned BlockShift = 8, unsigned BlockPool = 256>

unsigned agg::vertex_block_storage< T, BlockShift, BlockPool >::m_total_blocks

private

m_total_vertices

template<class T , unsigned BlockShift = 8, unsigned BlockPool = 256>

unsigned agg::vertex_block_storage< T, BlockShift, BlockPool >::m_total_vertices

private

---

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

• src/agg/agg_path_storage.h