/*
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 :
- Interface an Object.
- Can use polymorphisme.
- it is not copiable
- It is reasignable (use delete policy to the old object)
- If the object inherint from QObject, check the object life(Qt parent/child destruction feature)
- 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 :
- Interface un objet.
- Peut utiliser le polymorphisme .
- Il n'est pas copiable
- Il est réasignable(utilise la politique de desctruction de l'objet sur l'ancien objet)
- Si l'objet hérite de QObject, permet de savoir si l'objet est toujours vivant (processu de destruction parent/enfant de Qt).
- 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