/* Copyright © 2010 yan Verdavaine This file is part of QExtend. QExtend 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 3 of the License, or any later version. QExtend is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with QExtend. If not, see . */ #ifndef QEXTEND_ExtendPtr_H #define QEXTEND_ExtendPtr_H #include #include #include "objectextendptrpolicy.hpp" #include "templatetools.hpp" namespace QExtend { //! \~english QObject Smart pointer which create an object and synchronize its life time. //! \~french Pointeur intelligent pou rles QObject qui créé un objet et synchronise sa durée de vie. /*! \~english ExtendPtr is use to interface an object and use a policy for object destruction. Proposed features are :
  1. Interface an Object.
  2. Can use polymorphisme.
  3. it is not copiable
  4. It is reasignable (use delete policy to the old object)
  5. If the object inherint from QObject, check the object life(Qt parent/child destruction feature)
  6. When it's destroyed, use a policy on object destruction.
\tparam T Object type. \tparam DeletePolicy delete object policy used. Defaut is SCOPE policy. \~french ExtendPtr permet d'interfacer un objet et d'utiliser une politique sur la desctruction de l'objet. Les fonctionalités proposées sont :
  1. Interface un objet.
  2. Peut utiliser le polymorphisme .
  3. Il n'est pas copiable
  4. Il est réasignable(utilise la politique de desctruction de l'objet sur l'ancien objet)
  5. Si l'objet hérite de QObject, permet de savoir si l'objet est toujours vivant (processu de destruction parent/enfant de Qt).
  6. Lors de sa destruction, détruit l'objetde manière sure (verification que l'objet est bien vivant).
\tparam T Type du QObject. \tparam DeletePolicy Politique de destruction de l'objet utilisé. Par défaut la politique SCOPE est utilisé. \~ */ template class ExtendPtr { //internal struct to choice between normal ptr and QWeakPointer when the class inherite from QObject template struct interptr { }; //Specialization. If T is not a QObject, use a normal pointer template struct interptr { TPTR * ptr; interptr():ptr(0){} void setPtr(TPTR * p) {ptr = p;} TPTR* get() {return ptr;} const TPTR* get()const {return ptr;} }; //Specialization. If T is a QObject, use a QWeakPointer template struct interptr { QWeakPointer< TPTR> ptr; void setPtr(TPTR * p) {ptr = p;} TPTR* get() {return ptr.data();} const TPTR* get()const {return ptr.data();} }; interptr < IsDerivedFrom::val , T > m_data; //internal pointer depend if T is a QObejct or not public: //! \~english Smart pointer Constructor. //! \~french Constructeur du pointeur intelligent. /*! \~english Create Object with its default constructor. \param p Object pointer. \~french Créé un objet avec son constructeur par défaut. \param p pointeur sur l'objet. \~ */ ExtendPtr ( T * p = 0 ) { m_data.setPtr( p ); } //! \~english Reassigne pointer to a new object. Use Delete policy on old pointer. //! \~french reassigne le pointer un nouveau pointeur.Utilise la politique de destruction sur l'ancien pointer. /*! \~english Create Object with its default constructor. \param p New object pointer. \~french Créé un objet avec son constructeur par défaut. \param p Pointer du nouvel objet. \~ */ ExtendPtr &operator=( T * p ) { DeletePolicy deletePolicy; if( deletePolicy(m_data.get() ) ) { delete m_data.get(); } m_data.setPtr( p ); return *this; } //! \~english Smart pointer Destructor. Use DeletePolicy to decide if object should be deleted. //! \~french Destructeur du pointeur intelligent. Utilise DeletePolicy pour savoir s'il faut détruire l'objet /*! \~english Delete Object. \~french Détruit l'objet. \~ */ ~ExtendPtr() { DeletePolicy deletePolicy; if( deletePolicy(m_data.get() ) ) { delete m_data.get(); } } //! \~english Test if the pointer is null. //! \~french test si le pointeut est null. /*! \~english \return Returns true if pointer is null. \~french \return Retourne vrai si le pointeur est null \~ */ bool isNull() const { return m_data.get() == 0; } //! \~english Bool convertion. It's true if object is not destroyed (Parent destruction). //! \~french Conversion vers un booléen. Vrai si l'objet n'as pas été détruit(Parent destruction). operator bool () const { return ! isNull (); } //! \~english Cast to the object pointer. //! \~french Conversion vers le pointeur de l'objet. operator T * () { return m_data.get(); } //! \~english Cast to the const object pointer. //! \~french Conversion vers le pointeur constant de l'objet. operator const T * () const { return m_data.get(); } //! \~english Indirection Operator. //! \~french Operateur d'indirection. /*! \~english \return Returns the object pointer. \~french \return Retourne le pointeur de l'objet. \~ */ T* operator->() { return m_data.get(); } //! \~english Indirection Operator. //! \~french Operateur d'indirection. /*! \~english \return Returns the const object pointer. \~french \return Retourne le pointeur constant de l'objet. \~ */ const T* operator->() const { return m_data.get(); } //! \~english Indirection Operator. //! \~french Operateur d'indirection. /*! \~english \return Returns a reference to the object. \~french \return Retourne une référence vers l'objet. \~ */ T & operator*() { return *m_data.get(); } //! \~english Indirection Operator. //! \~french Operateur d'indirection. /*! \~english \return Returns a const reference to the object. \~french \return Retourne une référence constante vers l'objet. \~ */ const T & operator*() const { return *m_data.get(); } }; } #endif // QEXTEND_ObjectPtr