mitkWeakPointer.h

Go to the documentation of this file.

/*=========================================================================

Program:   Medical Imaging & Interaction Toolkit
Language:  C++
Date:      $Date$
Version:   $Revision: 14123 $

Copyright (c) German Cancer Research Center, Division of Medical and
Biological Informatics. All rights reserved.
See MITKCopyright.txt or https://www.mitk.org/copyright.html for details.

This software is distributed WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE.  See the above copyright notices for more information.

=========================================================================*/

#ifndef __mitkWeakPointer_h
#define __mitkWeakPointer_h

#include "mitkCommon.h"
#include "mitkMessage.h"

#include <itkCommand.h>
#include <iostream>

namespace mitk
{

template <class TObjectType>
class WeakPointer
{
public:
  typedef TObjectType ObjectType;

  typedef Message1<const itk::Object*> itkObjectEvent;
  //##Documentation
  //## @brief AddEvent is emitted when the object pointed to gets deleted
  itkObjectEvent ObjectDelete;

  //##Documentation
  //## @brief AddEvent is emitted when the object pointed to gets modified
  itkObjectEvent ObjectModified;

  WeakPointer ()
    : m_DeleteObserverTag(-1)
    , m_ModifiedObserverTag(-1)
    , m_Pointer(0)
  {
  }

  WeakPointer (const WeakPointer<ObjectType> &p)
    : m_DeleteObserverTag(-1)
    , m_ModifiedObserverTag(-1)
    , m_Pointer(p.m_Pointer)
  {
    this->AddDeleteAndModifiedObserver();
  }

  WeakPointer (ObjectType *p)
    : m_DeleteObserverTag(-1),
      m_ModifiedObserverTag(-1),
      m_Pointer(p) 
  {
    this->AddDeleteAndModifiedObserver();
  }

  ~WeakPointer ()
  { 
    this->RemoveDeleteAndModifiedObserver();

    m_Pointer = 0; 
  }

  ObjectType *operator -> () const
    { return m_Pointer; }

  operator ObjectType * () const
    { return m_Pointer; }

  template <typename R>
  bool operator == (R r) const
    {
    return (m_Pointer == (ObjectType*)r);
    }
  template <typename R>
  bool operator != (R r) const
    {
    return (m_Pointer != (ObjectType*)r);
    }

  ObjectType *GetPointer () const
    { return m_Pointer; }

  bool operator < (const WeakPointer &r) const
    { return (void*)m_Pointer < (void*) r.m_Pointer; }

  bool operator > (const WeakPointer &r) const
    { return (void*)m_Pointer > (void*) r.m_Pointer; }

  bool operator <= (const WeakPointer &r) const
    { return (void*)m_Pointer <= (void*) r.m_Pointer; }

  bool operator >= (const WeakPointer &r) const
    { return (void*)m_Pointer >= (void*) r.m_Pointer; }

  bool IsNotNull() const
  { return m_Pointer != 0; }
  bool IsNull() const
  { return m_Pointer == 0; }

  WeakPointer &operator = (const WeakPointer &r)
    { return this->operator = (r.GetPointer()); }

  WeakPointer &operator = (ObjectType *r)
  {
    this->RemoveDeleteAndModifiedObserver();
    m_Pointer = r;
    this->AddDeleteAndModifiedObserver();
    return *this;
  }

  ObjectType *Print (std::ostream& os) const
  {
  // This prints the object pointed to by the pointer
  (*m_Pointer).Print(os);
  return m_Pointer;
  }

  void OnObjectDelete( const itk::Object *caller, const itk::EventObject & )
  {
    // do not unsubscribe from this object. this would invalidate the iterator of the
    // event listener vector (in itk::Object) and would lead to a crash
    // instead: do nothing->object is going to be dead soon...
    //this->RemoveDeleteAndModifiedObserver();
    m_Pointer = 0;
    m_DeleteObserverTag = -1;
    m_ModifiedObserverTag = -1;
    ObjectDelete.Send(caller);

  }

  void OnObjectModified( const itk::Object *caller, const itk::EventObject & )
  {
    ObjectModified.Send(caller);
  }

private:
  void AddDeleteAndModifiedObserver()
  {
    if(m_DeleteObserverTag == -1 && m_ModifiedObserverTag == -1 && m_Pointer != 0)
    {
      // add observer for delete event
      typename itk::MemberCommand<WeakPointer<TObjectType> >::Pointer onObjectDelete =
        itk::MemberCommand<WeakPointer<TObjectType> >::New();

      onObjectDelete->SetCallbackFunction(this, &WeakPointer<TObjectType>::OnObjectDelete);
      m_DeleteObserverTag = m_Pointer->AddObserver(itk::DeleteEvent(), onObjectDelete);

      // add observer for modified event
      typename itk::MemberCommand<WeakPointer<TObjectType> >::Pointer onObjectModified =
        itk::MemberCommand<WeakPointer<TObjectType> >::New();

      onObjectModified->SetCallbackFunction(this, &WeakPointer<TObjectType>::OnObjectModified);
      m_ModifiedObserverTag = m_Pointer->AddObserver(itk::ModifiedEvent(), onObjectModified);
    }
  }

  void RemoveDeleteAndModifiedObserver()
  {
    if(m_DeleteObserverTag >= 0 && m_ModifiedObserverTag >= 0 && m_Pointer != 0)
    {      
      m_Pointer->RemoveObserver(m_DeleteObserverTag);
      m_Pointer->RemoveObserver(m_ModifiedObserverTag);

      m_DeleteObserverTag = -1;
      m_ModifiedObserverTag = -1;
    }
  }

  long m_DeleteObserverTag;
  long m_ModifiedObserverTag;

  ObjectType* m_Pointer;
};


template <typename T>
std::ostream& operator<< (std::ostream& os, WeakPointer<T> p)
{
  p.Print(os);
  return os;
}

} // end namespace mitk

#endif