一个使用模板,并具有模板和派生双重灵活性的ResourceManager

一个使用模板的资源管理器，
该类可以扩充，也可以使用基本功能，
有模板和派生双重灵活性。

//以下为ResourceMgr.h
//潘李亮，版权所有，2005.11-4

#ifndef __TEMPLATE_RESOURCE_MGR_H__
#define __TEMPLATE_RESOURCE_MGR_H__
#include <map>
#include <vector>
using namespace std;


template <typename ResType> class TBaseResMgr;

//-------------------------------------------------
//定义一个空资源类，如果不想派生这个ResMgr
//的话，需要你的ResType用下面两个函数来load/unload
//-------------------------------------------------
class XNullRes
{
public:
        bool load(const char* resName){return true;}
        bool unload(){return true;}
};

//-------------------------------------------------
//资源句柄类
//-------------------------------------------------
template  <typename ResType> class TResHandle
{
        typedef TBaseResMgr<ResType> MyResMgr;

        friend class MyResMgr;
        MyResMgr* m_pResMgr;
        int       m_iData;
        //面向资源管理器的类

public:
        TResHandle(){m_pResMgr = NULL;}
        MyResMgr* getOwner(){return m_pResMgr;}
        int       data(){return m_iData;}

        //面向用户的类
public:
        ResType* getResource();
        bool     confirm();
        bool     invalidate();
        bool     isHandle(){return m_pResMgr != NULL;}
};

//------------------------------------------------------
//Resource Manager的接口，
//所有的不同类型的Resource Manager都可以用这个接口来进行
//一些相同功能的操作
//------------------------------------------------------
class IResManager
{
public:
        virtual void unload() = 0;
        virtual void loadAll() = 0;

        virtual void update(unsigned int passedTime) = 0;
        virtual void release() = 0;
};
//------------------------------------------------------
//资源管理器类的基类
//基类不知道如何 创建和销毁一个实际资源，
//只负责管理逻辑
//------------------------------------------------------

template <typename ResType> class TBaseResMgr : public IResManager
{
protected:
        struct ResSlot
        {
                ResType* m_pRes;
                string   m_ResName;
        };

        typedef vector<ResSlot>     ResSlots;
        typedef map<string,int>     StringToIndexMap;
        typedef TResHandle<ResType> MyResHandle;
        ResSlots                    m_ResSlots;
        StringToIndexMap            m_StrToIndexMap;


        virtual ResType*   _load(const char* strResName) = 0;
        virtual bool       _unload(ResType* pRes) = 0;

        MyResHandle        _add(ResType* pRes,const char* strResName)
        {
                MyResHandle handle;
                handle.m_iData = m_ResSlots.size();
                handle.m_pResMgr = this;

                m_StrToIndexMap.insert(StringToIndexMap::value_type(strResName,handle.m_iData));
                m_ResSlots.push_back(ResSlot());
                ResSlot& Slot = m_ResSlots[handle.m_iData];
                Slot.m_pRes = pRes;
                Slot.m_ResName = strResName;
                return handle;
        }
public:

        ResType*   getResource(MyResHandle& handle)
        {
                if(isHandle(handle) == false)
                        return NULL;
                ResSlot& slot = m_ResSlots[handle.m_iData];
                return slot.m_pRes;
        }

        MyResHandle add(const char* strResName,bool bLoadImmediate)
        {
                MyResHandle handle = find(strResName);
                if(handle.isHandle())
                {
                        return handle;
                }
                else
                {
                        ResType* pRes =  NULL;
                        if(bLoadImmediate)
                        {
                                pRes = _load(strResName);
                                if(pRes == NULL)
                                {
                                        MyResHandle handle;
                                        return handle;
                                }
                        }
                        handle = _add(pRes,strResName);
                        return handle;
                }
        }

        bool isHandle(MyResHandle& handle)
        {
                if(handle.m_iData < 0 ) return false;
                if(handle.m_iData >= (int)m_ResSlots.size()) return false;
                if(handle.m_pResMgr != this) return false;
                return true;
        }

        bool confirm(MyResHandle& handle)
        {
                if( !isHandle(handle))
                        return false;
                ResSlot& Slot = m_ResSlots[handle.m_iData];
                if(Slot.m_pRes != NULL)
                        return true;
                else
                {
                        Slot.m_pRes = _load(Slot.m_ResName.c_str());
                        return true;
                }
        }

        MyResHandle find(const char* strResName)
        {
                MyResHandle handle;
                StringToIndexMap::iterator iPos = m_StrToIndexMap.find(strResName);
                if(iPos != m_StrToIndexMap.end() )
                {
                        handle.m_iData = iPos->second;
                        handle.m_pResMgr = this;
                        return handle;
                }
                handle.m_pResMgr = NULL;
                return handle;
        }

        bool     unload(MyResHandle handle)
        {
                assert(handle.m_pResMgr == this);
                ResSlot& slot = m_ResSlots[handle.m_iData];
                return _unload(slot.m_pRes);
        }

        //虚函数，行为可以继承
public:
        virtual void loadAll()
        {
                size_t i = 0;
                size_t n = m_ResSlots.size();
                for(i = 0 ; i < n ; ++i)
                {
                        ResSlot& Slot = m_ResSlots[i];
                        if(Slot.m_pRes == NULL)
                        {
                                Slot.m_pRes = _load(Slot.m_ResName.c_str());
                        }
                }
        }

        virtual void update(unsigned int passedTime)
        {

        }

        virtual void    unload()
        {
                size_t nRes = m_ResSlots.size();
                for(size_t i = 0 ; i < nRes ; i++)
                {
                        ResSlot& slot = m_ResSlots[i];
                        _unload(slot.m_pRes);
                }
        }

        virtual void release()
        {
                unload();
                m_ResSlots.clear();
                m_StrToIndexMap.clear();
        }
};

//-----------------------------------------------------------------------------------
//一个通用的ResMgr，
//只要求ResType实现了XNullRes的接口
//-----------------------------------------------------------------------------------
template <typename ResType> class TCommonResMgr: public TBaseResMgr<ResType>
{
protected:
        ResType* _load(const char* strResName)
        {
                ResType* pRes = new ResType;
                pRes->load(strResName);
                return pRes;
        }
        bool       _unload(ResType* pRes)
        {
                pRes->unload();
                delete pRes;
                return ;
        }
};


//--------------------------------------------------------------------
// Resource Hanlde 的实现函数
//--------------------------------------------------------------------
template <typename ResType> ResType* TResHandle<ResType>::getResource()
{
        return m_pResMgr->getResource(*this);
}

template <typename ResType> bool TResHandle<ResType>::confirm()
{
        return m_pResMgr->confirm(*this);
}

template <typename ResType> bool TResHandle<ResType>::invalidate()
{
        return m_pResMgr->unload(*this);
}

#endif

//end of the ResourceMgr.h

//--------------------------------------------------------------------------------------------------------
//以下类具体实现了一个ResManager
//因为XRMTexture没有load/unload函数，所以需要重载TBaseResMgr.
//如果XRMTexture实现了XNullRes的两个函数，那么可以简单使用 TCommonResMgr类
//--------------------------------------------------------------------------------------------------------

class XRMTextureMgr;
class XRMTexture
{
        unsigned int m_hTexture;
        int          m_iStage;
        string       m_TextureName;

        friend class XRMTextureMgr;
        XRMTexture(){}
public:
        bool create(const char* filename);
        bool create(const char* filename,const char* buf,int buflen);
        void apply(int iStage);
        void load();
        void unload();
        void free();
};
typedef TResHandle<XRMTexture>  HRMTexture;
class XRMTextureMgr: public TBaseResMgr<XRMTexture>
{
        XRMTexture* _load(const char* strResName)
        {
                XRMTexture* pTex = new XRMTexture;
                if(pTex->create(strResName) ==false)
                {
                        delete pTex;
                        return NULL;
                }
                return pTex;
        }
        bool       _unload(XRMTexture* pTex)
        {
                pTex->unload();
                delete pTex;
                return true;
        }
public:
        HRMTexture addTexture(const char* filename,const char* buf,int buflen,bool bLoadImmediate)
        {
                HRMTexture handle = find(filename);
                if(handle.isHandle())
                {
                        return handle;
                }
                else
                {
                        XRMTexture* pRes =  new XRMTexture;
                        bool ret = pRes->create(filename,buf,buflen);
                        if(ret == false)
                        {
                                delete pRes;
                                HRMTexture hTexture;
                                return hTexture;
                        }
                        handle = _add(pRes,filename);
                        return handle;
                }
        }
};

extern XRMTextureMgr g_RMTexMgr;


//==================================
//具体使用如下
//==================================
HRMTexture hTexture = g_RMTexture.add("pll.jpg",true);
if(hTexture.isHandle() == false)
hTexture = g_RMTexture.addTexture("pll.jpg", pFileDataInMem,file_len,true);
assert(hTexture.isHandle() );

//使用纹理对象，
if(hTexture.getResource())  hTexture.getResource()->apply(0);