Variable dimension array, an array whose dimensions can be specified at runtime. More...

#include <datatypedef.h>

Collaboration diagram for VariableDimensionArray:

Public Member Functions
	VariableDimensionArray ()
	Default constructor that initializes values to default. More...

	~VariableDimensionArray ()
	Destructor. More...

	VariableDimensionArray (const VariableDimensionArray &vda)
	Deep copy. More...

VariableDimensionArray &	operator= (const VariableDimensionArray &vda)
	Equals operator deep copy. More...

void	initArray (std::vector< int > dim_sizes)
	Initialize the array with the specified dimensions. More...

int	translate_coord_to_index (std::vector< int > vals)
	Translate coordinates to the flat index actually used for storage. More...

std::vector< int >	translate_index_to_coords (int index)
	Translate index to coordinates. More...

int	getValue (std::vector< int > rLoc)
	Get the value specified by the loc coordinates. More...

void	setValue (std::vector< int > rLoc, int rVal)
	Set the value at the given coordinates. More...

Public Attributes
int *	index
	Flat storage of values. More...

int	index_size

std::vector< int >	sizes

Detailed Description

Variable dimension array, an array whose dimensions can be specified at runtime.

Values are stored in a flat array (an array with 1 dimension), and arithmetic is used to translate between coordinates (with the array's dimensionality) to flat indices.

Definition at line 133 of file datatypedef.h.

Constructor & Destructor Documentation

VariableDimensionArray ( )

inline

Default constructor that initializes values to default.

Definition at line 138 of file datatypedef.h.

References index, and index_size.

                             {
         this->index = NULL;
         index_size = 0;
     }

~VariableDimensionArray ( )

inline

Destructor.

Definition at line 146 of file datatypedef.h.

References index.

                              {
         delete[] index;
     }

VariableDimensionArray ( const VariableDimensionArray & vda )

inline

Deep copy.

Parameters

vda	Array to copy

Definition at line 154 of file datatypedef.h.

References i, index, index_size, and sizes.

                                                              {
         this->sizes = vda.sizes;
         this->index_size = vda.index_size;
 
         if(index_size > 0){
             this->index = new int[index_size];
 
             for(int i=0; i<index_size; i++)
                 index[i] = vda.index[i];
         }
     }

Member Function Documentation

int getValue ( std::vector< int > rLoc )

inline

Get the value specified by the loc coordinates.

Parameters

rLoc	Coordinates for the value to retrieve

Returns: The value

Definition at line 272 of file datatypedef.h.

References index, sizes, and translate_coord_to_index().

Referenced by indexed_points::get_indexed_point().

                                      {
 
         if(rLoc.size() != sizes.size())
             return -1;
 
         int flat_i = translate_coord_to_index(rLoc);
         return index[flat_i];
     }

Here is the call graph for this function:

Here is the caller graph for this function:

void initArray ( std::vector< int > dim_sizes )

inline

Initialize the array with the specified dimensions.

Parameters

dim_sizes The size of each dimension of the array

Definition at line 194 of file datatypedef.h.

References i, index, index_size, and sizes.

Referenced by manual_index_pts::set_layout().

                                             {
 
         if(this->index != NULL)
             return;
 
         int i_size = 1;
         for(int i=0; i<dim_sizes.size(); i++){
             i_size *= dim_sizes[i];
         }
 
         index = new int[i_size];
         index_size = i_size;
 
         for(int i=0; i<i_size; i++)
             index[i] = -1;
 
         for(int i=0; i<dim_sizes.size(); i++){
             this->sizes.push_back(dim_sizes[i]);
         }
     }

Here is the caller graph for this function:

VariableDimensionArray& operator= ( const VariableDimensionArray & vda )

inline

Equals operator deep copy.

Parameters

vda	Array to copy

Returns: Reference to new object

Definition at line 171 of file datatypedef.h.

References i, index, index_size, and sizes.

                                                                            {
         if(this != &vda){
             if(index_size > 0)
                 delete[] index;
         
             this->sizes = vda.sizes;
             this->index_size = vda.index_size;
 
             if(index_size > 0){
                 this->index = new int[index_size];
 
                 for(int i=0; i<index_size; i++)
                     index[i] = vda.index[i];
             }
         }
 
         return *this;
     }

void setValue	(	std::vector< int >	rLoc,
		int	rVal
	)

inline

Set the value at the given coordinates.

Parameters

rLoc	Location of the value to set
rVal	Value to set

Definition at line 286 of file datatypedef.h.

References index, sizes, and translate_coord_to_index().

Referenced by manual_index_pts::set_index().

                                                 {
         
         if(rLoc.size() != sizes.size())
             return;
 
         int flat_i = translate_coord_to_index(rLoc);
         index[flat_i] = rVal;
     }

Here is the call graph for this function:

Here is the caller graph for this function:

int translate_coord_to_index ( std::vector< int > vals )

inline

Translate coordinates to the flat index actually used for storage.

Parameters

vals	Coordinates to translate

Returns: Flat index location corresponding to the coordinates

Definition at line 220 of file datatypedef.h.

References i, and sizes.

Referenced by indexed_points::get_connected_points(), getValue(), and setValue().

                                                      {    
     
         int flat_i = 0;
 
         for(int i=0; i<vals.size(); i++){
 
             if(vals[i] >= sizes[i] || vals[i] < 0)
                 return -1;
 
             int multiplier = 1;
             for(int m=(i+1); m<vals.size(); m++){
                 multiplier *= sizes[m];
             }
 
             flat_i += vals[i] * multiplier;
         }
 
         return flat_i;
     }

Here is the caller graph for this function:

std::vector<int> translate_index_to_coords ( int index )

inline

Translate index to coordinates.

Parameters

index Flat index value

Returns: Coordinates of the point specified by the flat index

Definition at line 245 of file datatypedef.h.

References i, index_size, and sizes.

Referenced by indexed_points::get_connected_points().

                                                        {
         if(index > index_size){
             std::vector<int> blank_ret;
             return blank_ret;
         }
 
         std::vector<int> ret;
 
         for(int i=0; i<sizes.size(); i++){
 
             int dimsize = 1;
             for(int m=(i+1); m<sizes.size(); m++){
                 dimsize *= sizes[m];
             }       
             
             ret.push_back(index / dimsize);
             index = index % dimsize;
         }
 
         return ret;
     }