EMAN2
Public Member Functions | Private Attributes
EMAN::CustomVector< type > Class Template Reference

CustomVector has some trivial optimizations of the STL vector. More...

#include <marchingcubes.h>

Inheritance diagram for EMAN::CustomVector< type >:
Inheritance graph
[legend]

List of all members.

Public Member Functions

 CustomVector (unsigned int starting_size=1024)
 Constructor.
 ~CustomVector ()
void clear (unsigned int starting_size=1024)
 Clear clears all data and resizes.
void resize (const unsigned int n)
 Resize Resize the data pointer using realloc In general you want to resize to a larger size...
void push_back (const type &t)
 Push back a value Potentially resizes.
void push_back_3 (const type *const p)
 Push back 3 values Potentially resizes.
void mult3 (const type &v1, const type &v2, const type &v3)
 Multiply contiguous groups of 3 by different values.
unsigned int elem ()
 The number of elements, is the same as STL::vector size() Should be called size() but oh well...
type & operator[] (const unsigned int idx)
 Operator[] - provide convenient set functionality (note NOT get)
type * get_data ()
 get the underlying data as a pointer objects

Private Attributes

type * data
 The data pointer.
unsigned int size
 The size of the associated memory block.
unsigned int elements
 The number of stored elements.

Detailed Description

template<typename type>
class EMAN::CustomVector< type >

CustomVector has some trivial optimizations of the STL vector.

It has get_data() functionality, which gives direct access to the underlying data, which is necessary for handing OpenGL vertex and normal arrays - the native STL vector does not give straightforward access to the data pointers. This class also has a push_back_3 function which does a memcpy of 3 elements - this can be used instead of 3 push_back function calls. Although it wasn't rigorously tested it should save some time by virtue of less function calls. Although the savings may be trivial, I just haven't tested it.

This class was not written for general use because- it is designed specifically for use in conjunction with the MarchingCubes class only.

Author:
David Woolford

Definition at line 78 of file marchingcubes.h.


Constructor & Destructor Documentation

template<typename type>
EMAN::CustomVector< type >::CustomVector ( unsigned int  starting_size = 1024) [inline, explicit]

Constructor.

Parameters:
starting_sizethe starting size of the underlying data

Definition at line 84 of file marchingcubes.h.

                                                                               : data(0), size(0), elements(0)
                        {
                                resize(starting_size);
                        }
template<typename type>
EMAN::CustomVector< type >::~CustomVector ( ) [inline]

Definition at line 89 of file marchingcubes.h.

                        {
                                if(data) {free(data); data=0;}
                        }

Member Function Documentation

template<typename type>
void EMAN::CustomVector< type >::clear ( unsigned int  starting_size = 1024) [inline]

Clear clears all data and resizes.

Parameters:
starting_sizethe starting size of the underlying data

Definition at line 98 of file marchingcubes.h.

                        {
                                if (data) {free(data); data = 0;}
                                size = 0;
                                elements = 0;
                                resize(starting_size);
                        }
template<typename type>
unsigned int EMAN::CustomVector< type >::elem ( ) [inline]

The number of elements, is the same as STL::vector size() Should be called size() but oh well...

This is the actual number of stored floating point numbers not the number of 'groups of 3'

Returns:
the number of elements stored by this object

Definition at line 159 of file marchingcubes.h.

{ return elements; }
template<typename type>
type* EMAN::CustomVector< type >::get_data ( ) [inline]

get the underlying data as a pointer objects

Returns:
the data pointer

Definition at line 178 of file marchingcubes.h.

{ return data; }
template<typename type>
void EMAN::CustomVector< type >::mult3 ( const type &  v1,
const type &  v2,
const type &  v3 
) [inline]

Multiply contiguous groups of 3 by different values.

Definition at line 144 of file marchingcubes.h.

                        {
                                for(unsigned int i = 0; (i + 2) < elements; i += 3 ){
                                        data[i] *= v1;
                                        data[i+1] *= v2;
                                        data[i+2] *= v3;
                                }
                        }
template<typename type>
type& EMAN::CustomVector< type >::operator[] ( const unsigned int  idx) [inline]

Operator[] - provide convenient set functionality (note NOT get)

Parameters:
idxthe index to access for setting purposes potentially resizes

Definition at line 165 of file marchingcubes.h.

                        {
                                unsigned int csize = size;
                                while (idx >= csize ) {
                                        csize *= 2;
                                }
                                if ( csize != size ) resize(csize);
                                return data[idx];
                        }
template<typename type>
void EMAN::CustomVector< type >::push_back ( const type &  t) [inline]

Push back a value Potentially resizes.

Parameters:
tthe value to push back

Definition at line 124 of file marchingcubes.h.

                        {
                                if ( elements == size ) resize(2*size);
                                data[elements] = t;
                                ++elements;
                        }
template<typename type>
void EMAN::CustomVector< type >::push_back_3 ( const type *const  p) [inline]

Push back 3 values Potentially resizes.

Parameters:
pa pointer to 3 contiguous values

Definition at line 135 of file marchingcubes.h.

                        {
                                if ( elements+2 >= size ) resize(2*size);
                                memcpy( &data[elements], p, 3*sizeof(type));
                                elements = elements + 3;
                        }
template<typename type>
void EMAN::CustomVector< type >::resize ( const unsigned int  n) [inline]

Resize Resize the data pointer using realloc In general you want to resize to a larger size...

Parameters:
nthe new size of the underlying data

Definition at line 112 of file marchingcubes.h.

Referenced by EMAN::CustomVector< F32 >::clear(), EMAN::CustomVector< F32 >::CustomVector(), EMAN::CustomVector< F32 >::operator[](), EMAN::CustomVector< F32 >::push_back(), and EMAN::CustomVector< F32 >::push_back_3().

                        {
                                data = (type*)realloc(data, n*sizeof(type));

                                for(unsigned int i = size; i < n; ++i) data[i] = 0;
                                size = n;
                        }

Member Data Documentation

template<typename type>
type* EMAN::CustomVector< type >::data [private]
template<typename type>
unsigned int EMAN::CustomVector< type >::elements [private]
template<typename type>
unsigned int EMAN::CustomVector< type >::size [private]

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