util_ptr_dtk.hpp

Go to the documentation of this file.

#ifndef _UTIL_PTR_DTK_HPP_
#define _UTIL_PTR_DTK_HPP_
 
#include <iostream>
#include "def/define.h"
#include "dtk/config.hpp"
#include <iosfwd>
 
/// @cond NO_DOXYGEN_DOC
namespace dtk
{
     namespace detail
     {
          struct bool_conversion {int for_bool; int for_arg(); };
          typedef int bool_conversion::* explicit_bool_arg;
 
#if !defined(DTK_NO_CXX11_NULLPTR) && !defined(DTK_NO_CXX11_DECLTYPE)
          typedef decltype(nullptr) nullptr_type;
#elif !defined(DTK_NO_CXX11_NULLPTR)
          typedef std::nullptr_t nullptr_type;
#else
          typedef int (bool_conversion::*nullptr_type)();
#endif
     }
}
//! \endcond
/** \defgroup ptr SmartPointer Classes
 * Encapsulate other entities for better memory management
 */
 
class Dtk_Object;
class Dtk_Entity;
 
class Dtk_Info;
class Dtk_StoredInfo;
class Dtk_matrix;
class Dtk_transfo;
 
//! \ingroup ptr
//! \class Dtk_SmartPtr
//! This the Smart Pointer template<br> 
template <typename T>
class Dtk_SmartPtr
{
public:
     typedef T element_type;
     typedef T*     pointer;
 
protected:
    T * ptr_;     
public:
    inline pointer operator->() const DTK_NOEXCEPT
     {
        DTK_ASSERT(ptr_);
        return ptr_; 
    }
 
     inline element_type & operator*() const DTK_NOEXCEPT
     {
          return *ptr_;
     }
 
#if !defined(DTK_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS)
     explicit operator bool() const DTK_NOEXCEPT
#else
     operator dtk::detail::explicit_bool_arg() const DTK_NOEXCEPT
#endif
     {
          return ptr_ ? &dtk::detail::bool_conversion::for_bool : dtk::detail::explicit_bool_arg(0);
     }
 
    ~Dtk_SmartPtr();
    Dtk_SmartPtr();
    Dtk_SmartPtr(T* p);
    Dtk_SmartPtr(const Dtk_SmartPtr<T>& p);
 
     //Move constructor/assignment
#if !defined(DTK_NO_CXX11_RVALUE_REFERENCES)
     Dtk_SmartPtr(Dtk_SmartPtr && p) DTK_NOEXCEPT : ptr_(p.ptr_)
     {
          p.ptr_ = nullptr;
     }
 
     Dtk_SmartPtr& operator=(Dtk_SmartPtr && p) DTK_NOEXCEPT
     {
          if(this != &p)
          {
               release();
               ptr_ = p.ptr_;
               p.ptr_ = nullptr;
          }
 
          return *this;
     }
#endif
 
     pointer get() const DTK_NOEXCEPT
     {  return ptr_;  }
 
    template <typename T2>
    static Dtk_SmartPtr<T> DtkDynamicCast(const Dtk_SmartPtr<T2>& p)
    {
        if( p.IsNULL() )
        {
            return NULL;
        }
        else
        {
            return T::DtkDynamicCast(p.operator ->());
        }
    }
 
    Dtk_SmartPtr<T>& operator= (const Dtk_SmartPtr<T>& p) DTK_NOEXCEPT;
 
    void Clone(Dtk_SmartPtr<T>& out) const;
     //! \brief Resets the Dtk_SmartPtr content.
     void Clear();
    Dtk_bool IsNULL()  const {return ((!ptr_)?(true):(false));}
    Dtk_bool IsNotNULL()  const {return ((ptr_)?(true):(false));}
 
    friend class Dtk_Object;
    friend std::ostream& operator<<(std::ostream& o,const Dtk_SmartPtr& d)
    {
        if (d.ptr_)
        {
            o <<"<Dtk_SmartPtr><Adr>" << d.ptr_ << "</Adr><Val>";
            o << *(d.ptr_);
            o << "</Val></Dtk_SmartPtr>"<<std::endl;
            return o;
        }
        else
            return o<<"<Dtk_SmartPtr><Adr>" << d.ptr_ << "</Adr></Dtk_SmartPtr>"<<std::endl;
    }
private:
    void release() DTK_NOEXCEPT;
 
};
 
///////////////////////////////////////////////////////////////////////////
 
 
template <typename T>
void Dtk_SmartPtr<T>::release() DTK_NOEXCEPT
{
    if(ptr_)
    {
        if (--ptr_->count_ == 0)
        {
            delete ptr_; 
            ptr_ = NULL;
        }
    }
}
 
template <typename T>
Dtk_SmartPtr<T>::~Dtk_SmartPtr()
{
    release();
}
template <typename T>
Dtk_SmartPtr<T>::Dtk_SmartPtr()
{
    ptr_ = NULL;
}
 
template <typename T>
Dtk_SmartPtr<T>::Dtk_SmartPtr(T* p):ptr_(p)
{
    if(ptr_)
        ++ptr_->count_;
}   // p ne doit pas valoir NULL
 
template <typename T>
Dtk_SmartPtr<T>::Dtk_SmartPtr(const Dtk_SmartPtr<T>& p):ptr_(p.ptr_)
{
    if(ptr_)
        ++ptr_->count_;
}
 
template <typename T>
Dtk_SmartPtr<T>& Dtk_SmartPtr<T>::operator= (const Dtk_SmartPtr<T>& p) DTK_NOEXCEPT
{  // NE CHANGEZ PAS L'ORDRE DE CES INSTRUCTIONS!
    // (Cet ordre gere correctement le cas de l'auto-affectation)
    if(p.ptr_)
        ++p.ptr_->count_;
    release();
    ptr_ = p.ptr_;
    return *this;
}
 
template <typename T>
void Dtk_SmartPtr<T>::Clone(Dtk_SmartPtr<T>& res) const
{
    if(ptr_)
    {
          auto * ptr = ptr_->Clone();
          if( ptr )
               res = T::DtkDynamicCast( ptr );
        //res =  new T(*ptr_);
    }
}
 
//! \brief Resets the Dtk_SmartPtr content.
template <typename T>
void Dtk_SmartPtr<T>::Clear()
{
     release();
     ptr_ = NULL;
}
 
template <class T1, class T2>
inline bool operator==(const Dtk_SmartPtr<T1> &x, const Dtk_SmartPtr<T2> &y) DTK_NOEXCEPT
{  return x.get() == y.get(); }
 
template <class T1, class T2>
inline bool operator!=(const Dtk_SmartPtr<T1> &x, const Dtk_SmartPtr<T2> &y) DTK_NOEXCEPT
{  return !(x == y); }
 
template <class T1, class T2>
inline bool operator<(const Dtk_SmartPtr<T1> &x, const Dtk_SmartPtr<T2> &y) DTK_NOEXCEPT
{  return x.get() < y.get(); }
 
template <class T1, class T2>
inline bool operator<=(const Dtk_SmartPtr<T1> &x, const Dtk_SmartPtr<T2> &y) DTK_NOEXCEPT
{  return !(y < x); }
 
template <class T1, class T2>
inline bool operator>(const Dtk_SmartPtr<T1> &x, const Dtk_SmartPtr<T2> &y) DTK_NOEXCEPT
{  return y < x; }
 
template <class T1, class T2>
inline bool operator>=(const Dtk_SmartPtr<T1> &x, const Dtk_SmartPtr<T2> &y) DTK_NOEXCEPT
{  return !(x < y); }
 
 
template <class T>
inline bool operator==(const Dtk_SmartPtr<T> &x, dtk::detail::nullptr_type) DTK_NOEXCEPT
{  return !x;  }
 
template <class T>
inline bool operator==(dtk::detail::nullptr_type, const Dtk_SmartPtr<T> &x) DTK_NOEXCEPT
{  return !x;  }
 
template <class T>
inline bool operator!=(const Dtk_SmartPtr<T> &x, dtk::detail::nullptr_type) DTK_NOEXCEPT
{  return !!x;  }
 
template <class T>
inline bool operator!=(dtk::detail::nullptr_type, const Dtk_SmartPtr<T> &x) DTK_NOEXCEPT
{  return !!x;  }
 
template <class T>
inline bool operator<(const Dtk_SmartPtr<T> &x, dtk::detail::nullptr_type) DTK_NOEXCEPT
{  return x.get() < typename Dtk_SmartPtr<T>::pointer();  }
 
template <class T>
inline bool operator<(dtk::detail::nullptr_type, const Dtk_SmartPtr<T> &x) DTK_NOEXCEPT
{  return typename Dtk_SmartPtr<T>::pointer() < x.get();  }
 
template <class T>
inline bool operator>(const Dtk_SmartPtr<T> &x, dtk::detail::nullptr_type) DTK_NOEXCEPT
{  return x.get() > typename Dtk_SmartPtr<T>::pointer();  }
 
template <class T>
inline bool operator>(dtk::detail::nullptr_type, const Dtk_SmartPtr<T> &x) DTK_NOEXCEPT
{  return typename Dtk_SmartPtr<T>::pointer() > x.get();  }
 
template <class T>
inline bool operator<=(const Dtk_SmartPtr<T> &x, dtk::detail::nullptr_type) DTK_NOEXCEPT
{  return !(x > dtk::detail::nullptr_type());  }
 
template <class T>
inline bool operator<=(dtk::detail::nullptr_type, const Dtk_SmartPtr<T> &x) DTK_NOEXCEPT
{  return !(dtk::detail::nullptr_type() > x);  }
 
template <class T>
inline bool operator>=(const Dtk_SmartPtr<T> &x, dtk::detail::nullptr_type) DTK_NOEXCEPT
{  return !(x < dtk::detail::nullptr_type());  }
 
template <class T>
inline bool operator>=(dtk::detail::nullptr_type, const Dtk_SmartPtr<T> &x) DTK_NOEXCEPT
{  return !(dtk::detail::nullptr_type() < x);  }
 
//! \ingroup ptr
//! \typedef Dtk_ObjectPtr 
//! \brief Handles a Dtk_Object object
//! \sa Dtk_reference
typedef Dtk_SmartPtr<Dtk_Object> Dtk_ObjectPtr;
 
//! \ingroup ptr
//! \typedef Dtk_EntityPtr 
//! \brief Handles a Dtk_Entity object
//! \sa Dtk_Entity
typedef Dtk_SmartPtr<Dtk_Entity> Dtk_EntityPtr;
 
//! \ingroup ptr
//! \typedef Dtk_matrixPtr 
//! \brief Handles a Dtk_matrix object
//! \sa Dtk_dimension
typedef Dtk_SmartPtr<Dtk_matrix> Dtk_matrixPtr;
 
//! \ingroup ptr
//! \typedef Dtk_transfoPtr 
//! \brief Handles a Dtk_transfo object
//! \sa Dtk_dimension
typedef Dtk_SmartPtr<Dtk_transfo> Dtk_transfoPtr;
 
//! \ingroup ptr
//! \typedef Dtk_InfoPtr 
//! \brief Handles a Dtk_Info object
//! \sa Dtk_Info
typedef Dtk_SmartPtr<Dtk_Info> Dtk_InfoPtr;
 
//! \ingroup ptr
//! \typedef Dtk_StoredInfoPtr 
//! \brief Handles a Dtk_StoredInfo object
//! \sa Dtk_Info
typedef Dtk_SmartPtr<Dtk_StoredInfo> Dtk_StoredInfoPtr;
 
 
//! \ingroup ptr
//! \typedef Dtk_RenderInfosPtr 
//! \brief Handles a Dtk_RenderInfos object
//! \sa Dtk_InfoDtk_RenderInfos
class Dtk_RenderInfos;
typedef Dtk_SmartPtr<Dtk_RenderInfos> Dtk_RenderInfosPtr;
 
//! \ingroup ptr
//! \typedef Dtk_BuildingMaterialPtr 
//! \brief Handles a Dtk_BuildingMaterial object
//! \sa Dtk_InfoDtk_BuildingMaterial
class Dtk_BuildingMaterial;
typedef Dtk_SmartPtr<Dtk_BuildingMaterial> Dtk_BuildingMaterialPtr;
 
 
//! \ingroup ptr
//! \typedef Dtk_PhysicalMaterialInfosPtr 
//! \brief Handles a Dtk_PhysicalMaterialInfos object
//! \sa Dtk_PhysicalMaterialInfos
class Dtk_PhysicalMaterialInfos;
typedef Dtk_SmartPtr<Dtk_PhysicalMaterialInfos> Dtk_PhysicalMaterialInfosPtr;
 
 
class Dtk_picture;
typedef Dtk_SmartPtr<Dtk_picture> Dtk_picturePtr;
 
//! \ingroup ptr
//! \typedef Dtk_LineTypeDefinitionPtr 
//! \brief Handles a Dtk_LineTypeDefinition object
//! \sa Dtk_LineTypeDefinition
class Dtk_LineTypeDefinition;
typedef Dtk_SmartPtr<Dtk_LineTypeDefinition> Dtk_LineTypeDefinitionPtr;
 
 
//! \ingroup ptr
//! \typedef Dtk_OLEObjectPtr
//! \brief Handles a Dtk_OLEObject object
//! \sa Dtk_OLEObject
class Dtk_OLEObject;
typedef Dtk_SmartPtr<Dtk_OLEObject> Dtk_OLEObjectPtr;
 
//! \ingroup ptr
//! \typedef Dtk_StreamPtr
//! \brief Handles a Dtk_Stream object
//! \sa Dtk_Stream
class Dtk_Stream;
typedef Dtk_SmartPtr<Dtk_Stream> Dtk_StreamPtr;
 
#endif