object.h

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2008 by Kutumov Alexey                                  *
 *   ru.pixel@gmail.com                                                    *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/

#ifndef __object__header__
#define __object__header__

#include "gpucalc/prerequisites.h"
#include "gpucalc/exception.h"

namespace gpucalc
{
#define OBJ_DISABLE_COPY(class_name)  class_name(const class_name &); class_name & operator = (const class_name &);

 
 
 
 
 

 class _GpuCalcExport Object
 {
  OBJ_DISABLE_COPY(Object)
  
  public:
   Object(const std::string & ClassName, const std::string & ObjectName): mClassName(ClassName), mObjectName(ObjectName), mSpecificParameters(),
    mIsLocked(false)
   {
   }


   virtual ~Object()
   {
    /*for (SpecificParametersMap::iterator i = mSpecificParameters.begin(); i != mSpecificParameters.end(); ++i)
    {
     free(i->second.Pointer);
    }
    */
   }


   const std::string & getClassName() const
   {
    return mClassName;
   }


   const std::string & getObjectName() const
   {
    return mObjectName;
   }


   bool isLocked() const
   {
    return mIsLocked;
   }


   void getSpecificParameter(const std::string & ParameterName, void * ParameterValue)
   {
    SpecificParametersMap::iterator i = mSpecificParameters.find(ParameterName);
    if (i != mSpecificParameters.end())
    {
     i->second.copyValue(ParameterValue);
    }
    else
    {
     Except<ERR_ITEM_NOT_FOUND>(this, "Parameter \"" + ParameterName + "\" does not exists.", "Object::getSpecificParameter()", __FILE__, __LINE__);
    }
   }


  private:
   std::string mClassName;
   std::string mObjectName;


   class Any
   {
    public:
     Any(): mPointer(0), mSize(0), mUseCount(0)
     {
     }


     Any(size_t size): mPointer(0), mSize(size),mUseCount(0)
     {
      mPointer = malloc(size);
      mUseCount = new size_t(1);
     }


     Any(void * from, size_t size): mSize(size)
     {
      mPointer = malloc(size);
      memcpy(mPointer, from, size);
      mUseCount = new size_t(1);
     }


     Any(const Any & any): mPointer(any.mPointer), mSize(any.mSize), mUseCount(any.mUseCount)
     {
      if (mUseCount)
      {
       ++(*mUseCount);
      }
     }


     Any & operator = (const Any & any)
     {
      if (mPointer == any.mPointer)
      {
       return *this;
      }
      else
      {
       Any tmp(any);
       swap(tmp);
       return *this;
      }
     }


     ~Any()
     {
      release();
     }


     void copyValue(void * To)
     {
      memcpy(To, mPointer, mSize);
     }


    private:
     void * mPointer;
     size_t mSize;
     size_t * mUseCount;


     void release()
     {
      if (mUseCount)
      {
       if (--(*mUseCount) == 0)
       {
        destroy();
       }
      }

     }


     void destroy()
     {
      free(mPointer);
      mSize = 0;
      delete mUseCount;
     }


     void swap(Any & other)
     {
      std::swap(mPointer, other.mPointer);
      std::swap(mSize, other.mSize);
      std::swap(mUseCount, other.mUseCount);
     }

   };


   typedef std::map<std::string, Any> SpecificParametersMap;
   SpecificParametersMap mSpecificParameters;


   bool mIsLocked;



  protected:


   void addSpecificParameter(const std::string & ParameterName, void * ParameterValue, size_t Size)
   {
    SpecificParametersMap::iterator i = mSpecificParameters.find(ParameterName);
    if (i != mSpecificParameters.end())
    {
     mSpecificParameters.erase(i);
    }
    mSpecificParameters[ParameterName] = Any(ParameterValue, Size);
   }


   void lock()
   {
    mIsLocked = true;
   }


   void unlock()
   {
    mIsLocked = false;
   }
 };
}

#endif