ConstExplicitlySharedDataPointer.h

#ifndef _KNOW_CORE_CONSTEXPLICITLYSHAREDDATAPOINTER_H_
#define _KNOW_CORE_CONSTEXPLICITLYSHAREDDATAPOINTER_H_
 
#include <QSharedDataPointer>
 
namespace knowCore
{
  template <class T>
  class ConstExplicitlySharedDataPointer
  {
  public:
    typedef T Type;
    typedef T* pointer;
    
    inline const T& operator*() const
    {
      return *d;
    }
    inline const T* operator->() const
    {
      return d;
    }
    inline operator bool() const
    {
      return d;
    }
    inline const T* data() const
    {
      return d;
    }
    inline const T* constData() const
    {
      return d;
    }
    
    inline bool operator==(const ConstExplicitlySharedDataPointer<T>& other) const
    {
      return d == other.d;
    }
    inline bool operator!=(const ConstExplicitlySharedDataPointer<T>& other) const
    {
      return d != other.d;
    }
    
    inline ConstExplicitlySharedDataPointer()
    {
      d = 0;
    }
    inline ~ConstExplicitlySharedDataPointer()
    {
      if(d && !d->ref.deref())
      {
        delete d;
      }
    }
    
    inline ConstExplicitlySharedDataPointer(const T* data) : d(const_cast<T*>(data))
    {
      if(d)
      {
        d->ref.ref();
      }
    }
    inline ConstExplicitlySharedDataPointer(const ConstExplicitlySharedDataPointer& o) : d(o.d)
    {
      if(d)
      {
        d->ref.ref();
      }
    }
    template<typename _T2_, std::enable_if_t<std::is_convertible_v<_T2_*, T*>, int> = 0>
    inline ConstExplicitlySharedDataPointer(const ConstExplicitlySharedDataPointer<_T2_>& o) : d(const_cast<_T2_*>(o.data()))
    {
      if(d)
      {
        d->ref.ref();
      }
    }
    inline ConstExplicitlySharedDataPointer(const QExplicitlySharedDataPointer<T>& o) : d(const_cast<T*>(o.data()))
    {
      if(d)
      {
        d->ref.ref();
      }
    }
    inline ConstExplicitlySharedDataPointer<T>& operator=(const ConstExplicitlySharedDataPointer<T>& o)
    {
      if(o.d != d)
      {
        if(o.d)
        {
          o.d->ref.ref();
        }
        
        if(d && !d->ref.deref())
        {
          delete d;
        }
        
        d = o.d;
      }
      
      return *this;
    }
    inline ConstExplicitlySharedDataPointer& operator=(T* o)
    {
      if(o != d)
      {
        if(o)
        {
          o->ref.ref();
        }
        
        if(d && !d->ref.deref())
        {
          delete d;
        }
        
        d = o;
      }
      
      return *this;
    }
    template<typename _T2_>
    inline std::enable_if_t<std::is_convertible_v<_T2_*, T*>, ConstExplicitlySharedDataPointer<_T2_>> d_cast() const
    {
      return ConstExplicitlySharedDataPointer<_T2_>(dynamic_cast<_T2_*>(d));
    }
    template<typename _T2_>
    inline std::enable_if_t<std::is_convertible_v<_T2_*, T*>, ConstExplicitlySharedDataPointer<_T2_>> s_cast() const
    {
      return ConstExplicitlySharedDataPointer<_T2_>(static_cast<_T2_*>(d));
    }
    
    inline bool operator!() const
    {
      return !d;
    }
    
    inline void swap(ConstExplicitlySharedDataPointer& other)
    {
      qSwap(d, other.d);
    }
    
  private:
    T* d;
  };
  
}
 
#endif