data.h

Go to the documentation of this file.
00001 /***************************************************************************
00002  *   Copyright (C) 2008 by Kutumov Alexey                                  *
00003  *   ru.pixel@gmail.com                                                    *
00004  *                                                                         *
00005  *   This program is free software; you can redistribute it and/or modify  *
00006  *   it under the terms of the GNU General Public License as published by  *
00007  *   the Free Software Foundation; either version 2 of the License, or     *
00008  *   (at your option) any later version.                                   *
00009  *                                                                         *
00010  *   This program is distributed in the hope that it will be useful,       *
00011  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
00012  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
00013  *   GNU General Public License for more details.                          *
00014  *                                                                         *
00015  *   You should have received a copy of the GNU General Public License     *
00016  *   along with this program; if not, write to the                         *
00017  *   Free Software Foundation, Inc.,                                       *
00018  *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
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 /*ADataType*/, T * /*Pointer*/, size_t /*ActualLengthCPU*/,
00166     size_t /*NumberOfComponents*/, size_t /*SizeX*/, size_t /*SizeY = 0*/, size_t /*SizeZ = 0*/)
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 /*EDataType*/, T * /*Pointer*/, size_t /*ActualLengthCPU*/,
00199     size_t /*SizeX*/, size_t /*SizeY*/)
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

Generated on Thu Mar 5 22:36:42 2009 for gpucalc by  doxygen 1.5.6