00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00033 #ifndef __data__header__
00034 #define __data__header__
00035
00036 #include "gpucalc/log_manager.h"
00037
00038 namespace gpucalc
00039 {
00040
00046 enum ValueType
00047 {
00051 NOTType = 0,
00052
00056 FloatType = 1,
00057
00061 DoubleType,
00062
00066 IntType,
00067
00071 UnsignedIntType,
00072
00076 CharType,
00077
00081 UnsignedCharType
00082 };
00083
00089 enum ArrayDataType
00090 {
00094 NOTArray = 0,
00095
00102 Array1D = 1,
00103
00110 Array2D,
00111
00118 Array3D
00119 };
00120
00126 enum ElementDataType
00127 {
00131 NOTElement = 0,
00132
00133
00134 ElementNumber = 1
00135 };
00136
00137
00138 const char _DataClassName [] = "Data";
00139
00143 class _GpuCalcExport Data: public Object
00144 {
00145
00146
00147 OBJ_DISABLE_COPY(Data)
00148
00149
00150 public:
00151 Data(const std::string & DataName): 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 }
00157
00158 ~Data()
00159 {
00160 }
00161
00165 template <typename T> void createArray(ArrayDataType , T * , size_t ,
00166 size_t , size_t , size_t , size_t )
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 }
00171
00172
00173 void createArray(ArrayDataType ADataType, float * Pointer, size_t ActualLengthCPU,
00174 size_t NumberOfComponents, size_t SizeX, size_t SizeY = 0, size_t SizeZ = 0)
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 }
00183
00184
00185 void createArray(ArrayDataType ADataType, char * Pointer, size_t ActualLengthCPU,
00186 size_t NumberOfComponents, size_t SizeX, size_t SizeY = 0, size_t SizeZ = 0)
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 }
00195
00196
00197
00198 template <typename T> void createElement(ElementDataType , T * , size_t ,
00199 size_t , size_t )
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 }
00204
00205
00206 void createElement(ElementDataType EDataType, float * Pointer, size_t ActualLengthCPU,
00207 size_t SizeX, size_t SizeY)
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 }
00216
00217
00218 void createElement(ElementDataType EDataType, int * Pointer, size_t ActualLengthCPU,
00219 size_t SizeX, size_t SizeY)
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 }
00228
00229
00230
00231 ValueType getValueType() const
00232 {
00233 return mValueType;
00234 }
00235
00236 ArrayDataType getArrayDataType() const
00237 {
00238 return mArrayDataType;
00239 }
00240
00241 ElementDataType getElementDataType() const
00242 {
00243 return mElementDataType;
00244 }
00245
00246 void * pointer() const
00247 {
00248 return mPointer;
00249 }
00250
00254 size_t getActualLengthCPU() const
00255 {
00256 return mActualLengthCPU;
00257 }
00258
00259 size_t getTypeSize() const
00260 {
00261 return mTypeSize;
00262 }
00263
00264 size_t getNumberOfComponents() const
00265 {
00266 return mNumberOfComponents;
00267 }
00268
00269 size_t getSizeX() const
00270 {
00271 return mSizeX;
00272 }
00273
00274 size_t getSizeY() const
00275 {
00276 return mSizeY;
00277 }
00278
00279 size_t getSizeZ() const
00280 {
00281 return mSizeZ;
00282 }
00283
00284 bool isArray() const
00285 {
00286 return mIsArray;
00287 }
00288
00289 private:
00290
00291 bool mIsArray;
00292
00293
00294 ValueType mValueType;
00295 ArrayDataType mArrayDataType;
00296 ElementDataType mElementDataType;
00297
00298
00299 mutable void * mPointer;
00300 size_t mActualLengthCPU;
00301 size_t mTypeSize;
00302 size_t mNumberOfComponents;
00303
00304
00305 size_t mSizeX;
00306 size_t mSizeY;
00307 size_t mSizeZ;
00308
00309
00310 template <typename T> void setInternalData(T * Pointer, size_t ActualLengthCPU, size_t NumberOfComponents, size_t SizeX,
00311 size_t SizeY = 1, size_t SizeZ = 1)
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 }
00322 };
00323 }
00324 #endif