SmartPtr.hpp

Go to the documentation of this file.

/*
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 */
#ifndef SMARTPTR_HPP_
#define SMARTPTR_HPP_

#include <helpers/Log.hpp>

namespace OpenAB {
template<typename __C>
class SmartPtr
{
  public:
    SmartPtr()
        : ptr(0),
          refCount(0)
    {
      refCount = new unsigned int;
      *refCount = 1;
    }

    SmartPtr(__C* p) :
    ptr(p),
    refCount(0)
    {
      refCount = new unsigned int;
      *refCount = 1;
    }

    SmartPtr(const SmartPtr& other) :
    ptr(other.ptr),
    refCount(other.refCount)
    {
      (*refCount)++;
    }

    ~SmartPtr()
    {
      (*refCount)--;
      if(*refCount == 0)
      {
        delete refCount;
        if (ptr)
          delete ptr;
      }
    }

    SmartPtr& operator=(const SmartPtr& other)
    {
      if (this != &other)
      {
        (*refCount)--;
        if(*refCount == 0)
        {
          delete refCount;
          if (ptr)
            delete ptr;
        }

        ptr = other.ptr;
        refCount = other.refCount;
        (*refCount)++;
      }
      return *this;
    }

    bool operator==(const SmartPtr& other) const
    {
      if (NULL == ptr || NULL == other.ptr)
      {
        if (NULL == ptr && NULL == other.ptr)
        {
          return true;
        }
        return false;
      }
      return ((*ptr) == (*other.ptr));
    }

    bool operator!=(const SmartPtr& other) const
    {
      if (NULL == ptr || NULL == other.ptr)
      {
        if (NULL == ptr && NULL == other.ptr)
        {
          return false;
        }
        return true;
      }
      return ((*ptr) != (*other.ptr));
    }

    bool operator<(const SmartPtr& other) const
    {
      if (NULL == ptr || NULL == other.ptr)
      {
        if (NULL == ptr && NULL == other.ptr)
        {
          return false;
        }
        if(!ptr)
        {
          return true;
        }
        else
        {
          return false;
        }
      }
      return ((*ptr) < (*other.ptr));
    }

    __C* operator->() const {return ptr;}
    __C& operator*() const {return *ptr;}
    __C* getPointer() const {return ptr;}

    operator __C*() const {return ptr;}
    operator const __C*() const {return (const __C*) ptr;}
   // operator __C() {return *ptr;}

  private:
    __C* ptr;
    unsigned int* refCount;
};

} // namespace OpenAB

#endif // SMARTPTR_HPP_