shared_pointer.h

#ifndef SHARED_POINTER_H
#define SHARED_POINTER_H
 
#include "CORE_Object.h"
 
//unique pointer
template<class T>
using  CORE_UniquePointer = typename std::unique_ptr<T,CORE_Object::Delete> ;
 
 
 
//shared pointer
template<class T>
using  CORE_SharedPointer = typename std::shared_ptr<T> ;
 
 
//weak pointer
template<class T>
using  CORE_WeakPointer = typename std::weak_ptr<T> ;
 
 
//some usefull function for manipulating smart pointers
namespace shared_pointer {
    
    /* \brief cast the shared pointer of class F to T
     */
    template<class T, class F> 
    static CORE_SharedPointer<T> dynamic_sp_cast(CORE_SharedPointer<F> const & r) {
        return dynamic_pointer_cast<T>(r);
    };
    /* \brief cast the shared pointer of class F to T
     */
    template<class T, class F> 
    static CORE_SharedPointer<const T> dynamic_spc_cast(CORE_SharedPointer<const F> const & r) {
        return dynamic_pointer_cast<const T>(r);
    };
     
    /* \brief cast the unique  pointer of class F to T
     * @param[in] r : unqiue pointer of type F to cast to derived class T of the instance
     */
    template<class T, class F> 
    static CORE_UniquePointer<T> dynamic_up_cast(CORE_UniquePointer<F> & r) {
        T* p = dynamic_cast<T*>( r.get() );
        if (p!=null) r.release();
        return CORE_UniquePointer<T>(p); 
    };    
    /* \brief cast the unique  pointer of class F to T
     * @param[in] r : unqiue pointer of type F to cast to derived class T of the instance
     */
    template<class T, class F> 
    static CORE_UniquePointer<T> dynamic_up_cast(CORE_UniquePointer<F> && r) {
        T* p = dynamic_cast<T*>( r.get() );
        if (p!=null) r.release();
        return CORE_UniquePointer<T>(p); 
    };
    /* \brief cast the unique pointer of class F to T
     * @param[in] r : unqiue pointer of type F to cast to derived class T of the instance
     */
    template<class T, class F> 
    static CORE_UniquePointer<const T> dynamic_upc_cast(CORE_UniquePointer<const F> & r) {
        const T* p = dynamic_cast<const T*>( r.get() );
        if( p!=null) r.release();
        return CORE_UniquePointer<const T>(p); 
    };
   /* \brief cast the unique pointer of class F to T
     * @param[in] r : unqiue pointer of type F to cast to derived class T of the instance
     */
    template<class T, class F> 
    static CORE_UniquePointer<const T> dynamic_upc_cast(CORE_UniquePointer<const F> && r) {
        const T* p = dynamic_cast<const T*>( r.get() );
        if( p!=null ) r.release();
        return CORE_UniquePointer<const T>(p); 
    };
   
 
    
 
    
};
#define CORE_UniqueInstance CORE_UniquePointer
#define CORE_SharedInstance CORE_SharedPointer
 
#endif