berrySmartPointer.h

Go to the documentation of this file.

/*============================================================================
 
The Medical Imaging Interaction Toolkit (MITK)
 
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
 
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
 
============================================================================*/
 
#ifndef BERRYSMARTPOINTER_H_
#define BERRYSMARTPOINTER_H_
 
#include <iostream>
#include <stdexcept>
 
#include <org_blueberry_core_runtime_Export.h>
 
#include <berryConfig.h>
 
#include <Poco/Bugcheck.h>
 
#if defined(BLUEBERRY_DEBUG_SMARTPOINTER)
#include <QMutex>
#endif
 
namespace berry
{
 
template<class T> class WeakPointer;
 
template<class TObjectType>
class SmartPointer
{
public:
  typedef TObjectType ObjectType;
  typedef SmartPointer Self;
 
  SmartPointer() :
    m_Pointer(nullptr)
  {
#if defined(BLUEBERRY_DEBUG_SMARTPOINTER)
    DebugInitSmartPointer();
#endif
 
  }
 
  explicit SmartPointer(ObjectType *p) :
    m_Pointer(p)
  {
    if (m_Pointer)
      this->Register();
 
#if defined(BLUEBERRY_DEBUG_SMARTPOINTER)
    DebugInitSmartPointer();
#endif
  }
 
  SmartPointer(const SmartPointer<ObjectType> &p) :
    m_Pointer(p.m_Pointer)
  {
    this->Register();
 
#if defined(BLUEBERRY_DEBUG_SMARTPOINTER)
    DebugInitSmartPointer();
#endif
  }
 
  template<class Other>
  SmartPointer(const SmartPointer<Other>& ptr) :
    m_Pointer(const_cast<Other*> (ptr.GetPointer()))
  {
    if (m_Pointer)
      this->Register();
 
#if defined(BLUEBERRY_DEBUG_SMARTPOINTER)
    DebugInitSmartPointer();
#endif
  }
 
  template<class Other>
  explicit SmartPointer(const WeakPointer<Other>& wp);
 
  ~SmartPointer()
  {
#if defined(BLUEBERRY_DEBUG_SMARTPOINTER)
    if (m_Pointer) DebugRemoveSmartPointer();
#endif
 
    this->UnRegister();
    m_Pointer = nullptr;
  }
 
  template<class Other>
  SmartPointer<Other> Cast() const
  {
    Other* pOther = dynamic_cast<Other*> (m_Pointer);
    return SmartPointer<Other> (pOther);
  }
 
  ObjectType *operator ->() const
  {
    return m_Pointer;
  }
 
//  /** Return pointer to object.  */
//  operator ObjectType *() const
//  {
//    return m_Pointer;
//  }
 
  ObjectType & operator*() const
  {
    poco_assert( m_Pointer != nullptr );
    return *m_Pointer;
  }
 
  bool IsNotNull() const
  {
    return m_Pointer != nullptr;
  }
  bool IsNull() const
  {
    return m_Pointer == nullptr;
  }
 
  typedef ObjectType * Self::*unspecified_bool_type;
 
  operator unspecified_bool_type () const
  {
    return m_Pointer == nullptr ? nullptr: &Self::m_Pointer;
  }
 
  template<typename R>
  bool operator ==(const R* o) const
  {
    return (m_Pointer == nullptr ? o == nullptr : (o && m_Pointer->operator==(o)));
  }
 
  template<typename R>
  bool operator ==(const SmartPointer<R>& r) const
  {
    const R* o = r.GetPointer();
    return (m_Pointer == nullptr ? o == nullptr : (o && m_Pointer->operator==(o)));
  }
 
  bool operator ==(int r) const
  {
    if (r == 0)
      return m_Pointer == nullptr;
 
    throw std::invalid_argument("Can only compare to 0");
  }
 
  template<typename R>
  bool operator !=(const R* r) const
  {
    return !(this->operator==(r));
  }
 
  template<typename R>
  bool operator !=(const SmartPointer<R>& r) const
  {
    return !(this->operator==(r));
  }
 
  bool operator !=(int r) const
  {
    if (r == 0)
      return m_Pointer != nullptr;
 
    throw std::invalid_argument("Can only compare to 0");
  }
 
//  /** Template comparison operators using operator==. */
//  template<typename R>
//  bool CompareTo(const SmartPointer<R>& r) const
//  {
//    return m_Pointer == 0 ? r == 0 : r.GetPointer() && m_Pointer->operator==(r.GetPointer());
//  }
 
//  template<typename R>
//  bool CompareTo(R r) const
//  {
//    //const ObjectType* o = static_cast<const ObjectType*> (r);
//    return m_Pointer == 0 ? r == 0 : (r && m_Pointer->operator==(r));
//  }
 
  ObjectType *GetPointer() const
  {
    return m_Pointer;
  }
 
  template<typename R>
  bool operator <(const SmartPointer<R>& r) const
  {
    const R* o = r.GetPointer();
    return m_Pointer == nullptr ? o == nullptr : o && m_Pointer->operator<(o);
  }
 
  template<typename R>
  bool operator>(const SmartPointer<R>& r) const
  {
    const R* o = r.GetPointer();
    return m_Pointer == 0 ? o == 0 : o && m_Pointer->operator>(o);
  }
 
  template<typename R>
  bool operator <=(const SmartPointer<R>& r) const
  {
    return this->operator<(r) || this->operator==(r);
  }
 
  template<typename R>
  bool operator >=(const SmartPointer<R>& r) const
  {
    return this->operator>(r) || this->operator==(r);
  }
 
  SmartPointer &operator =(const SmartPointer &r)
  {
    return this->operator =(r.GetPointer());
  }
 
  template<typename R>
  SmartPointer &operator =(const SmartPointer<R>& r)
  {
    return this->operator =(r.GetPointer());
  }
 
  SmartPointer &operator =(ObjectType *r)
  {
    if (m_Pointer != r)
    {
#if defined(BLUEBERRY_DEBUG_SMARTPOINTER)
      DebugAssignSmartPointer(r, m_Pointer);
#endif
      ObjectType* tmp = m_Pointer; //avoid recursive unregisters by retaining temporarily
      m_Pointer = r;
      this->Register();
      if (tmp)
      {
        tmp->UnRegister();
      }
    }
    return *this;
  }
 
  QDebug Print(QDebug os) const;
 
private:
 
  ObjectType* m_Pointer;
 
  void Register()
  {
    if (m_Pointer)
    {
      m_Pointer->Register();
    }
  }
 
  void UnRegister()
  {
    if (m_Pointer)
    {
      m_Pointer->UnRegister();
    }
  }
 
#if defined(BLUEBERRY_DEBUG_SMARTPOINTER)
 
  unsigned int m_Id;
  QMutex m_Mutex;
 
  void DebugInitSmartPointer();
 
  void DebugRemoveSmartPointer();
 
  void DebugAssignSmartPointer(const ObjectType* newObject, const ObjectType* oldObject);
 
public:
 
  int GetId();
 
private:
#endif
};
 
template<typename T>
std::ostream& operator<<(std::ostream& os, const SmartPointer<T>& p)
{
  os << p->ToString().toStdString();
  return os;
}
 
} // namespace berry
 
template<class T>
uint qHash(const berry::SmartPointer<T>& sp)
{
  return sp->HashCode();
}
 
template<class T>
uint qHash(const berry::WeakPointer<T>& wp)
{
  berry::SmartPointer<T> sp(wp.Lock());
  if (sp.IsNull())
  {
    return 0;
  }
  return sp->HashCode();
}
 
#include "berryException.h"
#include <QDebug>
 
namespace berry {
 
template<class T>
template<class Other>
SmartPointer<T>::SmartPointer(const WeakPointer<Other>& wp)
{
  if (wp.m_Pointer)
  {
    this->m_Pointer = wp.m_Pointer;
    this->Register();
 
    #if defined(BLUEBERRY_DEBUG_SMARTPOINTER)
      DebugInitSmartPointer();
    #endif
  }
  else
  {
    throw BadWeakPointerException("Weak pointer is nullptr");
  }
}
 
template<class T>
QDebug SmartPointer<T>::Print(QDebug os) const
{
  // This prints the object pointed to by the pointer
  (*m_Pointer).Print(os);
  return os;
}
 
}
 
#if defined(BLUEBERRY_DEBUG_SMARTPOINTER)
 
#include "berryDebugUtil.h"
 
namespace berry {
 
template<class T>
void SmartPointer<T>::DebugInitSmartPointer()
{
  {
    QMutexLocker lock(&m_Mutex);
    if (m_Pointer)
    {
      unsigned int& counter = DebugUtil::GetSmartPointerCounter();
      m_Id = ++counter;
      DebugUtil::RegisterSmartPointer(m_Id, m_Pointer);
    }
    else m_Id = 0;
  }
 
  //if (DebugUtil::GetSmartPointerCounter() == Platform::GetConfiguration().getInt(Platform::DEBUG_ARG_SMARTPOINTER_ID))
  //throw 1;
}
 
template<class T>
void SmartPointer<T>::DebugRemoveSmartPointer()
{
  QMutexLocker lock(&m_Mutex);
  DebugUtil::UnregisterSmartPointer(m_Id, m_Pointer);
}
 
template<class T>
void SmartPointer<T>::DebugAssignSmartPointer(const ObjectType* newObject, const ObjectType* oldObject)
{
  QMutexLocker lock(&m_Mutex);
  if (oldObject)
    DebugUtil::UnregisterSmartPointer(m_Id, oldObject);
 
  if (newObject)
  {
    if (m_Id < 1)
    {
      unsigned int& counter = DebugUtil::GetSmartPointerCounter();
      m_Id = ++counter;
    }
    DebugUtil::RegisterSmartPointer(m_Id, newObject);
  }
}
 
template<class T>
int SmartPointer<T>::GetId()
{
  return m_Id;
}
 
}
 
#endif
 
#endif /*BERRYSMARTPOINTER_H_*/