gpucalc::Data Class Reference

Class representing external (CPU-side) data. More...

#include <data.h>

Inheritance diagram for gpucalc::Data:

List of all members.

Public Member Functions

void createArray (ArrayDataType ADataType, char *Pointer, size_t ActualLengthCPU, size_t NumberOfComponents, size_t SizeX, size_t SizeY=0, size_t SizeZ=0)

void createArray (ArrayDataType ADataType, float *Pointer, size_t ActualLengthCPU, size_t NumberOfComponents, size_t SizeX, size_t SizeY=0, size_t SizeZ=0)

template<typename T>

void createArray (ArrayDataType, T *, size_t, size_t, size_t, size_t, size_t)

This method provide representation our data as arrays.

void createElement (ElementDataType EDataType, int *Pointer, size_t ActualLengthCPU, size_t SizeX, size_t SizeY)

void createElement (ElementDataType EDataType, float *Pointer, size_t ActualLengthCPU, size_t SizeX, size_t SizeY)

template<typename T>

void createElement (ElementDataType, T *, size_t, size_t, size_t)

Data (const std::string &DataName)

size_t getActualLengthCPU () const

Returns number of elements in our data array in CPU-side.

ArrayDataType getArrayDataType () const

const std::string & getClassName () const

Returns name of class of our object.

ElementDataType getElementDataType () const

size_t getNumberOfComponents () const

const std::string & getObjectName () const

Returns name of our object.

size_t getSizeX () const

size_t getSizeY () const

size_t getSizeZ () const

void getSpecificParameter (const std::string &ParameterName, void *ParameterValue)

Method for obtaining some specific parameters, such as texture specific params, and so on.

size_t getTypeSize () const

ValueType getValueType () const

bool isArray () const

bool isLocked () const

returns state of object.

void * pointer () const

~Data ()

Protected Member Functions

void addSpecificParameter (const std::string &ParameterName, void *ParameterValue, size_t Size)

void lock ()

void unlock ()

Private Member Functions

template<typename T>

void setInternalData (T *Pointer, size_t ActualLengthCPU, size_t NumberOfComponents, size_t SizeX, size_t SizeY=1, size_t SizeZ=1)

Private Attributes

size_t mActualLengthCPU

ArrayDataType mArrayDataType

ElementDataType mElementDataType

bool mIsArray

size_t mNumberOfComponents

void * mPointer

size_t mSizeX

size_t mSizeY

size_t mSizeZ

size_t mTypeSize

ValueType mValueType

Detailed Description

Class representing external (CPU-side) data.

Definition at line 143 of file data.h.

Constructor & Destructor Documentation

gpucalc::Data::Data ( const std::string & DataName ) [inline]

Definition at line 151 of file data.h.

00151                                    : Object(_DataClassName, DataName),
00152     mIsArray(false), mValueType(NOTType), mArrayDataType(NOTArray),
00153     mElementDataType(NOTElement), mPointer(0), mActualLengthCPU(0),
00154     mTypeSize(0), mNumberOfComponents(0), mSizeX(0), mSizeY(0), mSizeZ(0)
00155    {
00156    }

gpucalc::Data::~Data ( ) [inline]

Definition at line 158 of file data.h.

00159    {
00160    }

Member Function Documentation

void gpucalc::Object::addSpecificParameter	(	const std::string &	ParameterName,
		void *	ParameterValue,
		size_t	Size
	)			`[inline, protected, inherited]`

Definition at line 254 of file object.h.

00255    {
00256     SpecificParametersMap::iterator i = mSpecificParameters.find(ParameterName);
00257     if (i != mSpecificParameters.end())
00258     {
00259      mSpecificParameters.erase(i);
00260     }
00261     mSpecificParameters[ParameterName] = Any(ParameterValue, Size);
00262    }

void gpucalc::Data::createArray	(	ArrayDataType	ADataType,
		char *	Pointer,
		size_t	ActualLengthCPU,
		size_t	NumberOfComponents,
		size_t	SizeX,
		size_t	SizeY = `0`,
		size_t	SizeZ = `0`
	)			`[inline]`

Definition at line 185 of file data.h.

00187    {
00188     mIsArray = true;
00189     mArrayDataType = ADataType;
00190     mValueType = CharType;
00191     setInternalData(Pointer, ActualLengthCPU, NumberOfComponents, SizeX, SizeY, SizeZ);
00192 
00193     LogManager::getSingleton().logMessage(this, "Char value array created.", LML_Trivial);
00194    }

void gpucalc::Data::createArray	(	ArrayDataType	ADataType,
		float *	Pointer,
		size_t	ActualLengthCPU,
		size_t	NumberOfComponents,
		size_t	SizeX,
		size_t	SizeY = `0`,
		size_t	SizeZ = `0`
	)			`[inline]`

Definition at line 173 of file data.h.

00175    {
00176     mIsArray = true;
00177     mArrayDataType = ADataType;
00178     mValueType = FloatType;
00179     setInternalData(Pointer, ActualLengthCPU, NumberOfComponents, SizeX, SizeY, SizeZ);
00180 
00181     LogManager::getSingleton().logMessage(this, "Floating point value array created.", LML_Trivial);
00182    }

template<typename T>

void gpucalc::Data::createArray	(	ArrayDataType	,
		T *	,
		size_t	,
		size_t	,
		size_t	,
		size_t	,
		size_t
	)			`[inline]`

This method provide representation our data as arrays.

Definition at line 165 of file data.h.

00167    {
00168     Except<ERR_INVALID_STATE>(this, "Cannot assign void * pointer (or this type of pointer is not implemented), size of element is unknown.",
00169      "Data::createArray()", __FILE__, __LINE__);
00170    }

void gpucalc::Data::createElement	(	ElementDataType	EDataType,
		int *	Pointer,
		size_t	ActualLengthCPU,
		size_t	SizeX,
		size_t	SizeY
	)			`[inline]`

Definition at line 218 of file data.h.

00220    {
00221     mIsArray = false;
00222     mElementDataType = EDataType;
00223     mValueType = IntType;
00224     setInternalData(Pointer, ActualLengthCPU, SizeX, SizeY);
00225 
00226     LogManager::getSingleton().logMessage(this, "Integer element created.", LML_Trivial);
00227    }

void gpucalc::Data::createElement	(	ElementDataType	EDataType,
		float *	Pointer,
		size_t	ActualLengthCPU,
		size_t	SizeX,
		size_t	SizeY
	)			`[inline]`

Definition at line 206 of file data.h.

00208    {
00209     mIsArray = false;
00210     mElementDataType = EDataType;
00211     mValueType = FloatType;
00212     setInternalData(Pointer, ActualLengthCPU, SizeX, SizeY);
00213 
00214     LogManager::getSingleton().logMessage(this, "Floating point element created.", LML_Trivial);
00215    }

template<typename T>

void gpucalc::Data::createElement	(	ElementDataType	,
		T *	,
		size_t	,
		size_t	,
		size_t
	)			`[inline]`

Definition at line 198 of file data.h.

00200    {
00201     Except<ERR_INVALID_STATE>(this, "Cannot assign void * pointer (or this type of pointer is not implemented), size of element is unknown.",
00202      "Data::createElement()", __FILE__, __LINE__);
00203    }

size_t gpucalc::Data::getActualLengthCPU ( ) const [inline]

Returns number of elements in our data array in CPU-side.

Definition at line 254 of file data.h.

00255    {
00256     return mActualLengthCPU;
00257    }

ArrayDataType gpucalc::Data::getArrayDataType ( ) const [inline]

Definition at line 236 of file data.h.

00237    {
00238     return mArrayDataType;
00239    }

const std::string& gpucalc::Object::getClassName ( ) const [inline, inherited]

Returns name of class of our object.

Definition at line 92 of file object.h.

00093    {
00094     return mClassName;
00095    }

ElementDataType gpucalc::Data::getElementDataType ( ) const [inline]

Definition at line 241 of file data.h.

00242    {
00243     return mElementDataType;
00244    }

size_t gpucalc::Data::getNumberOfComponents ( ) const [inline]

Definition at line 264 of file data.h.

00265    {
00266     return mNumberOfComponents;
00267    }

const std::string& gpucalc::Object::getObjectName ( ) const [inline, inherited]

Returns name of our object.

Definition at line 101 of file object.h.

00102    {
00103     return mObjectName;
00104    }

size_t gpucalc::Data::getSizeX ( ) const [inline]

Definition at line 269 of file data.h.

00270    {
00271     return mSizeX;
00272    }

size_t gpucalc::Data::getSizeY ( ) const [inline]

Definition at line 274 of file data.h.

00275    {
00276     return mSizeY;
00277    }

size_t gpucalc::Data::getSizeZ ( ) const [inline]

Definition at line 279 of file data.h.

00280    {
00281     return mSizeZ;
00282    }

void gpucalc::Object::getSpecificParameter	(	const std::string &	ParameterName,
		void *	ParameterValue
	)			`[inline, inherited]`

Method for obtaining some specific parameters, such as texture specific params, and so on.

Parameters:

	ParameterName	- name of parameter, usually it similar to specific method of some object (for example, GLTextureID)
	ParameterValue	- contain value of named parameter, it must be allocated and have sufficient size.

Todo:: Think for better realization.

Definition at line 128 of file object.h.

00129    {
00130     SpecificParametersMap::iterator i = mSpecificParameters.find(ParameterName);
00131     if (i != mSpecificParameters.end())
00132     {
00133      i->second.copyValue(ParameterValue);
00134     }
00135     else
00136     {
00137      Except<ERR_ITEM_NOT_FOUND>(this, "Parameter \"" + ParameterName + "\" does not exists.", "Object::getSpecificParameter()", __FILE__, __LINE__);
00138     }
00139    }

size_t gpucalc::Data::getTypeSize ( ) const [inline]

Definition at line 259 of file data.h.

00260    {
00261     return mTypeSize;
00262    }

ValueType gpucalc::Data::getValueType ( ) const [inline]

Definition at line 231 of file data.h.

00232    {
00233     return mValueType;
00234    }

bool gpucalc::Data::isArray ( ) const [inline]

Definition at line 284 of file data.h.

00285    {
00286     return mIsArray;
00287    }

bool gpucalc::Object::isLocked ( ) const [inline, inherited]

returns state of object.

If object is locked then we cannot change some state of it, because object is used in computation. If object is unlocked then we can change some state of it, object is not in computation.

Definition at line 113 of file object.h.

00114    {
00115     return mIsLocked;
00116    }

void gpucalc::Object::lock ( ) [inline, protected, inherited]

Definition at line 265 of file object.h.

00266    {
00267     mIsLocked = true;
00268    }

void* gpucalc::Data::pointer ( ) const [inline]

Definition at line 246 of file data.h.

00247    {
00248     return mPointer;
00249    }

template<typename T>

void gpucalc::Data::setInternalData	(	T *	Pointer,
		size_t	ActualLengthCPU,
		size_t	NumberOfComponents,
		size_t	SizeX,
		size_t	SizeY = `1`,
		size_t	SizeZ = `1`
	)			`[inline, private]`

Definition at line 310 of file data.h.

00312    {
00313     mPointer = Pointer;
00314     mActualLengthCPU = ActualLengthCPU;
00315     mTypeSize = sizeof(T);
00316     mNumberOfComponents = NumberOfComponents;
00317 
00318     mSizeX = SizeX;
00319     mSizeY = SizeY;
00320     mSizeZ = SizeZ;
00321    }

void gpucalc::Object::unlock ( ) [inline, protected, inherited]

Definition at line 271 of file object.h.

00272    {
00273     mIsLocked = false;
00274    }

Member Data Documentation

size_t gpucalc::Data::mActualLengthCPU [private]

Definition at line 300 of file data.h.

ArrayDataType gpucalc::Data::mArrayDataType [private]

Definition at line 295 of file data.h.

ElementDataType gpucalc::Data::mElementDataType [private]

Definition at line 296 of file data.h.

bool gpucalc::Data::mIsArray [private]

Definition at line 291 of file data.h.

size_t gpucalc::Data::mNumberOfComponents [private]

Definition at line 302 of file data.h.

void* gpucalc::Data::mPointer [mutable, private]

Definition at line 299 of file data.h.

size_t gpucalc::Data::mSizeX [private]

Definition at line 305 of file data.h.

size_t gpucalc::Data::mSizeY [private]

Definition at line 306 of file data.h.

size_t gpucalc::Data::mSizeZ [private]

Definition at line 307 of file data.h.

size_t gpucalc::Data::mTypeSize [private]

Definition at line 301 of file data.h.

ValueType gpucalc::Data::mValueType [private]

Definition at line 294 of file data.h.

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

gpucalc/data.h


Public Member Functions
void	createArray (ArrayDataType ADataType, char *Pointer, size_t ActualLengthCPU, size_t NumberOfComponents, size_t SizeX, size_t SizeY=0, size_t SizeZ=0)
void	createArray (ArrayDataType ADataType, float *Pointer, size_t ActualLengthCPU, size_t NumberOfComponents, size_t SizeX, size_t SizeY=0, size_t SizeZ=0)
template<typename T>
void	createArray (ArrayDataType, T *, size_t, size_t, size_t, size_t, size_t)
	This method provide representation our data as arrays.
void	createElement (ElementDataType EDataType, int *Pointer, size_t ActualLengthCPU, size_t SizeX, size_t SizeY)
void	createElement (ElementDataType EDataType, float *Pointer, size_t ActualLengthCPU, size_t SizeX, size_t SizeY)
template<typename T>
void	createElement (ElementDataType, T *, size_t, size_t, size_t)
	Data (const std::string &DataName)
size_t	getActualLengthCPU () const
	Returns number of elements in our data array in CPU-side.
ArrayDataType	getArrayDataType () const
const std::string &	getClassName () const
	Returns name of class of our object.
ElementDataType	getElementDataType () const
size_t	getNumberOfComponents () const
const std::string &	getObjectName () const
	Returns name of our object.
size_t	getSizeX () const
size_t	getSizeY () const
size_t	getSizeZ () const
void	getSpecificParameter (const std::string &ParameterName, void *ParameterValue)
	Method for obtaining some specific parameters, such as texture specific params, and so on.
size_t	getTypeSize () const
ValueType	getValueType () const
bool	isArray () const
bool	isLocked () const
	returns state of object.
void *	pointer () const
	~Data ()
Protected Member Functions
void	addSpecificParameter (const std::string &ParameterName, void *ParameterValue, size_t Size)
void	lock ()
void	unlock ()
Private Member Functions
template<typename T>
void	setInternalData (T *Pointer, size_t ActualLengthCPU, size_t NumberOfComponents, size_t SizeX, size_t SizeY=1, size_t SizeZ=1)
Private Attributes
size_t	mActualLengthCPU
ArrayDataType	mArrayDataType
ElementDataType	mElementDataType
bool	mIsArray
size_t	mNumberOfComponents
void *	mPointer
size_t	mSizeX
size_t	mSizeY
size_t	mSizeZ
size_t	mTypeSize
ValueType	mValueType