Dtk_SmartPtr< T > Class Template Reference

Public Types
typedef T	element_type
typedef T *	pointer

Public Member Functions
void	Clear ()
	Resets the Dtk_SmartPtr content. More...
void	Clone (Dtk_SmartPtr< T > &out) const
	Dtk_SmartPtr ()
	Dtk_SmartPtr (const Dtk_SmartPtr< T > &p)
	Dtk_SmartPtr (Dtk_SmartPtr &&p) DTK_NOEXCEPT
	Dtk_SmartPtr (T *p)
pointer	get () const DTK_NOEXCEPT
Dtk_bool	IsNotNULL () const
Dtk_bool	IsNULL () const
	operator bool () const DTK_NOEXCEPT
element_type &	operator* () const DTK_NOEXCEPT
pointer	operator-> () const DTK_NOEXCEPT
Dtk_SmartPtr< T > &	operator= (const Dtk_SmartPtr< T > &p) DTK_NOEXCEPT
Dtk_SmartPtr &	operator= (Dtk_SmartPtr &&p) DTK_NOEXCEPT
	~Dtk_SmartPtr ()

Static Public Member Functions
template<typename T2 >
static Dtk_SmartPtr< T >	DtkDynamicCast (const Dtk_SmartPtr< T2 > &p)

Protected Attributes
T *	ptr_

Friends
class	Dtk_Object
std::ostream &	operator<< (std::ostream &o, const Dtk_SmartPtr &d)

Detailed Description

template<typename T>
class Dtk_SmartPtr< T >

This the Smart Pointer template

Member Typedef Documentation

element_type

template<typename T >

typedef T Dtk_SmartPtr< T >::element_type

pointer

template<typename T >

typedef T* Dtk_SmartPtr< T >::pointer

Constructor & Destructor Documentation

~Dtk_SmartPtr()

template<typename T >

Dtk_SmartPtr< T >::~Dtk_SmartPtr

{
    release();
}

Dtk_SmartPtr() [1/4]

template<typename T >

Dtk_SmartPtr< T >::Dtk_SmartPtr

{
    ptr_ = NULL;
}

Dtk_SmartPtr() [2/4]

template<typename T >

Dtk_SmartPtr< T >::Dtk_SmartPtr

(

T *

p

)

                                 :ptr_(p)
{
    if(ptr_)
        ++ptr_->count_;
}   // p ne doit pas valoir NULL

Dtk_SmartPtr() [3/4]

template<typename T >

Dtk_SmartPtr< T >::Dtk_SmartPtr

(

const Dtk_SmartPtr< T > &

p

)

                                                     :ptr_(p.ptr_)
{
    if(ptr_)
        ++ptr_->count_;
}

Dtk_SmartPtr() [4/4]

template<typename T >

Dtk_SmartPtr< T >::Dtk_SmartPtr

(

Dtk_SmartPtr< T > &&

p

)

                                                  : ptr_(p.ptr_)
     {
          p.ptr_ = nullptr;
     }

Member Function Documentation

Clear()

template<typename T >

void Dtk_SmartPtr< T >::Clear

Resets the Dtk_SmartPtr content.

{
     release();
     ptr_ = NULL;
}

Clone()

template<typename T >

void Dtk_SmartPtr< T >::Clone

(

Dtk_SmartPtr< T > &

out

)

const

{
    if(ptr_)
    {
        res = T::DtkDynamicCast( ptr_->Clone() );
        //res =  new T(*ptr_);
    }
}

DtkDynamicCast()

template<typename T >

template<typename T2 >

static Dtk_SmartPtr<T> Dtk_SmartPtr< T >::DtkDynamicCast ( const Dtk_SmartPtr< T2 > &  p )

static

    {
        if( p.IsNULL() )
        {
            return NULL;
        }
        else
        {
            return T::DtkDynamicCast(p.operator ->());
        }
    }

get()

template<typename T >

pointer Dtk_SmartPtr< T >::get

(

)

const

     {  return ptr_;  }

IsNotNULL()

template<typename T >

Dtk_bool Dtk_SmartPtr< T >::IsNotNULL

(

)

const

{return ((ptr_)?(true):(false));}

IsNULL()

template<typename T >

Dtk_bool Dtk_SmartPtr< T >::IsNULL

(

)

const

{return ((!ptr_)?(true):(false));}

operator bool()

template<typename T >

Dtk_SmartPtr< T >::operator bool ( ) const

explicit

     {
          return ptr_ ? &dtk::detail::bool_conversion::for_bool : dtk::detail::explicit_bool_arg(0);
     }

operator*()

template<typename T >

element_type& Dtk_SmartPtr< T >::operator*

(

)

const

     {
          return *ptr_;
     }

operator->()

template<typename T >

pointer Dtk_SmartPtr< T >::operator->

(

)

const

     {
        DTK_ASSERT(ptr_);
        return ptr_; 
    }

operator=() [1/2]

template<typename T >

Dtk_SmartPtr< T > & Dtk_SmartPtr< T >::operator=

(

const Dtk_SmartPtr< T > &

p

)

{  // 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;
}

operator=() [2/2]

template<typename T >

Dtk_SmartPtr& Dtk_SmartPtr< T >::operator=

(

Dtk_SmartPtr< T > &&

p

)

     {
          if(this != &p)
          {
               release();
               ptr_ = p.ptr_;
               p.ptr_ = nullptr;
          }
 
          return *this;
     }

Friends And Related Function Documentation

Dtk_Object

template<typename T >

friend class Dtk_Object

friend

operator<<

template<typename T >

std::ostream& operator<< ( std::ostream &  o, const Dtk_SmartPtr< T > &  d  )

friend

    {
        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;
    }

Field Documentation

ptr_

template<typename T >

T* Dtk_SmartPtr< T >::ptr_

protected