IRefObject.h

#pragma once
#include "IAttributeFields.h"
#include "util/unordered_array.hpp"

namespace ParaEngine
{
    using namespace std;
    class IRefObject;

    typedef DWORD RefMessage;
    enum REF_MESSAGE
    {
        REFMSG_REF_DELETED = 0x1,
        REFMSG_REF_ADDED = 0x2,
    };

    /* Some return codes for references...
    * There would probably be a bunch of these.
    */
    enum RefResult {
        REF_FAIL,
        REF_SUCCEED,
        REF_DONTCARE,
        REF_STOP,
        REF_INVALID,
        // Return this from NotifRefChanged() when a REFMGS_TAGET_DELETED message is sent
        // if a ReferenceMaker should be removed from the scene when all its references are removed.
        REF_AUTO_DELETE
    };

    class RefListItem
    {
    public:
        IRefObject*  m_object;
        int m_tag;
        RefListItem( IRefObject*  ref, int nTag):m_object(ref),m_tag(nTag) {}
        RefListItem( IRefObject*  ref):m_object(ref), m_tag(0) {};
        RefListItem():m_object(NULL), m_tag(0) {};

        inline bool operator == (const RefListItem& r){
            return this->m_object == r.m_object;
        }

        inline bool operator == (const IRefObject* r){
            return this->m_object == r;
        }

        bool operator == (const char* r);
    };
    typedef unordered_array<RefListItem> RefList;

    class IRefObject : public IAttributeFields
    {
    protected:
        RefList m_references;

        std::string m_sIdentifer;       
    public:
        IRefObject() {} 
        virtual ~IRefObject();

        virtual const std::string& GetIdentifier();
        virtual void SetIdentifier(const std::string& sID);

        int GetNameW(std::u16string& out);
        const std::string& GetName();

        IRefObject* GetRefObjectByName(const char* sName);

        RefListItem* GetRefObjectByTag(int nTag);

        inline bool HasReferences(){ return !(m_references.empty());};
        
        RefResult AddReference(IRefObject* maker, int nTag = 0);

        RefResult DeleteReference(IRefObject* ref);

        RefResult DeleteAllRefs();

        int DeleteAllRefsByTag(int nTag = 0);

        inline RefList& GetRefList() { return m_references; }
        
        int GetRefObjNum();

        RefListItem* GetRefObject(int nIndex);
        
        virtual void OnRefAdded(IRefObject* rm, int nTag=0);

        virtual void OnRefDeleted(IRefObject* rm);

        //virtual RefResult AutoDelete(){ return REF_SUCCEED;};

        // Notify all dependent RefMakers concerned with the message 
        // virtual RefResult NotifyReferences(RefMessage message, bool propagate=true, IRefObject* pCaller=NULL);
    };
}