F:/My Projects/LSEngine/Modules/LSTL/Src/SharedPtr/LSTLSharedPtr.h

#ifndef __LSTL_SHAREDPTR_H__
#define __LSTL_SHAREDPTR_H__

#include "../LSTLib.h"
#include "../Allocator/LSTLAllocator.h"

namespace lstl {

        // == Enumerations.
        enum LSSTL_SHARED_PTR {
                LSSTL_SP_MAKE_NEW
        };

        template <typename _tType>
        class CSharedPtr {
        public :
                // == Various constructors.
                LSE_CALLCTOR                                    CSharedPtr() :
                        m_pcCont( NULL ),
                        m_ptDirect( NULL ) {
                }
                explicit LSE_CALLCTOR                   CSharedPtr( LSSTL_SHARED_PTR /*_spFlag*/ ) {
                        // Create a new object with a 1 reference count.
                        m_pcCont = static_cast<CSharedPtr<_tType>::LSSTL_CONTAINER *>(CMemLib::MNew( NULL, LSSTL_CONTAINER ));
                        if ( !m_pcCont ) { throw LSSTD_E_OUTOFMEMORY; }
                        m_pcCont->paAllocator = NULL;
                        m_pcCont->ui32RefCount = 1UL;
                        m_ptDirect = &m_pcCont->tObj;
                }
                explicit LSE_CALLCTOR                   CSharedPtr( CAllocator * _paAllocator ) {
                        // Create a new object with a 1 reference count.
                        m_pcCont = static_cast<CSharedPtr<_tType>::LSSTL_CONTAINER *>(CMemLib::MNew( _paAllocator ? _paAllocator->GetAllocator() : NULL, LSSTL_CONTAINER ));
                        if ( !m_pcCont ) { throw LSSTD_E_OUTOFMEMORY; }
                        m_pcCont->paAllocator = _paAllocator;
                        m_pcCont->ui32RefCount = 1UL;
                        m_ptDirect = &m_pcCont->tObj;
                }
                LSE_CALLCTOR                                    CSharedPtr( const CSharedPtr<_tType> &_spOther ) {
                        // Reference the object to which it points.
                        m_pcCont = _spOther.m_pcCont;
                        m_ptDirect = _spOther.m_ptDirect;
                        if ( m_pcCont ) {
                                ++m_pcCont->ui32RefCount;
                        }
                }
                template <typename _tCastType>  
                LSE_CALLCTOR                                    CSharedPtr( const CSharedPtr<_tCastType> &_spOther ) {
                        // Reference the object to which it points.
                        m_pcCont = const_cast<LSSTL_CONTAINER *>(reinterpret_cast<const LSSTL_CONTAINER *>(_spOther.GetContainer()));
                        m_ptDirect = const_cast<_tType *>(static_cast<const _tType *>(_spOther.Get()));
                        if ( m_pcCont ) {                               
                                ++m_pcCont->ui32RefCount;
                        }
                }
                LSE_CALLCTOR                                    ~CSharedPtr() {
                        Reset();
                }


                // == Types.
                typedef struct LSSTL_CONTAINER {
                        CAllocator *                            paAllocator;

                        LSUINT32                                        ui32RefCount;

                        _tType                                          tObj;
                } * LPLSSTL_CONTAINER, * const LPCLSSTL_CONTAINER;


                // == Operators.
                CSharedPtr<_tType> & LSE_CALL   operator = ( const CSharedPtr<_tType> &_spOther ) {
                        if ( _spOther.m_pcCont ) {
                                // Increase their reference count before decreasing ours.
                                ++_spOther.m_pcCont->ui32RefCount;
                        }
                        Reset();
                        m_pcCont = _spOther.m_pcCont;
                        m_ptDirect = _spOther.m_ptDirect;
                        return (*this);
                }

                _tType & LSE_CALL                               operator * () {
                        return (*Get());
                }

                const _tType & LSE_CALL                 operator * () const {
                        return (*Get());
                }

                _tType * LSE_CALL                               operator -> () {
                        return Get();
                }

                const _tType * LSE_CALL                 operator -> () const {
                        return Get();
                }

                LSE_CALL                                                operator LSUINTPTR() const {
                        return reinterpret_cast<LSUINTPTR>(Get());
                }


                // == Functions.
                LSBOOL LSE_CALL                                 New() {
                        CAllocator * paAllocator = NULL;
                        if ( m_pcCont ) {
                                paAllocator = m_pcCont->paAllocator;
                        }
                        Reset();
                        m_pcCont = static_cast<CSharedPtr<_tType>::LSSTL_CONTAINER *>(CMemLib::MNew( paAllocator ? paAllocator->GetAllocator() : NULL, LSSTL_CONTAINER ));
                        if ( !m_pcCont ) { return false; }
                        m_pcCont->paAllocator = paAllocator;
                        m_pcCont->ui32RefCount = 1UL;
                        m_ptDirect = &m_pcCont->tObj;
                        return true;
                }

                _tType * LSE_CALL                               Get() {
                        return m_ptDirect;
                }

                const _tType * LSE_CALL                 Get() const {
                        return m_ptDirect;
                }

                LSUINT32 LSE_CALL                               RefCount() const {
                        return m_pcCont ? m_pcCont->ui32RefCount : 0UL;
                }

                LSBOOL LSE_CALL                                 Valid() const {
                        return m_pcCont != NULL;
                }

                LSVOID LSE_CALL                                 Reset() {
                        if ( m_pcCont ) {
                                if ( --m_pcCont->ui32RefCount == 0UL ) {
                                        // Delete it.  Use the direct pointer to call the destructor.  This is the only
                                        //      way to get virtual destructors to be called properly in the case that this
                                        //      object was a cast of a different type of shared pointer.
                                        m_ptDirect->~_tType();
                                        if ( m_pcCont->paAllocator ) {
                                                m_pcCont->paAllocator->Free( m_pcCont );
                                        }
                                        else {
                                                CMemLib::Free( m_pcCont );
                                        }
                                }
                                m_pcCont = NULL;
                                m_ptDirect = NULL;
                        }
                }

                LSVOID LSE_CALL                                 Trash() {
                        if ( m_pcCont ) {
                                if ( --m_pcCont->ui32RefCount == 0UL ) {
                                        // Trash it.
                                        m_ptDirect->Trash();
                                }
                                m_pcCont = NULL;
                                m_ptDirect = NULL;
                        }
                }

                const LSSTL_CONTAINER * LSE_CALL
                                                                                GetContainer() const {
                        return m_pcCont;
                }


        protected :
                // == Members.
                LSSTL_CONTAINER *                               m_pcCont;

                _tType *                                                m_ptDirect;

        };

}       // namespace lstl

#endif  // __LSTL_SHAREDPTR_H__