smartptr.hpp

浏览该文件的文档.

#ifndef __SMARTPTR_HPP__
#define __SMARTPTR_HPP__
//
// smartptr 提供智能指针相关的功能
//

namespace winux
{
class SmartPtrError : public Error
{
public:
    enum SmartPtrErrorType
    {
        errNone,
        errBadSimpleHandle,
        errBadSimplePointer,
        errBadSharedHandle,
        errBadSharedPointer,
        errBadWeakHandle,
        errBadWeakPointer
    };

    SmartPtrError( SmartPtrErrorType err, AnsiString const & errStr ) : Error( err, errStr ) { }
};

class WINUX_DLL SimpleDeleterContext
{
protected:
    SimpleDeleterContext() { }
    virtual ~SimpleDeleterContext() { }

public:
    void release()
    {
        this->_destroy();
        this->_deleteThis();
    }

    void delThis() { this->_deleteThis(); }

protected:
    virtual void _destroy() = 0;
    virtual void _deleteThis() = 0;
};

template < typename _HTy >
class SimpleDefaultDeleterContext : public SimpleDeleterContext
{
public:
    SimpleDefaultDeleterContext( _HTy h ) : _h(h) { }

protected:
    virtual void _destroy() override { delete _h; }
    virtual void _deleteThis() override { delete this; }

private:
    _HTy _h;
};

template < typename _HTy, typename _Dt >
class SimpleCustomDeleterContext : public SimpleDeleterContext
{
public:
    SimpleCustomDeleterContext( _HTy h, _Dt dt ) : _h(h), _dt(dt) { }

protected:
    virtual void _destroy() override { _dt(_h); }
    virtual void _deleteThis() override { delete this; }

private:
    _HTy _h;
    _Dt _dt;
};

template < typename _HTy >
class SimpleHandle
{
public:
    typedef _HTy HType;

    struct SimpleHandleData
    {
        _HTy h; 
        SimpleDeleterContext * ctx; 
        SimpleHandleData() : h(0), ctx(0) { }
        SimpleHandleData( _HTy h, SimpleDeleterContext * ctx ) : h(h), ctx(ctx) { }
    };

    SimpleHandle() { }

    SimpleHandle( _HTy h, _HTy failVal ) { attachNew( h, failVal ); }

    template < typename _Dt >
    SimpleHandle( _HTy h, _HTy failVal, _Dt dt ) { attachNew( h, failVal, dt ); }

    template < typename _HTy2 >
    SimpleHandle( _HTy2 h, _HTy2 failVal ) { attachNew( h, failVal ); }

    template < typename _HTy2, typename _Dt >
    SimpleHandle( _HTy2 h, _HTy2 failVal, _Dt dt ) { attachNew( h, failVal, dt ); }

    ~SimpleHandle()
    {
        reset();
    }

    SimpleHandle( SimpleHandle const & other )
    {
        _reset(other);
    }

    SimpleHandle & operator = ( SimpleHandle const & other )
    {
        _reset(other);
        return *this;
    }

    template < typename _HTy2 >
    SimpleHandle( SimpleHandle<_HTy2> const & other )
    {
        _reset(other);
    }

    template < typename _HTy2 >
    SimpleHandle & operator = ( SimpleHandle<_HTy2> const & other )
    {
        _reset(other);
        return *this;
    }

    void attachNew( _HTy h, _HTy failVal )
    {
        this->_reset0( h, ( h != failVal ? new SimpleDefaultDeleterContext<_HTy>(h) : 0 ) );
    }

    template < typename _Dt >
    void attachNew( _HTy h, _HTy failVal, _Dt dt )
    {
        this->_reset0( h, ( h != failVal ? new SimpleCustomDeleterContext< _HTy, _Dt >( h, dt ) : 0 ) );
    }

    template < typename _HTy2 >
    void attachNew( _HTy2 h, _HTy2 failVal )
    {
        this->_reset0( h, ( h != failVal ? new SimpleDefaultDeleterContext<_HTy2>(h) : 0 ) );
    }

    template < typename _HTy2, typename _Dt >
    void attachNew( _HTy2 h, _HTy2 failVal, _Dt dt )
    {
        this->_reset0( h, ( h != failVal ? new SimpleCustomDeleterContext< _HTy2, _Dt >( h, dt ) : 0 ) );
    }

    void attach( SimpleHandleData const & data )
    {
        _reset0( data.h, data.ctx );
    }

    template < typename _HTy2 >
    void attach( typename SimpleHandle<_HTy2>::SimpleHandleData const & data )
    {
        _reset0( data.h, data.ctx );
    }

    template < typename _HTy2 >
    void attach( _HTy2 h, SimpleDeleterContext * ctx )
    {
        _reset0( h, ctx );
    }

    SimpleHandleData detach()
    {
        SimpleHandleData r = _self;
        _self.h = static_cast<_HTy>(0);
        _self.ctx = 0;
        return r;
    }

    void reset()
    {
        _reset0( static_cast<_HTy>(0), 0 );
    }

    _HTy get() const { return _self.h; }
    SimpleDeleterContext * getContext() const { return _self.ctx; }

    operator bool() const { return _self.ctx != 0; }

    bool operator < ( SimpleHandle const & other ) const { return _self.h < other._self.h; }

    _HTy operator -> ()
    {
        return _self.h;
    }

    _HTy operator -> () const
    {
        return _self.h;
    }

protected:
    template < typename _HTy2 >
    void _reset0( _HTy2 newH, SimpleDeleterContext * newCtx )
    {
        if ( _self.ctx )
            _self.ctx->release();
        _self.h = newH;
        _self.ctx = newCtx;
    }

    template < typename _HTy2 >
    void _reset( _HTy2 & otherH, SimpleDeleterContext * & otherCtx )
    {
        _reset0( otherH, otherCtx );
        otherH = static_cast<_HTy2>(0);
        otherCtx = 0;
    }

    template < typename _HTy2 >
    void _reset( SimpleHandle<_HTy2> const & other )
    {
        SimpleHandle<_HTy2> & o = const_cast< SimpleHandle<_HTy2> & >(other);
        _reset( o._self.h, o._self.ctx );
    }

    SimpleHandleData _self;

private:
    template < typename _HTy0 >
    friend class SimpleHandle;
};

template < typename _Ty >
class SimplePointer : public SimpleHandle<_Ty*>
{
public:
    typedef SimpleHandle<_Ty*> MyBase;
    typedef _Ty Type;

    SimplePointer() { }

    explicit SimplePointer( _Ty* p ) : MyBase( p, (_Ty*)0 ) { }

    template < typename _Dt >
    SimplePointer( _Ty* p, _Dt dt ) : MyBase( p, (_Ty*)0, dt ) { }

    template < typename _Ty2 >
    explicit SimplePointer( _Ty2* p ) : MyBase( p, (_Ty2*)0 ) { }

    template < typename _Ty2, typename _Dt >
    SimplePointer( _Ty2* p, _Dt dt ) : MyBase( p, (_Ty2*)0, dt ) { }

    SimplePointer( SimplePointer const & other )
    {
        this->_reset(other);
    }

    SimplePointer & operator = ( SimplePointer const & other )
    {
        this->_reset(other);
        return *this;
    }

    template < typename _Ty2 >
    SimplePointer( SimplePointer<_Ty2> const & other )
    {
        this->_reset(other);
    }

    template < typename _Ty2 >
    SimplePointer & operator = ( SimplePointer<_Ty2> const & other )
    {
        this->_reset(other);
        return *this;
    }

    void attachNew( _Ty * p )
    {
        MyBase::attachNew( p, (_Ty*)0 );
    }

    template < typename _Dt >
    void attachNew( _Ty * p, _Dt dt )
    {
        MyBase::attachNew( p, (_Ty*)0, dt );
    }

    template < typename _Ty2 >
    void attachNew( _Ty2 * p )
    {
        MyBase::attachNew( p, (_Ty2*)0 );
    }

    template < typename _Ty2, typename _Dt >
    void attachNew( _Ty2 * p, _Dt dt )
    {
        MyBase::attachNew( p, (_Ty2*)0, dt );
    }

    template < typename _Ty2 >
    SimplePointer<_Ty2> cast()
    {
        SimplePointer<_Ty2> r;
        typename SimplePointer<_Ty2>::HType p = dynamic_cast< typename SimplePointer<_Ty2>::HType >(this->_self.h);
        if ( p != 0 )
        {
            r._reset( p, this->_self.ctx );
            this->_self.h = static_cast<typename MyBase::HType>(0);
            this->_self.ctx = 0;
        }
        return r;
    }

    template < typename _Ty2 >
    SimplePointer<_Ty2> ensureCast()
    {
        SimplePointer<_Ty2> r;
        typename SimplePointer<_Ty2>::HType p = static_cast< typename SimplePointer<_Ty2>::HType >(this->_self.h);
        r._reset( p, this->_self.ctx );
        this->_self.h = static_cast<typename MyBase::HType>(0);
        this->_self.ctx = 0;
        return r;
    }

    template < typename _Ty0 >
    friend class SimplePointer;
};


WINUX_FUNC_DECL(long) LongAtomicIncrement( long volatile * p );
WINUX_FUNC_DECL(long) LongAtomicDecrement( long volatile * p );
WINUX_FUNC_DECL(long) LongAtomicCompareExchange( long volatile * p,  long exchange, long comparand );

// 前向声明
template < typename _HTy >
class WeakHandle;
template < typename _Ty >
class WeakPointer;
template < typename _Ty >
class SharedPointer;

// For SFINAE
template < typename... _Ty >
struct MakeVoid { typedef void type; };
template < typename... _Ty >
using VoidT = typename MakeVoid<_Ty...>::type;

// Detect unambiguous and accessible inheritance from EnableSharedFromThis
template < typename _Yty, typename = VoidT<> >
struct _CanEnableShared : std::false_type
{
};

// is_convertible is necessary to verify unambiguous inheritance
template < typename _Yty >
struct _CanEnableShared<_Yty, VoidT<typename _Yty::_EsftType> > : std::is_convertible<typename std::remove_cv<_Yty>::type *, typename _Yty::_EsftType *>::type
{
};

// enable sharedFromThis
template < typename _Other, typename _Yty >
void _EnableSharedFromThis1( SharedPointer<_Other> const & sharedThis, _Yty * ptr, std::true_type )
{
    if ( ptr && ptr->_weakPtr.expired() )
    {
        ptr->_weakPtr = SharedPointer<typename std::remove_cv<_Yty>::type>( sharedThis, const_cast<typename std::remove_cv<_Yty>::type *>(ptr) );
    }
}

// don't enable sharedFromThis
template < typename _Other, typename _Yty >
void _EnableSharedFromThis1( SharedPointer<_Other> const &, _Yty *, std::false_type )
{
}

// possibly enable sharedFromThis
template < typename _Other, typename _Yty >
void _EnableSharedFromThis( SharedPointer<_Other> const & sharedThis, _Yty * ptr )
{
    _EnableSharedFromThis1( sharedThis, ptr, std::integral_constant< bool, _CanEnableShared<_Yty>::value >() );
}

class WINUX_DLL SharedDeleterContext
{
protected:
    SharedDeleterContext() : _uses(1), _weaks(1) { }
    virtual ~SharedDeleterContext() { }

    virtual void _destroy() = 0;
    virtual void _deleteThis() = 0;

public:
    bool _incRefNz()
    {
        for ( ; ; )
        {
            // loop until state is known
            long count = (long volatile &)_uses;
            if ( count == 0 ) return false;
            if ( LongAtomicCompareExchange( &_uses, count + 1, count ) == count ) return true;
        }
    }
    void incRef() { LongAtomicIncrement(&_uses); }
    void decRef()
    {
        if ( LongAtomicDecrement(&_uses) == 0 )
        {
            this->_destroy();
            this->decWRef();
        }
    }

    void incWRef() { LongAtomicIncrement(&_weaks); }
    void decWRef()
    {
        if ( LongAtomicDecrement(&_weaks) == 0 )
        {
            this->_deleteThis();
        }
    }

    long useCount() const { return (_uses); }

    bool expired() const { return ( _uses == 0 ); }

    long weakCount() const { return (_weaks); }

private:
    long volatile _uses;
    long volatile _weaks;

    DISABLE_OBJECT_COPY(SharedDeleterContext)
};

template < typename _HTy >
class SharedDefaultDeleterContext : public SharedDeleterContext
{
public:
    SharedDefaultDeleterContext( _HTy h ) : _h(h) { }

protected:
    virtual void _destroy() override { delete _h; }
    virtual void _deleteThis() override { delete this; }

private:
    _HTy _h;
};

template < typename _HTy, typename _Dt >
class SharedCustomDeleterContext : public SharedDeleterContext
{
public:
    SharedCustomDeleterContext( _HTy h, _Dt dt ) : _h(h), _dt(dt) { }

protected:
    virtual void _destroy() override { _dt(_h); }
    virtual void _deleteThis() override { delete this; }

private:
    _HTy _h;
    _Dt _dt;
};

template < typename _HTy >
class SharedHandle
{
public:
    typedef _HTy HType;

    struct SharedHandleData
    {
        _HTy h; 
        SharedDeleterContext * ctx; 
        SharedHandleData() : h(0), ctx(0) { }
        SharedHandleData( _HTy h, SharedDeleterContext * ctx ) : h(h), ctx(ctx) { }
    };

    SharedHandle() { }

    SharedHandle( _HTy h, _HTy failVal ) { attachNew( h, failVal ); }

    template < typename _Dt >
    SharedHandle( _HTy h, _HTy failVal, _Dt dt ) { attachNew( h, failVal, dt ); }

    template < typename _HTy2 >
    SharedHandle( _HTy2 h, _HTy2 failVal ) { attachNew( h, failVal ); }

    template < typename _HTy2, typename _Dt >
    SharedHandle( _HTy2 h, _HTy2 failVal, _Dt dt ) { attachNew( h, failVal, dt ); }

    template < typename _HTy2 >
    explicit SharedHandle( WeakHandle<_HTy2> const & other )
    {
        if ( !other._sharedReset(this) )
        {
            throw SmartPtrError( SmartPtrError::errBadWeakHandle, AnsiString("Bad WeakHandle<") + typeid(_HTy2).name() + ">" );
        }
    }

    ~SharedHandle()
    {
        reset();
    }

    SharedHandle( SharedHandle const & other )
    {
        _reset(other);
    }

    SharedHandle & operator = ( SharedHandle const & other )
    {
        _reset(other);
        return *this;
    }

    template < typename _HTy2 >
    SharedHandle( SharedHandle<_HTy2> const & other )
    {
        _reset(other);
    }

    template < typename _HTy2 >
    SharedHandle & operator = ( SharedHandle<_HTy2> const & other )
    {
        _reset(other);
        return *this;
    }

    void attachNew( _HTy h, _HTy failVal )
    {
        this->_reset0( h, ( h != failVal ? new SharedDefaultDeleterContext<_HTy>(h) : 0 ) );
    }

    template < typename _Dt >
    void attachNew( _HTy h, _HTy failVal, _Dt dt )
    {
        this->_reset0( h, ( h != failVal ? new SharedCustomDeleterContext< _HTy, _Dt >( h, dt ) : 0 ) );
    }

    template < typename _HTy2 >
    void attachNew( _HTy2 h, _HTy2 failVal )
    {
        this->_reset0( h, ( h != failVal ? new SharedDefaultDeleterContext<_HTy2>(h) : 0 ) );
    }

    template < typename _HTy2, typename _Dt >
    void attachNew( _HTy2 h, _HTy2 failVal, _Dt dt )
    {
        this->_reset0( h, ( h != failVal ? new SharedCustomDeleterContext< _HTy2, _Dt >( h, dt ) : 0 ) );
    }

    void attach( SharedHandleData const & data, bool isIncRef )
    {
        if ( isIncRef )
        {
            _reset( data.h, data.ctx );
        }
        else
        {
            _reset0( data.h, data.ctx );
        }
    }

    template < typename _HTy2 >
    void attach( typename SharedHandle<_HTy2>::SharedHandleData const & data, bool isIncRef )
    {
        if ( isIncRef )
        {
            _reset( data.h, data.ctx );
        }
        else
        {
            _reset0( data.h, data.ctx );
        }
    }

    template < typename _HTy2 >
    void attach( _HTy2 h, SharedDeleterContext * ctx, bool isIncRef )
    {
        if ( isIncRef )
        {
            _reset( h, ctx );
        }
        else
        {
            _reset0( h, ctx );
        }
    }

    SharedHandleData detach()
    {
        SharedHandleData r = _self;
        _self.h = static_cast<_HTy>(0);
        _self.ctx = 0;
        return r;
    }

    SharedHandleData peek() const
    {
        return _self;
    }

    void reset()
    {
        _reset0( static_cast<_HTy>(0), 0 );
    }

    _HTy get() const { return _self.h; }
    SharedDeleterContext * getContext() const { return _self.ctx; }

    operator bool() const { return _self.ctx != 0; }

    bool operator < ( SharedHandle const & other ) const { return _self.h < other._self.h; }

    _HTy operator -> ()
    {
        return _self.h;
    }

    _HTy operator -> () const
    {
        return _self.h;
    }

protected:
    template < typename _HTy2 >
    void _reset0( _HTy2 newH, SharedDeleterContext * newCtx )
    {
        if ( _self.ctx )
            _self.ctx->decRef();
        _self.h = newH;
        _self.ctx = newCtx;
    }

    template < typename _HTy2 >
    void _reset( _HTy2 otherH, SharedDeleterContext * otherCtx )
    {
        if ( otherCtx )
            otherCtx->incRef();
        _reset0( otherH, otherCtx );
    }

    template < typename _HTy2 >
    void _reset( SharedHandle<_HTy2> const & other )
    {
        _reset( other._self.h, other._self.ctx );
    }

    SharedHandleData _self;

private:
    template < typename _HTy0 >
    friend class SharedHandle;
    template < typename _HTy0 >
    friend class WeakHandle;
};

template < typename _Ty >
class SharedPointer : public SharedHandle<_Ty*>
{
public:
    typedef SharedHandle<_Ty*> MyBase;
    typedef _Ty Type;

    SharedPointer() { }

    explicit SharedPointer( _Ty* p ) { attachNew(p); }

    template < typename _Dt >
    SharedPointer( _Ty* p, _Dt dt ) { attachNew( p, dt ); }

    template < typename _Ty2 >
    explicit SharedPointer( _Ty2* p ) { attachNew(p); }

    template < typename _Ty2, typename _Dt >
    SharedPointer( _Ty2* p, _Dt dt ) { attachNew( p, dt ); }

    template < typename _Ty2 >
    explicit SharedPointer( WeakPointer<_Ty2> const & other )
    {
        if ( !other._sharedReset(this) )
        {
            throw SmartPtrError( SmartPtrError::errBadWeakPointer, AnsiString("Bad WeakPointer<") + typeid(_Ty2).name() + ">" );
        }
    }

    template < typename _Ty2 >
    SharedPointer( SharedPointer<_Ty2> const & other, _Ty2 * ptr ) noexcept
    {
        if ( other._self.ctx )
            other._self.ctx->incRef();

        this->_self.h = ptr;
        this->_self.ctx = other._self.ctx;
    }

    SharedPointer( SharedPointer const & other )
    {
        this->_reset(other);
    }

    SharedPointer & operator = ( SharedPointer const & other )
    {
        this->_reset(other);
        return *this;
    }

    template < typename _Ty2 >
    SharedPointer( SharedPointer<_Ty2> const & other )
    {
        this->_reset(other);
    }

    template < typename _Ty2 >
    SharedPointer & operator = ( SharedPointer<_Ty2> const & other )
    {
        this->_reset(other);
        return *this;
    }

    void attachNew( _Ty * p )
    {
        MyBase::attachNew( p, (_Ty*)0 );
        _EnableSharedFromThis( *this, p );
    }

    template < typename _Dt >
    void attachNew( _Ty * p, _Dt dt )
    {
        MyBase::attachNew( p, (_Ty*)0, dt );
        _EnableSharedFromThis( *this, p );
    }

    template < typename _Ty2 >
    void attachNew( _Ty2 * p )
    {
        MyBase::attachNew( p, (_Ty2*)0 );
        _EnableSharedFromThis( *this, p );
    }

    template < typename _Ty2, typename _Dt >
    void attachNew( _Ty2 * p, _Dt dt )
    {
        MyBase::attachNew( p, (_Ty2*)0, dt );
        _EnableSharedFromThis( *this, p );
    }

    template < typename _Ty2 >
    SharedPointer<_Ty2> cast()
    {
        SharedPointer<_Ty2> r;
        typename SharedPointer<_Ty2>::HType p = dynamic_cast< typename SharedPointer<_Ty2>::HType >(this->_self.h);
        if ( p != 0 )
            r._reset( p, this->_self.ctx );
        return r;
    }

    template < typename _Ty2 >
    SharedPointer<_Ty2> ensureCast()
    {
        SharedPointer<_Ty2> r;
        r._reset( static_cast< typename SharedPointer<_Ty2>::HType >(this->_self.h), this->_self.ctx );
        return r;
    }

private:
    template < typename _Ty0 >
    friend class SharedPointer;
    template < typename _Ty0 >
    friend class WeakPointer;
};

template < typename _HTy >
class WeakHandle
{
public:
    typedef _HTy HType;

    typedef typename SharedHandle<_HTy>::SharedHandleData WeakHandleData;

    WeakHandle() { }

    template < typename _HTy2 >
    WeakHandle( SharedHandle<_HTy2> const & other )
    {
        _reset( other._self.h, other._self.ctx );
    }

    template < typename _HTy2 >
    WeakHandle & operator = ( SharedHandle<_HTy2> const & other )
    {
        _reset( other._self.h, other._self.ctx );
        return *this;
    }

    ~WeakHandle()
    {
        reset();
    }

    WeakHandle( WeakHandle const & other )
    {
        _reset(other);
    }

    WeakHandle & operator = ( WeakHandle const & other )
    {
        _reset(other);
        return *this;
    }

    template < typename _HTy2 >
    WeakHandle( WeakHandle<_HTy2> const & other )
    {
        _reset(other);
    }

    template < typename _HTy2 >
    WeakHandle & operator = ( WeakHandle<_HTy2> const & other )
    {
        _reset(other);
        return *this;
    }

    void reset()
    {
        _reset( static_cast<_HTy>(0), 0 );
    }

    SharedHandle<_HTy> lock() const
    {
        SharedHandle<_HTy> r;
        (void)this->_sharedReset(&r);
        return r;
    }

    bool expired() const { return ( !_self.ctx || _self.ctx->expired() ); }

    operator bool() const { return _self.ctx != 0; }

protected:
    template < typename _HTy2 >
    bool _sharedReset( SharedHandle<_HTy2> * shared ) const
    {
        if ( _self.ctx && _self.ctx->_incRefNz() )
        {
            // 由于之前_incRefNz()已经增加引用计数，因此这里当作新资源看待
            shared->_reset0( _self.h, _self.ctx );
            return true;
        }
        return false;
    }

    template < typename _HTy2 >
    void _reset( _HTy2 otherH, SharedDeleterContext * otherCtx )
    {
        if ( otherCtx != 0 )
            otherCtx->incWRef();
        if ( _self.ctx != 0 )
            _self.ctx->decWRef();
        _self.h = otherH;
        _self.ctx = otherCtx;
    }

    template < typename _HTy2 >
    void _reset( WeakHandle<_HTy2> const & other )
    {
        _reset( other._self.h, other._self.ctx );
    }

    WeakHandleData _self;

private:
    template < typename _HTy0 >
    friend class WeakHandle;
    template < typename _HTy0 >
    friend class SharedHandle;
};

template < typename _Ty >
class WeakPointer : public WeakHandle<_Ty*>
{
public:
    typedef WeakHandle<_Ty*> MyBase;
    typedef _Ty Type;

    WeakPointer() { }

    template < typename _Ty2 >
    WeakPointer( SharedPointer<_Ty2> const & other )
    {
        this->_reset( other._self.h, other._self.ctx );
    }

    template < typename _Ty2 >
    WeakPointer & operator = ( SharedPointer<_Ty2> const & other )
    {
        this->_reset( other._self.h, other._self.ctx );
        return *this;
    }

    WeakPointer( WeakPointer const & other )
    {
        this->_reset(other);
    }

    WeakPointer & operator = ( WeakPointer const & other )
    {
        this->_reset(other);
        return *this;
    }

    template < typename _Ty2 >
    WeakPointer( WeakPointer<_Ty2> const & other )
    {
        this->_reset(other);
    }

    template < typename _Ty2 >
    WeakPointer & operator = ( WeakPointer<_Ty2> const & other )
    {
        this->_reset(other);
        return *this;
    }

    SharedPointer<_Ty> lock() const
    {
        SharedPointer<_Ty> r;
        (void)this->_sharedReset(&r);
        return r;
    }

private:
    template < typename _Ty0 >
    friend class WeakPointer;
    template < typename _Ty0 >
    friend class SharedPointer;
};


template < typename _Ty >
class EnableSharedFromThis
{
public:
    using _EsftType = EnableSharedFromThis;

    SharedPointer<_Ty> sharedFromThis()
    {   // return shared_ptr
        return SharedPointer<_Ty>(_weakPtr);
    }

    SharedPointer<const _Ty> sharedFromThis() const
    {   // return shared_ptr
        return SharedPointer<const _Ty>(_weakPtr);
    }

    WeakPointer<_Ty> weakFromThis() noexcept
    {   // return weak_ptr
        return _weakPtr;
    }

    WeakPointer<const _Ty> weakFromThis() const noexcept
    {   // return weak_ptr
        return _weakPtr;
    }

protected:
    constexpr EnableSharedFromThis() noexcept : _weakPtr()
    {   // construct
    }

    EnableSharedFromThis( EnableSharedFromThis const & ) noexcept : _weakPtr()
    {   // construct (must value-initialize _Wptr)
    }

    EnableSharedFromThis& operator = ( EnableSharedFromThis const & ) noexcept
    {   // assign (must not change _Wptr)
        return (*this);
    }

private:
    template < typename _Other, typename _Yty >
    friend void _EnableSharedFromThis1( SharedPointer<_Other> const & sharedThis, _Yty * ptr, std::true_type );

    mutable WeakPointer<_Ty> _weakPtr;
};

template < typename _Ty >
inline SimplePointer<_Ty> MakeSimple( _Ty * newObj )
{
    return SimplePointer<_Ty>(newObj);
}

template < typename _Ty, typename _Dt >
inline SimplePointer<_Ty> MakeSimple( _Ty * newObj, _Dt dt )
{
    return SimplePointer<_Ty>( newObj, dt );
}

template < typename _Ty >
inline SharedPointer<_Ty> MakeShared( _Ty * newObj )
{
    return SharedPointer<_Ty>(newObj);
}

template < typename _Ty, typename _Dt >
inline SharedPointer<_Ty> MakeShared( _Ty * newObj, _Dt dt )
{
    return SharedPointer<_Ty>( newObj, dt );
}


} // namespace winux

#endif // __SMARTPTR_HPP__