utils.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 __utils__header__
#define __utils__header__

#include "gpucalc/std_headers.h"

namespace gpucalc
{
 template <int num> struct Int2Type
 {
  enum
  {
   number = num
  };
 };


 template <class T> class SharedPtr
 {
  public:

   SharedPtr(): mPointer(0), mUseCount(0)
   {
   }


   template <class Y> explicit SharedPtr(Y * Pointer): mPointer(Pointer), mUseCount(new unsigned int(1))
   {
   }


   SharedPtr(const SharedPtr & r): mPointer(0), mUseCount(0)
   {
    mPointer = r.mPointer;
    mUseCount = r.mUseCount;
    if (mUseCount)
    {
     ++(*mUseCount);
    }
   }


   SharedPtr & operator = (const SharedPtr & r)
   {
    if (mPointer == r.mPointer)
    {
     return * this;
    }
    // Swap current data into a local copy
    // this ensures we deal with rhs and this being dependent
    SharedPtr<T> tmp(r);
    swap(tmp);
    return * this;
   }


   template <class Y> SharedPtr(const SharedPtr<Y> & r): mPointer(0), mUseCount(0)
   {
    mPointer = r.getPointer();
    mUseCount = r.useCountPointer();
    // Handle zero pointer gracefully to manage STL containers
    if (mUseCount)
    {
     ++(*mUseCount);
    }
   }


   template <class Y> SharedPtr & operator = (const SharedPtr<Y> & r)
   {
    if (mPointer == r.mPointer)
    {
     return * this;
    }
    // Swap current data into a local copy
    // this ensures we deal with rhs and this being dependent
    SharedPtr<T> tmp(r);
    swap(tmp);
    return * this;
   }


   virtual ~SharedPtr()
   {
    release();
   }


   inline T & operator * () const
   {
    assert(mPointer);
    return * mPointer;
   }


   inline T * operator -> () const
   {
    assert(mPointer);
    return mPointer;
   }


   inline T * get() const
   {
    return mPointer;
   }


   void bind(T * Pointer)
   {
    assert(!mPointer && !mUseCount);
    mUseCount = new unsigned int (1);
    mPointer = Pointer;
   }


   inline bool unique() const
   {
    assert(mUseCount);
    return * mUseCount == 1;
   }


   inline unsigned int useCount() const
   {
    assert(mUseCount);
    return * mUseCount;
   }


   inline unsigned int * useCountPointer() const
   {
    return mUseCount;
   }


   inline T * getPointer() const
   {
    return mPointer;
   }


   inline bool isNull() const
   {
    return mPointer == 0;
   }


   inline void setNull()
   {
    if (mPointer)
    {
     release();
     mPointer = 0;
     mUseCount = 0;
    }
   }


  protected:

   T * mPointer;

   unsigned int * mUseCount;


   inline void release()
   {
    bool destroyThis = false;
    if (mUseCount)
    {
     if (--(*mUseCount) == 0)
     {
      destroyThis = true;
     }
    }
    if (destroyThis)
    {
     destroy();
    }
   }


   virtual void destroy()
   {
    // IF YOU GET A CRASH HERE, YOU FORGOT TO FREE UP POINTERS
    // BEFORE SHUTTING gpucalc DOWN
    // Use setNull() before shutdown or make sure your pointer goes
    // out of scope before gpucalc shuts down to avoid this.
    delete mPointer;
    delete mUseCount;
   }


   virtual void swap(SharedPtr<T> & other)
   {
    std::swap(mPointer, other.mPointer);
    std::swap(mUseCount, other.mUseCount);
   }
 };


 template <class T, class U> inline bool operator == (SharedPtr<T> const & a, SharedPtr<U> const & b)
 {
  return a.get() == b.get();
 }


 template <class T, class U> inline bool operator != (SharedPtr<T> const & a, SharedPtr<U> const & b)
 {
  return a.get() != b.get();
 }


 template <class T, class U> inline bool operator < (SharedPtr<T> const & a, SharedPtr<U> const & b)
 {
  return std::less<const void *>()(a.get(), b.get());
 }
}


#endif