mitkWeakPointer.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 mitkWeakPointer_h
#define mitkWeakPointer_h
 
#include <itkCommand.h>
#include <compare>
#include <functional>
 
namespace mitk
{
  template <class T>
  class WeakPointer final
  {
  public:
    using DeleteEventCallbackType = std::function<void ()>;
 
    WeakPointer() noexcept
      : m_RawPointer(nullptr)
    {
    }
 
    WeakPointer(T *rawPointer)
      : m_RawPointer(rawPointer)
    {
      this->AddDeleteEventObserver();
    }
 
    WeakPointer(const WeakPointer &other)
      : m_RawPointer(other.m_RawPointer)
    {
      this->AddDeleteEventObserver();
    }
 
    WeakPointer(WeakPointer &&other)
      : m_RawPointer(other.m_RawPointer)
    {
      other.RemoveDeleteEventObserver();
      other.m_RawPointer = nullptr;
      this->AddDeleteEventObserver();
    }
 
    ~WeakPointer() noexcept
    {
      try
      {
        this->RemoveDeleteEventObserver();
      }
      catch (...)
      {
        // Swallow. Otherwise, the application would terminate if another
        // exception is already propagating.
      }
    }
 
    WeakPointer & operator =(const WeakPointer &other)
    {
      if (this != &other)
      {
        this->RemoveDeleteEventObserver();
        m_RawPointer = other.m_RawPointer;
        this->AddDeleteEventObserver();
      }
 
      return *this;
    }
 
    WeakPointer & operator =(WeakPointer &&other)
    {
      // No check for self-assignment as it is allowed to assume that the
      // parameter is a unique reference to this argument.
 
      this->RemoveDeleteEventObserver();
      m_RawPointer = other.m_RawPointer;
      other.m_RawPointer = nullptr;
      this->AddDeleteEventObserver();
 
      return *this;
    }
 
    WeakPointer & operator =(std::nullptr_t)
    {
      this->RemoveDeleteEventObserver();
      m_RawPointer = nullptr;
 
      return *this;
    }
 
    WeakPointer & operator =(T *other)
    {
      if (m_RawPointer != other)
      {
        this->RemoveDeleteEventObserver();
        m_RawPointer = other;
        this->AddDeleteEventObserver();
      }
 
      return *this;
    }
 
    explicit operator bool() const noexcept
    {
      return nullptr != m_RawPointer;
    }
 
    bool IsExpired() const noexcept
    {
      return !*this;
    }
 
    itk::SmartPointer<T> Lock() const
    {
      return m_RawPointer;
    }
 
    void SetDeleteEventCallback(const DeleteEventCallbackType &callback)
    {
      m_DeleteEventCallback = callback;
    }
 
  private:
    void AddDeleteEventObserver()
    {
      if (nullptr != m_RawPointer)
      {
        auto command = itk::SimpleMemberCommand<WeakPointer>::New();
        command->SetCallbackFunction(this, &WeakPointer::OnDeleteEvent);
 
        using TWithoutConst = typename std::remove_const_t<T>;
        //cast the pointer to non const before adding the observer. This is done to ensure that
        //weak pointer also supports const pointers.
        auto nonConstPointer = const_cast<TWithoutConst*>(m_RawPointer);
        m_ObserverTag = nonConstPointer->AddObserver(itk::DeleteEvent(), command);
      }
    }
 
    void RemoveDeleteEventObserver()
    {
      if (nullptr != m_RawPointer)
      {
        using TWithoutConst = typename std::remove_const_t<T>;
        //cast the pointer to non const before removing the observer. This is done to ensure that
        //weak pointer also supports const pointers.
        auto nonConstPointer = const_cast<TWithoutConst*>(m_RawPointer);
        nonConstPointer->RemoveObserver(m_ObserverTag);
      }
    }
 
    void OnDeleteEvent() noexcept
    {
      // Don't remove any observers from the observed object as it is about to
      // die and can't handle this operation anymore.
 
      m_RawPointer = nullptr;
 
      if (m_DeleteEventCallback)
        m_DeleteEventCallback();
    }
 
    // In C++20, operator== and operator<=> generate all comparison operators
    // (!=, <, >, <=, >=) and their reversed-argument forms automatically.
    // This also covers comparisons to T::Pointer and T::ConstPointer as
    // itk::SmartPointer can be implicitly converted to a raw pointer.
 
    friend bool operator ==(const WeakPointer &left, const WeakPointer &right) noexcept
    {
      return left.m_RawPointer == right.m_RawPointer;
    }
 
    friend std::strong_ordering operator <=>(const WeakPointer &left, const WeakPointer &right) noexcept
    {
      return std::compare_three_way()(left.m_RawPointer, right.m_RawPointer);
    }
 
    friend bool operator ==(const WeakPointer &left, const T *right) noexcept
    {
      return left.m_RawPointer == right;
    }
 
    friend std::strong_ordering operator <=>(const WeakPointer &left, const T *right) noexcept
    {
      return std::compare_three_way()(left.m_RawPointer, right);
    }
 
    T *m_RawPointer;
 
    // m_ObserverTag is completely managed by the two methods
    // AddDeleteEventObserver() and RemoveDeleteEventObserver(). There
    // isn't any need to initialize or use it at all outside of these methods.
    unsigned long m_ObserverTag;
 
    DeleteEventCallbackType m_DeleteEventCallback;
  };
}
 
#endif