agg::pod_bvector< T, S > Class Template Reference

#include <src/agg/agg_array.h>

Inheritance diagram for agg::pod_bvector< T, S >:

Public Types
enum	block_scale_e { block_shift = S , block_size = 1 << block_shift , block_mask = block_size - 1 }
typedef T	value_type

Public Member Functions
	~pod_bvector ()
	pod_bvector ()
	pod_bvector (unsigned block_ptr_inc)
	pod_bvector (const pod_bvector< T, S > &v)
const pod_bvector< T, S > &	operator= (const pod_bvector< T, S > &v)
void	remove_all ()
void	clear ()
void	free_all ()
void	free_tail (unsigned size)
void	add (const T &val)
void	push_back (const T &val)
void	modify_last (const T &val)
void	remove_last ()
int	allocate_continuous_block (unsigned num_elements)
void	add_array (const T *ptr, unsigned num_elem)
template<class DataAccessor >
void	add_data (DataAccessor &data)
void	cut_at (unsigned size)
unsigned	size () const
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 &	curr (unsigned idx) const
T &	curr (unsigned idx)
const T &	prev (unsigned idx) const
T &	prev (unsigned idx)
const T &	next (unsigned idx) const
T &	next (unsigned idx)
const T &	last () const
T &	last ()
unsigned	byte_size () const
void	serialize (int8u *ptr) const
void	deserialize (const int8u *data, unsigned byte_size)
void	deserialize (unsigned start, const T &empty_val, const int8u *data, unsigned byte_size)
template<class ByteAccessor >
void	deserialize (ByteAccessor data)
template<class ByteAccessor >
void	deserialize (unsigned start, const T &empty_val, ByteAccessor data)
const T *	block (unsigned nb) const

Private Member Functions
void	allocate_block (unsigned nb)
T *	data_ptr ()

Private Attributes
unsigned	m_size
unsigned	m_num_blocks
unsigned	m_max_blocks
T **	m_blocks
unsigned	m_block_ptr_inc

Detailed Description

template<class T, unsigned S = 6>
class agg::pod_bvector< T, S >

Member Typedef Documentation

value_type

template<class T , unsigned S = 6>

typedef T agg::pod_bvector< T, S >::value_type

Member Enumeration Documentation

block_scale_e

template<class T , unsigned S = 6>

enum agg::pod_bvector::block_scale_e

Enumerator
block_shift
block_size
block_mask

        {   
            block_shift = S,
            block_size  = 1 << block_shift,
            block_mask  = block_size - 1
        };

Constructor & Destructor Documentation

~pod_bvector()

template<class T , unsigned S>

agg::pod_bvector< T, S >::~pod_bvector

    {
        if(m_num_blocks)
        {
            T** blk = m_blocks + m_num_blocks - 1;
            while(m_num_blocks--)
            {
                pod_allocator<T>::deallocate(*blk, block_size);
                --blk;
            }
        }
        pod_allocator<T*>::deallocate(m_blocks, m_max_blocks);
    }

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

Here is the call graph for this function:

pod_bvector() [1/3]

template<class T , unsigned S>

agg::pod_bvector< T, S >::pod_bvector

                                                                 :
        m_size(0),
        m_num_blocks(0),
        m_max_blocks(0),
        m_blocks(0),
        m_block_ptr_inc(block_size)
    {
    }

pod_bvector() [2/3]

template<class T , unsigned S>

agg::pod_bvector< T, S >::pod_bvector

(

unsigned

block_ptr_inc

)

                                                         :
        m_size(0),
        m_num_blocks(0),
        m_max_blocks(0),
        m_blocks(0),
        m_block_ptr_inc(block_ptr_inc)
    {
    }

pod_bvector() [3/3]

template<class T , unsigned S>

agg::pod_bvector< T, S >::pod_bvector

(

const pod_bvector< T, S > &

v

)

                                                             :
        m_size(v.m_size),
        m_num_blocks(v.m_num_blocks),
        m_max_blocks(v.m_max_blocks),
        m_blocks(v.m_max_blocks ? 
                 pod_allocator<T*>::allocate(v.m_max_blocks) : 
                 0),
        m_block_ptr_inc(v.m_block_ptr_inc)
    {
        unsigned i;
        for(i = 0; i < v.m_num_blocks; ++i)
        {
            m_blocks[i] = pod_allocator<T>::allocate(block_size);
            memcpy(m_blocks[i], v.m_blocks[i], block_size * sizeof(T));
        }
    }

References agg::pod_allocator< T >::allocate(), agg::pod_bvector< T, S >::block_size, agg::pod_bvector< T, S >::m_blocks, and agg::pod_bvector< T, S >::m_num_blocks.

Here is the call graph for this function:

Member Function Documentation

add()

template<class T , unsigned S>

void agg::pod_bvector< T, S >::add ( const T &  val )

inline

    {
        *data_ptr() = val;
        ++m_size;
    }

Referenced by agg::pod_bvector< T, S >::add_array(), agg::scanline32_p8::add_cell(), agg::scanline32_p8::add_cells(), agg::pod_bvector< T, S >::add_data(), agg::scanline32_p8::add_span(), agg::pod_bvector< T, S >::deserialize(), and agg::pod_bvector< T, S >::push_back().

Here is the caller graph for this function:

add_array()

template<class T , unsigned S = 6>

void agg::pod_bvector< T, S >::add_array ( const T *  ptr, unsigned  num_elem  )

inline

        {
            while(num_elem--)
            {
                add(*ptr++);
            }
        }

References agg::pod_bvector< T, S >::add().

Here is the call graph for this function:

add_data()

template<class T , unsigned S = 6>

template<class DataAccessor >

void agg::pod_bvector< T, S >::add_data ( DataAccessor &  data )

inline

        {
            while(data.size())
            {
                add(*data);
                ++data;
            }
        }

References agg::pod_bvector< T, S >::add().

Here is the call graph for this function:

allocate_block()

template<class T , unsigned S>

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

private

    {
        if(nb >= m_max_blocks) 
        {
            T** new_blocks = pod_allocator<T*>::allocate(m_max_blocks + m_block_ptr_inc);
 
            if(m_blocks)
            {
                memcpy(new_blocks, 
                       m_blocks, 
                       m_num_blocks * sizeof(T*));
 
                pod_allocator<T*>::deallocate(m_blocks, m_max_blocks);
            }
            m_blocks = new_blocks;
            m_max_blocks += m_block_ptr_inc;
        }
        m_blocks[nb] = pod_allocator<T>::allocate(block_size);
        m_num_blocks++;
    }

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

Here is the call graph for this function:

allocate_continuous_block()

template<class T , unsigned S>

int agg::pod_bvector< T, S >::allocate_continuous_block

(

unsigned

num_elements

)

    {
        if(num_elements < block_size)
        {
            data_ptr(); // Allocate initial block if necessary
            unsigned rest = block_size - (m_size & block_mask);
            unsigned index;
            if(num_elements <= rest)
            {
                // The rest of the block is good, we can use it
                //-----------------
                index = m_size;
                m_size += num_elements;
                return index;
            }
 
            // New block
            //---------------
            m_size += rest;
            data_ptr();
            index = m_size;
            m_size += num_elements;
            return index;
        }
        return -1; // Impossible to allocate
    }

at() [1/2]

template<class T , unsigned S = 6>

T & agg::pod_bvector< T, S >::at ( unsigned  i )

inline

        { 
            return m_blocks[i >> block_shift][i & block_mask];
        }

References agg::pod_bvector< T, S >::block_mask, agg::pod_bvector< T, S >::block_shift, and agg::pod_bvector< T, S >::m_blocks.

at() [2/2]

template<class T , unsigned S = 6>

const T & agg::pod_bvector< T, S >::at ( unsigned  i ) const

inline

        { 
            return m_blocks[i >> block_shift][i & block_mask];
        }

References agg::pod_bvector< T, S >::block_mask, agg::pod_bvector< T, S >::block_shift, and agg::pod_bvector< T, S >::m_blocks.

block()

template<class T , unsigned S = 6>

const T * agg::pod_bvector< T, S >::block ( unsigned  nb ) const

inline

{ return m_blocks[nb]; }

References agg::pod_bvector< T, S >::m_blocks.

byte_size()

template<class T , unsigned S>

unsigned agg::pod_bvector< T, S >::byte_size

    {
        return m_size * sizeof(T);
    }

clear()

template<class T , unsigned S = 6>

void agg::pod_bvector< T, S >::clear ( )

inline

{ m_size = 0; }

References agg::pod_bvector< T, S >::m_size.

curr() [1/2]

template<class T , unsigned S = 6>

T & agg::pod_bvector< T, S >::curr ( unsigned  idx )

inline

        {
            return (*this)[idx];
        }

curr() [2/2]

template<class T , unsigned S = 6>

const T & agg::pod_bvector< T, S >::curr ( unsigned  idx ) const

inline

        {
            return (*this)[idx];
        }

cut_at()

template<class T , unsigned S = 6>

void agg::pod_bvector< T, S >::cut_at ( unsigned  size )

inline

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

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

Here is the call graph for this function:

data_ptr()

template<class T , unsigned S>

T * agg::pod_bvector< T, S >::data_ptr

inlineprivate

    {
        unsigned nb = m_size >> block_shift;
        if(nb >= m_num_blocks)
        {
            allocate_block(nb);
        }
        return m_blocks[nb] + (m_size & block_mask);
    }

Referenced by agg::pod_bvector< T, S >::deserialize(), and agg::pod_bvector< T, S >::deserialize().

Here is the caller graph for this function:

deserialize() [1/4]

template<class T , unsigned S = 6>

template<class ByteAccessor >

void agg::pod_bvector< T, S >::deserialize ( ByteAccessor  data )

inline

        {
            remove_all();
            unsigned elem_size = data.size() / sizeof(T);
 
            for(unsigned i = 0; i < elem_size; ++i)
            {
                int8u* ptr = (int8u*)data_ptr();
                for(unsigned j = 0; j < sizeof(T); ++j)
                {
                    *ptr++ = *data;
                    ++data;
                }
                ++m_size;
            }
        }

References agg::pod_bvector< T, S >::data_ptr(), agg::pod_bvector< T, S >::m_size, and agg::pod_bvector< T, S >::remove_all().

Here is the call graph for this function:

deserialize() [2/4]

template<class T , unsigned S>

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

    {
        remove_all();
        byte_size /= sizeof(T);
        for(unsigned i = 0; i < byte_size; ++i)
        {
            T* ptr = data_ptr();
            memcpy(ptr, data, sizeof(T));
            ++m_size;
            data += sizeof(T);
        }
    }

deserialize() [3/4]

template<class T , unsigned S = 6>

template<class ByteAccessor >

void agg::pod_bvector< T, S >::deserialize ( unsigned  start, const T &  empty_val, ByteAccessor  data  )

inline

        {
            while(m_size < start)
            {
                add(empty_val);
            }
 
            unsigned elem_size = data.size() / sizeof(T);
            for(unsigned i = 0; i < elem_size; ++i)
            {
                int8u* ptr;
                if(start + i < m_size)
                {
                    ptr = (int8u*)(&((*this)[start + i]));
                }
                else
                {
                    ptr = (int8u*)data_ptr();
                    ++m_size;
                }
                for(unsigned j = 0; j < sizeof(T); ++j)
                {
                    *ptr++ = *data;
                    ++data;
                }
            }
        }

References agg::pod_bvector< T, S >::add(), agg::pod_bvector< T, S >::data_ptr(), and agg::pod_bvector< T, S >::m_size.

Here is the call graph for this function:

deserialize() [4/4]

template<class T , unsigned S>

void agg::pod_bvector< T, S >::deserialize	(	unsigned	start,
		const T &	empty_val,
		const int8u *	data,
		unsigned	byte_size
	)

    {
        while(m_size < start)
        {
            add(empty_val);
        }
 
        byte_size /= sizeof(T);
        for(unsigned i = 0; i < byte_size; ++i)
        {
            if(start + i < m_size)
            {
                memcpy(&((*this)[start + i]), data, sizeof(T));
            }
            else
            {
                T* ptr = data_ptr();
                memcpy(ptr, data, sizeof(T));
                ++m_size;
            }
            data += sizeof(T);
        }
    }

free_all()

template<class T , unsigned S = 6>

void agg::pod_bvector< T, S >::free_all ( )

inline

{ free_tail(0); }

References agg::pod_bvector< T, S >::free_tail().

Here is the call graph for this function:

free_tail()

template<class T , unsigned S>

void agg::pod_bvector< T, S >::free_tail

(

unsigned

size

)

    {
        if(size < m_size)
        {
            unsigned nb = (size + block_mask) >> block_shift;
            while(m_num_blocks > nb)
            {
                pod_allocator<T>::deallocate(m_blocks[--m_num_blocks], block_size);
            }
            if(m_num_blocks == 0)
            {
                pod_allocator<T*>::deallocate(m_blocks, m_max_blocks);
                m_blocks = 0;
                m_max_blocks = 0;
            }
            m_size = size;
        }
    }

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

Referenced by agg::pod_bvector< T, S >::free_all().

Here is the call graph for this function:

Here is the caller graph for this function:

last() [1/2]

template<class T , unsigned S = 6>

T & agg::pod_bvector< T, S >::last ( )

inline

        {
            return (*this)[m_size - 1];
        }

References agg::pod_bvector< T, S >::m_size.

last() [2/2]

template<class T , unsigned S = 6>

const T & agg::pod_bvector< T, S >::last ( ) const

inline

        {
            return (*this)[m_size - 1];
        }

References agg::pod_bvector< T, S >::m_size.

Referenced by agg::scanline32_p8::add_cell(), agg::scanline32_p8::add_cells(), and agg::scanline32_p8::add_span().

Here is the caller graph for this function:

modify_last()

template<class T , unsigned S>

void agg::pod_bvector< T, S >::modify_last

(

const T &

val

)

    {
        remove_last();
        add(val);
    }

next() [1/2]

template<class T , unsigned S = 6>

T & agg::pod_bvector< T, S >::next ( unsigned  idx )

inline

        {
            return (*this)[(idx + 1) % m_size];
        }

References agg::pod_bvector< T, S >::m_size.

next() [2/2]

template<class T , unsigned S = 6>

const T & agg::pod_bvector< T, S >::next ( unsigned  idx ) const

inline

        {
            return (*this)[(idx + 1) % m_size];
        }

References agg::pod_bvector< T, S >::m_size.

operator=()

template<class T , unsigned S>

const pod_bvector< T, S > & agg::pod_bvector< T, S >::operator=

(

const pod_bvector< T, S > &

v

)

    {
        unsigned i;
        for(i = m_num_blocks; i < v.m_num_blocks; ++i)
        {
            allocate_block(i);
        }
        for(i = 0; i < v.m_num_blocks; ++i)
        {
            memcpy(m_blocks[i], v.m_blocks[i], block_size * sizeof(T));
        }
        m_size = v.m_size;
        return *this;
    }

References agg::pod_bvector< T, S >::m_blocks, agg::pod_bvector< T, S >::m_num_blocks, and agg::pod_bvector< T, S >::m_size.

operator[]() [1/2]

template<class T , unsigned S = 6>

T & agg::pod_bvector< T, S >::operator[] ( unsigned  i )

inline

        {
            return m_blocks[i >> block_shift][i & block_mask];
        }

References agg::pod_bvector< T, S >::block_mask, agg::pod_bvector< T, S >::block_shift, and agg::pod_bvector< T, S >::m_blocks.

operator[]() [2/2]

template<class T , unsigned S = 6>

const T & agg::pod_bvector< T, S >::operator[] ( unsigned  i ) const

inline

        {
            return m_blocks[i >> block_shift][i & block_mask];
        }

References agg::pod_bvector< T, S >::block_mask, agg::pod_bvector< T, S >::block_shift, and agg::pod_bvector< T, S >::m_blocks.

prev() [1/2]

template<class T , unsigned S = 6>

T & agg::pod_bvector< T, S >::prev ( unsigned  idx )

inline

        {
            return (*this)[(idx + m_size - 1) % m_size];
        }

References agg::pod_bvector< T, S >::m_size.

prev() [2/2]

template<class T , unsigned S = 6>

const T & agg::pod_bvector< T, S >::prev ( unsigned  idx ) const

inline

        {
            return (*this)[(idx + m_size - 1) % m_size];
        }

References agg::pod_bvector< T, S >::m_size.

push_back()

template<class T , unsigned S = 6>

void agg::pod_bvector< T, S >::push_back ( const T &  val )

inline

{ add(val); }

References agg::pod_bvector< T, S >::add().

Here is the call graph for this function:

remove_all()

template<class T , unsigned S = 6>

void agg::pod_bvector< T, S >::remove_all ( )

inline

{ m_size = 0; }

References agg::pod_bvector< T, S >::m_size.

Referenced by agg::pod_bvector< T, S >::deserialize(), agg::scanline32_p8::reset(), and agg::scanline32_p8::reset_spans().

Here is the caller graph for this function:

remove_last()

template<class T , unsigned S>

void agg::pod_bvector< T, S >::remove_last

inline

    {
        if(m_size) --m_size;
    }

serialize()

template<class T , unsigned S>

void agg::pod_bvector< T, S >::serialize

(

int8u *

ptr

)

const

    {
        unsigned i;
        for(i = 0; i < m_size; i++)
        {
            memcpy(ptr, &(*this)[i], sizeof(T));
            ptr += sizeof(T);
        }
    }

size()

template<class T , unsigned S = 6>

unsigned agg::pod_bvector< T, S >::size ( ) const

inline

{ return m_size; }

References agg::pod_bvector< T, S >::m_size.

Referenced by agg::scanline32_p8::add_cell(), agg::scanline32_p8::add_cells(), agg::scanline32_p8::add_span(), agg::pod_bvector< T, S >::cut_at(), and agg::scanline32_p8::num_spans().

Here is the caller graph for this function:

value_at()

template<class T , unsigned S = 6>

T agg::pod_bvector< T, S >::value_at ( unsigned  i ) const

inline

        { 
            return m_blocks[i >> block_shift][i & block_mask];
        }

References agg::pod_bvector< T, S >::block_mask, agg::pod_bvector< T, S >::block_shift, and agg::pod_bvector< T, S >::m_blocks.

Member Data Documentation

m_block_ptr_inc

template<class T , unsigned S = 6>

unsigned agg::pod_bvector< T, S >::m_block_ptr_inc

private

m_blocks

template<class T , unsigned S = 6>

T** agg::pod_bvector< T, S >::m_blocks

private

Referenced by agg::pod_bvector< T, S >::pod_bvector(), agg::pod_bvector< T, S >::at(), agg::pod_bvector< T, S >::at(), agg::pod_bvector< T, S >::block(), agg::pod_bvector< T, S >::operator=(), agg::pod_bvector< T, S >::operator[](), agg::pod_bvector< T, S >::operator[](), and agg::pod_bvector< T, S >::value_at().

m_max_blocks

template<class T , unsigned S = 6>

unsigned agg::pod_bvector< T, S >::m_max_blocks

private

m_num_blocks

template<class T , unsigned S = 6>

unsigned agg::pod_bvector< T, S >::m_num_blocks

private

Referenced by agg::pod_bvector< T, S >::pod_bvector(), and agg::pod_bvector< T, S >::operator=().

m_size

template<class T , unsigned S = 6>

unsigned agg::pod_bvector< T, S >::m_size

private

Referenced by agg::pod_bvector< T, S >::clear(), agg::pod_bvector< T, S >::cut_at(), agg::pod_bvector< T, S >::deserialize(), agg::pod_bvector< T, S >::deserialize(), agg::pod_bvector< T, S >::last(), agg::pod_bvector< T, S >::last(), agg::pod_bvector< T, S >::next(), agg::pod_bvector< T, S >::next(), agg::pod_bvector< T, S >::operator=(), agg::pod_bvector< T, S >::prev(), agg::pod_bvector< T, S >::prev(), agg::pod_bvector< T, S >::remove_all(), and agg::pod_bvector< T, S >::size().

---

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

• src/agg/agg_array.h