qobjectuniqueptr.h

Go to the documentation of this file.

/***************************************************************************
                                  qobjectuniqueptr.h
 
                      A unique pointer to a QObject.
 
                              -------------------
  begin                : June 2019
  copyright            : (C) 2009 by Matthias Kuhn
  email                : [email protected]
 ***************************************************************************/
 
/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/
 
#ifndef QOBJECTUNIQUEPTR_H
#define QOBJECTUNIQUEPTR_H
 
 
#include <QObject>
#include <QPointer>
#include <QtDebug>
#include <qtypeinfo.h>
 
#define SIP_NO_FILE
 
class QVariant;

template <class T>
class QObjectUniquePtr
{
    Q_STATIC_ASSERT_X( !std::is_pointer<T>::value, "QObjectUniquePtr's template type must not be a pointer type" );
 
    template<typename U>
    struct TypeSelector
    {
      typedef QObject Type;
    };
    template<typename U>
    struct TypeSelector<const U>
    {
      typedef const QObject Type;
    };
    typedef typename TypeSelector<T>::Type QObjectType;
    QPointer<QObjectType> mPtr;
  public:

    inline QObjectUniquePtr()
    { }

    inline QObjectUniquePtr( T *p ) : mPtr( p )
    { }

    ~QObjectUniquePtr()
    {
      // Will be a nullptr if the QObject has been deleted from somewhere else (e.g. through parent ownership)
      delete mPtr.data();
    }
 
    // This is a unique ptr, so copy is forbidden and we need to implement the move constructor/operator
    QObjectUniquePtr( const QObjectUniquePtr &other ) = delete;
    QObjectUniquePtr &operator=( const QObjectUniquePtr &other ) = delete;
 
    QObjectUniquePtr( QObjectUniquePtr &&other )
    {
      *this = std::move( other );
    }
 
    QObjectUniquePtr &operator=( QObjectUniquePtr &&other ) noexcept
    {
      if ( &other == this )
        return *this;
 
      delete mPtr.data();
      mPtr = other.mPtr;
      other.clear();
      return *this;
    }

    inline void swap( QObjectUniquePtr &other )
    {
      mPtr.swap( other.mPtr );
    }
 
    inline QObjectUniquePtr<T> &operator=( T *p )
    {
      mPtr.assign( static_cast<QObjectType *>( p ) );
      return *this;
    }

    inline T *data() const
    {
      return static_cast<T *>( mPtr.data() );
    }

    inline T *get() const
    {
      return static_cast<T *>( mPtr.data() );
    }

    inline T *operator->() const
    {
      return data();
    }

    inline T &operator*() const
    {
      return *data();
    }

    inline operator T *() const
    {
      return data();
    }

    inline bool isNull() const
    {
      return mPtr.isNull();
    }

    explicit inline operator bool() const
    {
      return !mPtr.isNull();
    }

    inline void clear()
    {
      mPtr.clear();
    }

    inline T *release()
    {
      T *p = qobject_cast<T *>( mPtr.data() );
      mPtr.clear();
      return p;
    }

    void reset( T *p = nullptr )
    {
      delete mPtr.data();
      mPtr = p;
    }
};
template <class T> Q_DECLARE_TYPEINFO_BODY( QObjectUniquePtr<T>, Q_MOVABLE_TYPE );
 
template <class T>
inline bool operator==( const T *o, const QObjectUniquePtr<T> &p )
{
  return o == p.operator->();
}
 
template<class T>
inline bool operator==( const QObjectUniquePtr<T> &p, const T *o )
{
  return p.operator->() == o;
}
 
template <class T>
inline bool operator==( T *o, const QObjectUniquePtr<T> &p )
{
  return o == p.operator->();
}
 
template<class T>
inline bool operator==( const QObjectUniquePtr<T> &p, T *o )
{
  return p.operator->() == o;
}
 
template<class T>
inline bool operator==( const QObjectUniquePtr<T> &p1, const QObjectUniquePtr<T> &p2 )
{
  return p1.operator->() == p2.operator->();
}
 
template <class T>
inline bool operator!=( const T *o, const QObjectUniquePtr<T> &p )
{
  return o != p.operator->();
}
 
template<class T>
inline bool operator!= ( const QObjectUniquePtr<T> &p, const T *o )
{
  return p.operator->() != o;
}
 
template <class T>
inline bool operator!=( T *o, const QObjectUniquePtr<T> &p )
{
  return o != p.operator->();
}
 
template<class T>
inline bool operator!= ( const QObjectUniquePtr<T> &p, T *o )
{
  return p.operator->() != o;
}
 
template<class T>
inline bool operator!= ( const QObjectUniquePtr<T> &p1, const QObjectUniquePtr<T> &p2 )
{
  return p1.operator->() != p2.operator->() ;
}
 
template<typename T>
QObjectUniquePtr<T>
QObjectUniquePtrFromVariant( const QVariant &variant )
{
  return QObjectUniquePtr<T>( qobject_cast<T *>( QtSharedPointer::weakPointerFromVariant_internal( variant ).toStrongRef().data() ) );
}
 
 
 

template <class T>
class QObjectParentUniquePtr
{
    Q_STATIC_ASSERT_X( !std::is_pointer<T>::value, "QObjectParentUniquePtr's template object type must not be a pointer type" );
 
    T *mChild = nullptr;
 
    QPointer<QObject> mParent;
    QMetaObject::Connection mParentDestroyedConnection;
 
  public:

    inline QObjectParentUniquePtr()
    { }

    inline QObjectParentUniquePtr( T *child, QObject *parent )
      : mChild( child )
    {
      if ( parent )
      {
        setParentOwner( parent );
      }
    }
    // compiler-generated copy/move ctor/assignment operators are fine!

    ~QObjectParentUniquePtr()
    {
      if ( mParent )
      {
        QObject::disconnect( mParentDestroyedConnection );
        mParent = nullptr;
      }
      if ( mChild )
      {
        // child is being deleted BEFORE parent, so we are responsible for deleting it
        delete mChild;
        mChild = nullptr;
      }
    }

    inline void setParentOwner( QObject *parent )
    {
      if ( mParent )
      {
        QObject::disconnect( mParentDestroyedConnection );
      }
      mParentDestroyedConnection = QObject::connect( parent, &QObject::destroyed, parent, [this]()
      {
        mParent = nullptr;
        // parent is being deleted BEFORE child, so it is responsible for deleting the child -- we don't need to delete it here!
        mChild = nullptr;
      } );
      mParent = parent;
    }

    inline QObjectParentUniquePtr<T> &operator=( T *child )
    {
      if ( child && !mParent )
      {
        qWarning() << "Assigning pointer to QObjectParentUniquePtr with nullptr parent.";
      }
      delete mChild;
      mChild = child;
      return *this;
    }

    inline T *data() const
    {
      return static_cast<T *>( mChild );
    }

    inline T *get() const
    {
      return static_cast<T *>( mChild );
    }

    inline T *operator->() const
    {
      return data();
    }

    inline T &operator*() const
    {
      return *data();
    }

    inline operator T *() const
    {
      return data();
    }

    inline bool isNull() const
    {
      return !mChild;
    }

    explicit inline operator bool() const
    {
      return static_cast< bool >( mChild );
    }

    inline void clear()
    {
      mChild = nullptr;
    }

    inline T *release()
    {
      T *p = qobject_cast<T *>( mChild );
      mChild = nullptr;
      return p;
    }

    void reset( T *p = nullptr )
    {
      if ( p && !mParent )
      {
        qWarning() << "Assigning pointer to QObjectParentUniquePtr with nullptr parent.";
      }
      delete mChild;
      mChild = p;
    }
};
 
template <class T>
inline bool operator==( const T *o, const QObjectParentUniquePtr<T> &p )
{
  return o == p.operator->();
}
 
template<class T>
inline bool operator==( const QObjectParentUniquePtr<T> &p, const T *o )
{
  return p.operator->() == o;
}
 
template <class T>
inline bool operator==( T *o, const QObjectParentUniquePtr<T> &p )
{
  return o == p.operator->();
}
 
template<class T>
inline bool operator==( const QObjectParentUniquePtr<T> &p, T *o )
{
  return p.operator->() == o;
}
 
template<class T>
inline bool operator==( const QObjectParentUniquePtr<T> &p1, const QObjectParentUniquePtr<T> &p2 )
{
  return p1.operator->() == p2.operator->();
}
 
template <class T>
inline bool operator!=( const T *o, const QObjectParentUniquePtr<T> &p )
{
  return o != p.operator->();
}
 
template<class T>
inline bool operator!= ( const QObjectParentUniquePtr<T> &p, const T *o )
{
  return p.operator->() != o;
}
 
template <class T>
inline bool operator!=( T *o, const QObjectParentUniquePtr<T> &p )
{
  return o != p.operator->();
}
 
template<class T>
inline bool operator!= ( const QObjectParentUniquePtr<T> &p, T *o )
{
  return p.operator->() != o;
}
 
template<class T>
inline bool operator!= ( const QObjectParentUniquePtr<T> &p1, const QObjectParentUniquePtr<T> &p2 )
{
  return p1.operator->() != p2.operator->() ;
}
 
 
#endif // QOBJECTUNIQUEPTR_H