PERef.h

#pragma once
#include "PERefPtr.h"
#include <string>

namespace ParaEngine
{
    class IType;
    struct ObjectEvent;

    /* base class for reference counted objects. */
    class PE_CORE_DECL CRefCounted
    {
    public:
        void addref()const
        {
            ++m_refcount;
        }

        bool delref()const
        {
            return --m_refcount<=0;
        }
        int GetRefCount()const 
        {
            return m_refcount;
        }
        //all overridden functions should call this function in order to use the "delete when 
        //reference is zero" scheme
        virtual int Release();
        
        CRefCounted* AddToAutoReleasePool();

    protected:
        CRefCounted();
        virtual ~CRefCounted();
    protected:
        mutable int m_refcount;
    };

    class CRefCountedOne : public CRefCounted
    {
    protected:
        CRefCountedOne();
    };

    template <typename T>
    class PE_CORE_DECL weak_ref_object : public CRefCounted
    {
    public:
        weak_ref_object() : m_watched_object(0){};
        weak_ref_object(T* pWatchedObject) : m_watched_object(pWatchedObject){};

        virtual ~weak_ref_object(){};

        inline bool expired() const
        {
            return m_watched_object == nullptr;
        }
        inline bool IsValid() const
        {
            return m_watched_object != nullptr;
        }

        inline T* get() const { return m_watched_object; }
        inline operator T* () { return m_watched_object; }
        inline void UnWatch(){
            m_watched_object = nullptr;
        }

    protected:
        T* m_watched_object;
    };

    template<class RealT, class DefaultPointerClass = RealT> 
    struct PE_CORE_DECL weak_ptr
    {
    public:
        typedef weak_ref_object<RealT> WeakRefObject_type;

        weak_ptr() : px(0)
        {
        }

        ~weak_ptr()
        {
            if (px != 0)
                px->Release();
        }

        weak_ptr(WeakRefObject_type * p)
            :px(p)
        {
            if (px != 0)
                px->addref();
        }

        template<class Y>
        explicit weak_ptr(Y * p) :px(0)
        {
            static_assert(std::is_convertible<Y*, RealT*>::value, "Invalid Type for ParaEngine::weak_ptr!");
            if (p)
                px = p->GetWeakReference().get_weak_ref_object();
            
            if (px != 0)
                px->addref();
        }

        weak_ptr(const weak_ptr & r) : px(r.get_weak_ref_object()) // never throws
        {
            if (px != 0)
                px->addref();
        }

        weak_ptr & operator=(const weak_ptr & r) // never throws
        {
            if (px != r.get_weak_ref_object())
            {
                if (px != 0)
                    px->Release();
                px = r.get_weak_ref_object();
                if (px != 0)
                    px->addref();
            }
            return *this;
        }

        weak_ptr& operator=(WeakRefObject_type * r)
        {
            if(px != r)
            {
                if (px != 0)
                    px->Release();
                px = r;
                if (px != 0)
                    px->addref();
            }
            return *this;
        }

        template<class Y>
        weak_ptr& operator=(Y* r) // never throws
        {
            static_assert(std::is_convertible<Y*, RealT*>::value, "Invalid Type for ParaEngine::weak_ptr!");

            if (get() != r)
            {
                if (px != 0)
                    px->Release();
                
                px = r ? r->GetWeakReference().get_weak_ref_object() : 0;

                if (px != 0)
                    px->addref();
            }
            return *this;
        }

        template<class Y>
        operator Y* () const // never throws
        {
            static_assert(std::is_convertible<Y*, RealT*>::value, "Invalid Type for ParaEngine::weak_ptr!");
            return (Y*)get();
        }

        DefaultPointerClass& operator* () const // never throws
        {
            PE_ASSERT(px != 0 && (*px).get()!=0);
            return *((*px).get());
        }

        DefaultPointerClass * operator-> () const // never throws
        {
            PE_ASSERT(px != 0);
            return (DefaultPointerClass*) ((*px).get());
        }

        DefaultPointerClass * get() const // never throws
        {
            return (DefaultPointerClass*) ((px != 0) ? (*px).get() : nullptr);
        }

        inline WeakRefObject_type * get_weak_ref_object() const // never throws
        {
            return px;
        }

        operator bool() const
        {
            return px != 0 && (*px).get()!=nullptr;
        }

        bool operator! () const // never throws
        {
            return px == 0 || (*px).get() == nullptr;
        }

        int use_count() const // never throws
        {
            return (px != 0 && (*px).get()) ? ((*px).get())->GetRefCount() : 0;
        }

        bool unique() const // nothrow
        {
            return use_count() == 1;
        }

        void reset()
        {
            if (px != 0)
            {
                px->Release();
                px = 0;
            }
        }

        inline bool operator==(weak_ptr const & b) const
        {
            return this->px == b.get_weak_ref_object();
        }

        inline bool operator!=(weak_ptr const & b) const
        {
            return this->px != b.get_weak_ref_object();
        }

        /* this conflicts with implicit cast operator
        
        template<class Y>
        inline bool operator==(Y const * b) const
        {
            return this->get() == b;
        }

        template<class Y>
        inline bool operator!=(Y const * b) const
        {
            return this->get() != b;
        }*/

        inline void UnWatch(){
            if (px)
                px->UnWatch();
        }
    private:
        // contained pointer
        WeakRefObject_type * px;
    };

    class PE_CORE_DECL IObject :public CRefCounted
    {
    public:
        typedef ParaEngine::weak_ptr<IObject> WeakPtr_type;

        virtual void Clone(IObject* obj)const;
        virtual IObject* Clone()const;
        virtual bool Equals(const IObject *obj)const;
        virtual const IType* GetType()const { return nullptr; };
        virtual std::string ToString()const;

        WeakPtr_type& GetWeakReference();
        
        virtual int ProcessObjectEvent(const ObjectEvent& event) { return 0; };
    protected:
        //One should not delete the object, use Release() instead
        //all overridden destructor should follow this rule
        virtual ~IObject();

        WeakPtr_type m_weak_reference;
    };

    typedef ParaEngine::weak_ptr<IObject> WeakPtr;
}