SEO		[PR] 爆速!無料ブログ 無料ホームページ開設 無料ライブ放送

               

---

dKingyoGameManager.h

解説を見る。

#include "stdafx.h"

#ifndef DONOT_USE_GAMEMANAGER__ //こいつが宣言されていたらコンパイルしない。

#ifndef _DKINGYO_GAME_MANAGER__
#define _DKINGYO_GAME_MANAGER__


#include "dKingyoMemoryManager.h"
#include "dKingyoFrameMemory.h"
#include "dKingyoDataWrapper.h"
#include "dkutilDebug.h"
#include "dkutilTL.h"



namespace dkutil{
    namespace dkingyoGM{









//以下のコメントアウトした奴はあるだけ邪魔。
//dKingyoIsWarehouserクラスに任せよう＾＾　d金魚は倉庫業者〜〜＾＾；

//タスクを参照するためのデータ構造
//typedef struct tugTasClassManagement{
//  std::string string_str;
//  DWORD ID;
//  TasClassTask *p;
//}TasClassManagement;

//すでに作ってあるタスクのデータ
//typedef struct tugTasClassData{
//  std::string string_str;
//  DWORD ID;
//  TasClassTask data;
//}TasClassData;


//タスクネームのマクロとか
#ifdef _DEBUG
# define _SetDebugTaskName(tasclass_p,s) strncpy(tasclass_p->name,s,TASKNAME_SIZE)
# define _NULLDebugTaskName(tasclass_p) ZeroMemory(tasclass_p->name,TASKNAME_SIZE)

#else
# define _SetDebugTaskName(tasclass_p,s)
# define _NULLDebugTaskName(tasclass_p)

#endif 




//global (あまり使いたくなかったけど･･･




//名前のとおり、タスクメモリーのプールです＾＾
//全部スタティックメンバーって邪道だなぁ
class OnlyForTaskMemoryPool{
    enum{
        tcsnum=100,//string max
    };
    static dkutil::memory::dKingyoArrayOneByOneDynamic<TasClassTask> m;
    static char taskcountstr[tcsnum];//タスクのデフォルトデバック名
    static DWORD m_counter;
    static DWORD m_now_count;
public:
    OnlyForTaskMemoryPool(){
        static int once =Initialize();
    }
    ~OnlyForTaskMemoryPool(){}
    static int Initialize(){
        m_counter=0;
        m_now_count=0;
        memset(taskcountstr,0,sizeof(taskcountstr));
        _snprintf(taskcountstr,tcsnum,"taskcount=%d",m_counter);
        return 0;
    }
        
    static inline TasClassTask *GetNewTaskDomain(DWORD *ID,
                                                        int state,int type,int prio,
                                                        DWORD counter,VOIDFUNC setfunc,VOIDFUNC setkill,
                                                        size_t setsize=0,char *debugname=taskcountstr
    ){
    TasClassTask *p=m.GetArray(ID);
#ifdef _DEBUG
        if(!p){MB("Can't GetNewTaskDomain");throw -1;}
#endif
        p->m_state = state;
        p->m_type = type;
        p->m_prio = prio;
        p->counter = counter;
        p->func = setfunc;
        p->kill = setkill;
        p->ID = *ID;
        p->worksize = setsize;
        p->next=p->prev=NULL;//next prev はNULL
        _SetDebugTaskName(p,debugname);
#ifdef _DEBUG
        m_counter++;//カウンタインクリメント
        _snprintf(taskcountstr,tcsnum,"taskcount=%d",m_counter);//次の名前を入れる。
#endif
        m_now_count++;
        return p;
    }
    static inline int FreeDomain(DWORD *ID){
        m_now_count--;
        return m.ReleaseArray(ID);
    }
    static inline TasClassTask *GetDomain(DWORD n){
        //TasClassTask *p = m.Data(
        return &m.Data()[n];
    }
    static inline DWORD GetCount(){return m_now_count;}
};

inline TasClassTask *CreateTask(int prio,DWORD counter,VOIDFUNC exe,VOIDFUNC kill)
{
    DWORD ID;
    return OnlyForTaskMemoryPool::GetNewTaskDomain(
                                            &ID,enuRUN,enuDEFAULT,prio,
                                                        counter,exe,kill);
}

inline TasClassTask *CreateNoCounterTask(int prio,VOIDFUNC exe,VOIDFUNC kill)
{
    return CreateTask(prio,NO_NEXT_COUNTER,exe,kill);
}


class dKingyoTaskPriorityMap : public dkutil::memory::dKingyoDataWrapperMap<int,TasClassTask *>{
public:
    dKingyoTaskPriorityMap(){}
    virtual ~dKingyoTaskPriorityMap(){}
    virtual TasClassTask *GetData(int key){
        int prev_prio=HIGHEST_PRIORITY_OF_SYSTEM_TASK;//前のプライオリティを保存
        for(map_it it=m.begin();it!=m.end();it++){
            //前の優先順序  取得したいイテレータ(int keyの入れるべき場所) < 今の優先順序
            if((*it).first >= key && prev_prio <= key){
                return m[(*it).first];
            }
            prev_prio=(*it).first;
            it++;
        }
        //throw -1;//not found
        return NULL;
    }
};

/*      
typedef dKingyoDataWrapperOverwriteAcceptMap<int,TasClassTask *> GAMEMANAGER_TASK_SERVER

inline  GAMEMANAGER_TASK_SERVER *GetGameManagerTaskServer(){
    //dkutil::singleton<dKingyoDataWrapperMap<int,VOIDFUNC> > m;
    static GAMEMANAGER_TASK_SERVER m;
    return &m;
}
*/



        



//このクラスはシングルトンで生成すること！！
class dKingyoGameManager_v01 : IdKingyoGameManager<TasClassTask>{
protected:
    OnlyForTaskMemoryPool mpool;//タスクメモリプール。
    //番兵さんを格納しておきます＾＾ int = priority , TasClassTask * = 番兵
    dKingyoTaskPriorityMap msentinel;
    //KillingTime用のキューです＾＾；
    typedef std::deque<TasClassTask *> KILLQUEUE;
    KILLQUEUE killq;

    TasClassTask *top,*tail;//頭と尻尾
    TasClassTask *now;//今、実行中のタスク
    DWORD topID,tailID;
    bool m_InitedFlag;

    //番兵たちによって探させる
    inline TasClassTask *SarchInsertTopbySentinel(int dekaprio){
            TasClassTask *temp;
            return (NULL != (temp=msentinel.GetData(dekaprio))) ? temp : GetTop();
            //アホ値が帰ってきたら最初からサーチすることになる。
    }
    
    int InitGameManager_v01();
public:
    dKingyoGameManager_v01(){
        m_InitedFlag=false;
        topID=tailID=NULL;
        top=tail=now=NULL;
        InitGameManager_v01();
    }
    virtual ~dKingyoGameManager_v01(){}
    virtual int KillingTime();
    virtual bool isOK(){return m_InitedFlag;}
    virtual int TaskRun();
    virtual int OpeningRun();
    inline TasClassTask *GetTop(){return top;}
    inline TasClassTask *GetTail(){return tail;}
    inline TasClassTask *GetNowTask(){return now;}
    //番兵を入れる
    inline bool SetSentinelTask(TasClassTask *syuzin){
    #ifdef _DEBUG
        if(false==msentinel.SetData(syuzin->m_prio,syuzin)){
            MB("Please break!!! sentinel data overlapped!!!Don't push the ok buttom!!!");
        }
        return true;
    #else
        return msentinel.SetData(syuzin->m_prio,syuzin);
    #endif
    }
    
    virtual int InsertTask( TasClassTask *item){
        //int i;
        TasClassTask *t;
        
        t=SarchInsertTopbySentinel(item->m_prio);

        //効率が悪いが簡単なので順次探索＾＾；(最近のPCの性能ならば大丈夫であろう
        while (t != NULL) {
            // 指定プライオリティの最後尾にタスクを追加します
            if (t->m_prio >  item->m_prio) {
                //ODS("OKOK\n");
                item->prev         = t->prev;   // 追加タスクの前部リンクに検索タスクの前部リンクをセット
                item->next        = t;      // 追加タスクの後部リンクに検索タスクをセット
                t->prev->next = item;           // 検索タスクの前タスクの後部リンクに追加タスクをセット
                t->prev       = item;           // 検索タスクの前部リンクに追加タスクをセット
                return 0;//成功
            }
            // 検索位置を進める     
            t = t->next;
        }
        return -1;//ダメです。
    }
    inline TasClassTask *SarchTask(int get_prio_min,int get_prio_max,int *GetNum,TasClassTask *confirmation=NULL)
    {
        TasClassTask *t;
        int prio_reserved;
        TasClassTask *t_reserved=NULL;
        bool findflag=false;
        int count=0;
        t=SarchInsertTopbySentinel(get_prio_min);
        while (t != NULL) {
            //普通にアドレス指定で見つけたらこれ。
            if (t == confirmation){
                return t;
            }
            //ひとつだけを検索しろと言われたら
            if(get_prio_min==get_prio_max){
                if(findflag==false){//まだ見つけていない。
                    if(t->m_prio == get_prio_min){ //同じプライオリティを見つけた。
                        prio_reserved=get_prio_min;//保存しておく
                        t_reserved=t;//保存しておく
                        findflag=true;//すでに見つけたことを知らせる
                        count++;
                    }
                }else{//すでに見つけている場合。
                    if(t->m_prio ==get_prio_min){//同じプライオリティを探す
                        count++;
                    }else{
                        *GetNum=count;//いくつ見つけたか？を入れる。
                        return t_reserved;//最初に見つけたポインタを返す。
                    }
                }
                //いやいや、min <= 対象 <= maxまでを検索しろ！といわれたら。
            }else{
                if(findflag==false){//まだ見つけていない
                    if(t->m_prio >= get_prio_min && t->m_prio <= get_prio_max)
                    {//min < t < max
                        t_reserved=t;//保存しておく
                        findflag=true;
                        count++;
                    }
                }else{
                    if(t->m_prio >= get_prio_min && t->m_prio <= get_prio_max){
                        count++;
                    }else{
                        *GetNum = count;
                        return t_reserved;
                    }
                }
            }
            // 検索位置を進める     
            t = t->next;
        }
        return NULL;//ダメです。
    }
    virtual int DeleteTask( TasClassTask *item){
        killq.push_back(item);
        return 0;
    }
    virtual int DeleteTask(int priority){
        return DeletePriorityTask(priority,priority);
    }
    virtual int DeletePriorityTask(int min,int max)
    {//minからmaxまでのプライオリティ範囲のタスクを消す
        TasClassTask *temp;
        int GetNum;
        if(NULL == (temp=SarchTask(min,max,&GetNum))) return -1;
        //GetNumでもらった数だけループする。
        for(int i=0;i<GetNum;i++){
            killq.push_back(temp);
            temp = temp->next;
        }   
        return 0;
    }

    virtual int DebugWindow(int,int){return 0;};
    virtual int GetVersion(){return 0x0001;}//Version0.01らしい。
    inline OnlyForTaskMemoryPool *GetTaskPool(){return &mpool;}
};

inline dkutil::memory::dKingyoFrameMemory &GetGlobalDoamin(){
    static dkutil::memory::dKingyoFrameMemory m_fm;
    static bool flag =(bool) m_fm.Construct(dkutil::DTL::GetKB<3>::value);
    return m_fm;
}
inline int InitOnceGlobal(){
    static bool flag=false;
    if(flag==false){
        DKUTIL_MULTITHREAD_SYNDROME_LOCK();
        if(false==flag){
            GAMEMANAGER_DEFAULTGLOBALDATA dd;
            GetSingletonGlobalProcess().DefaultGameManagerGlobalMemorySetting(&dd);
            GetGlobalDoamin().AttachFrame((void *)&dd,sizeof(dd),enuDefaultTasClassData,
                NULL,"GlobalMemory of dKingyoGameManager(TasClass)");
            flag=true;
            DKUTIL_MULTITHREAD_SYNDROME_UNLOCK();
            return 0;
        }
        DKUTIL_MULTITHREAD_SYNDROME_UNLOCK();
        return -1;
    }
    return -1;
}


inline int AttachGlobal(void *mem,size_t size,DWORD ID,
                                        VOIDFUNC ReleaseFunc,char *error_str="no comment"){
    return GetGlobalDoamin().AttachFrame(mem,size,ID,ReleaseFunc,error_str);
}
inline int PopTailGlobal(char *error_str="no comment"){
    return GetGlobalDoamin().PopTailFrame(error_str);
}
inline void *ChangeFromIDGlobal(DWORD id){
    return NULL;//実装してない＾＾；    
}


#ifdef USE_DKINGYO_OBJECT_TEST

extern void dKingyoGameManager_v01_Test();

#endif //end of USE_DKINGYO_OBJECT_TEST


}//end of dkingyoGM
}//end of dkutil

#endif // end of once include

#endif // end of  DONOT_USE_GAMEMANAGER__

---