observer_ptr.h

Go to the documentation of this file.

/*
Copyright 2007-2025. Algoryx Simulation AB.
 
All AGX source code, intellectual property, documentation, sample code,
tutorials, scene files and technical white papers, are copyrighted, proprietary
and confidential material of Algoryx Simulation AB. You may not download, read,
store, distribute, publish, copy or otherwise disseminate, use or expose this
material unless having a written signed agreement with Algoryx Simulation AB, or having been
advised so by Algoryx Simulation AB for a time limited evaluation, or having purchased a
valid commercial license from Algoryx Simulation AB.
 
Algoryx Simulation AB disclaims all responsibilities for loss or damage caused
from using this software, unless otherwise stated in written agreements with
Algoryx Simulation AB.
*/
 
#ifndef AGX_OBSERVER_PTR
#define AGX_OBSERVER_PTR
 
#include <agx/macros.h>
#include <agx/hash.h>
 
namespace agx
{
 
  DOXYGEN_START_INTERNAL_BLOCK()
 
 
  class Observer
  {
    public:
      virtual ~Observer() {}
      virtual void objectDeleted(void*) {}
  };
 
  DOXYGEN_END_INTERNAL_BLOCK()
 
  
 
 
  template<class T>
  class observer_ptr : public Observer
  {
    public:
 
      typedef T element_type;
 
      observer_ptr();
 
      observer_ptr(T* t);
 
      observer_ptr(const observer_ptr& rp);
 
      virtual ~observer_ptr();
 
      observer_ptr& operator = (const observer_ptr& rp);
 
      observer_ptr& operator = (T* ptr);
 
      virtual void objectDeleted(void*);
 
      operator T* () const;
 
      template <typename U>
      bool operator == (observer_ptr<U> const& rp) const;
 
      template <typename U>
      bool operator != (observer_ptr<U> const& rp) const;
 
      template <typename U>
      bool operator == (U const* p) const;
 
      template <typename U>
      bool operator != (U const* p) const;
 
      template <typename U>
      bool operator == (U* p) const;
 
      template <typename U>
      bool operator != (U* p) const;
 
      bool operator < (const observer_ptr& rp) const;
 
      T& operator*() const;
 
      T* operator->() const;
 
      T* get() const;
 
      bool operator!() const;
 
      bool isValid() const;
 
    private:
      T* m_ptr;
  };
 
  template<typename T>
  AGX_FORCE_INLINE observer_ptr<T>::observer_ptr() : m_ptr(nullptr)
  {
 
  }
 
  template<typename T>
  AGX_FORCE_INLINE observer_ptr<T>::observer_ptr(T* t): m_ptr(t)
  {
    if (m_ptr) m_ptr->addObserver(this);
  }
 
  template<typename T>
  AGX_FORCE_INLINE observer_ptr<T>::observer_ptr(const observer_ptr<T>& rp): Observer(), m_ptr(rp.m_ptr)
  {
    if (m_ptr) m_ptr->addObserver(this);
  }
 
  template<typename T>
  AGX_FORCE_INLINE observer_ptr<T>::~observer_ptr()
  {
    if (m_ptr) m_ptr->removeObserver(this);
    m_ptr = 0;
 
  }
 
  template<typename T>
  AGX_FORCE_INLINE observer_ptr<T>& observer_ptr<T>::operator = (const observer_ptr<T>& rp)
  {
    if (m_ptr == rp.m_ptr) return *this;
    if (m_ptr) m_ptr->removeObserver(this);
 
    m_ptr = rp.m_ptr;
    if (m_ptr) m_ptr->addObserver(this);
    return *this;
  }
 
  template<typename T>
  AGX_FORCE_INLINE observer_ptr<T>& observer_ptr<T>::operator = (T* ptr)
  {
    if (m_ptr == ptr) return *this;
    if (m_ptr) m_ptr->removeObserver(this);
 
    m_ptr = ptr;
    if (m_ptr) m_ptr->addObserver(this);
 
    return *this;
  }
 
  template<typename T>
  void observer_ptr<T>::objectDeleted(void*)
  {
    m_ptr = 0;
  }
 
#if 0 // Disable any hashing on observer_pointer, it can only be bad
  // Hash function
  template<typename T>
  struct HashFn< observer_ptr<T> >
  {
    AGX_FORCE_INLINE UInt32 operator()(const observer_ptr<T>& key) const
    {
      return agx::hash(key.get());
    }
 
    typedef const T *PtrT;
    AGX_FORCE_INLINE UInt32 operator()(const PtrT key) const
    {
      return agx::hash(key);
    }
  };
#endif
 
  template<typename T>
  AGX_FORCE_INLINE observer_ptr<T>::operator T* () const
  {
    return m_ptr;
  }
 
  template<typename T>
  template <typename U>
  AGX_FORCE_INLINE bool observer_ptr<T>::operator == (observer_ptr<U> const& rp) const
  {
    return m_ptr == rp.m_ptr;
  }
 
  template<typename T>
  template <typename U>
  AGX_FORCE_INLINE bool observer_ptr<T>::operator != (observer_ptr<U> const& rp) const
  {
    return m_ptr != rp.m_ptr;
  }
 
  template<typename T>
  template <typename U>
  AGX_FORCE_INLINE bool observer_ptr<T>::operator == (U const* p) const
  {
    return m_ptr == p;
  }
 
  template<typename T>
  template <typename U>
  AGX_FORCE_INLINE bool observer_ptr<T>::operator != (U const* p) const
  {
    return m_ptr != p;
  }
 
  template<typename T>
  template <typename U>
  AGX_FORCE_INLINE bool observer_ptr<T>::operator == (U* p) const
  {
    return m_ptr == p;
  }
 
  template<typename T>
  template <typename U>
  AGX_FORCE_INLINE bool observer_ptr<T>::operator != (U* p) const
  {
    return m_ptr != p;
  }
 
  template<typename T>
  AGX_FORCE_INLINE bool observer_ptr<T>::operator < (const observer_ptr& rp) const
  {
    return (m_ptr < rp.m_ptr);
  }
 
  template<typename T>
  AGX_FORCE_INLINE T& observer_ptr<T>::operator*() const
  {
    return *m_ptr;
  }
 
  template<typename T>
  AGX_FORCE_INLINE T* observer_ptr<T>::operator->() const
  {
    return m_ptr;
  }
 
  template<typename T>
  AGX_FORCE_INLINE T* observer_ptr<T>::get() const
  {
    return m_ptr;
  }
 
  template<typename T>
  AGX_FORCE_INLINE bool observer_ptr<T>::operator!() const
  {
    return m_ptr == 0;  // not required
  }
 
  template<typename T>
  AGX_FORCE_INLINE bool observer_ptr<T>::isValid() const
  {
    return m_ptr != 0;
  }
 
 
 
}
 
#endif