命令调度机制

#pragma once

#include <vector>
#include <iostream>
#include <functional>
using namespace std;

class CMD;
typedef function<void(CMD*)> CmdHandler;
#define CMD_HANDLER(CLASS_NAME,FUNC_NAME) bind(&CLASS_NAME::FUNC_NAME,this,placeholders::_1)

class CMD{
public:
    inline int getID(){
        return mID;
    }

    //注册命令处理器
    static void addHandler(CMD* cmd,CmdHandler handler){
        //添加命令处理插槽
        int num=cmd->mID-mHandlers.size()+1;
        if(num>0){
            for(int i=0;i<num;i++)
                mHandlers.push_back(vector<CmdHandler>());
        }
        //增加命令
        mHandlers[cmd->mID].push_back(handler);
    }

    //执行命令
    static void execute(CMD* cmd){
        if(cmd->mID>mHandlers.size())
            return;
        vector<CmdHandler>& handlers=mHandlers[cmd->mID];
        for(int i=0;i<handlers.size();i++)
            handlers[i](cmd);
    }
protected:
    int mID;//每个类唯一
       string mName;//方便调试

    static int ID_GEN;//产生唯一连续id号
    static vector<vector<CmdHandler>> mHandlers;//命令处理器
};

//无参数
#define CMD_0(CMD_NAME)\
class CMD_NAME : public CMD{\
public:\
    CMD_NAME(){\
        static int ID=(++ID_GEN);\
           mName=#CMD_NAME;\
        mID=ID;\
    }\
};\
//1个参数
#define CMD_1(CMD_NAME,PARAM1)\
class CMD_NAME : public CMD{\
public:\
    CMD_NAME(){\
        static int ID=(++ID_GEN);\
           mName=#CMD_NAME;\
        mID=ID;\
    }\
public:\
    PARAM1;\
};\
//2个参数
#define CMD_2(CMD_NAME,PARAM1,PARAM2)\
class CMD_NAME : public CMD{\
public:\
    CMD_NAME(){\
        static int ID=(++ID_GEN);\
           mName=#CMD_NAME;\
        mID=ID;\
    }\
public:\
    PARAM1;\
    PARAM2;\
};\

//定义命令
CMD_0(CMD_CLOSE);
CMD_0(CMD_RENDER);
CMD_1(CMD_PICK,vector<int> mResults);

#include "Cmd.h"

int CMD::ID_GEN=-1;
vector<vector<CmdHandler>> CMD::mHandlers;

class SceneEditor{
public:
    SceneEditor(){
    }
    void doPick(){
        CMD_PICK cmd;
        cmd.mResults.push_back(5);
        cmd.mResults.push_back(100);
        CMD::execute(&cmd);
    }
};

class MaterialEditor{
public:
    MaterialEditor(){
        CMD_PICK cmd;
        CMD::addHandler(&cmd,CMD_HANDLER(MaterialEditor,onPick));
    }
protected:
    void onPick(CMD* cmd){
        CMD_PICK* pick=(CMD_PICK*)cmd;
        vector<int>& results=pick->mResults;
        for(int i=0;i<results.size();i++)
            cout<<"MaterialEditor handle pick:"<<results[i]<<endl;
    }
};

int main(int argc,char** argv){
    SceneEditor* se=new SceneEditor();
    MaterialEditor* me=new MaterialEditor();
    se->doPick();
    return 0;
}

发这文章前慎重考虑了一下：如此没技术含量的东西该不该记录下来。

还是写一下吧，虽然它跟回调函数，监听者模式之类的没本质区别，但在实际项目中确实有效。

这是为了应对一个无处不在的问题：一处改变，几处做出反应。

这里之所以叫命令而不是消息，是因为它是立即执行的，会阻塞主线程。

添加命令处理器:

CMD_PICK cmd;
CMD::addHandler(&cmd,CMD_HANDLER(MaterialEditor,onPick));

发送命令：

CMD_PICK cmd;
cmd.mResults.push_back(5);
cmd.mResults.push_back(100);
CMD::execute(&cmd);

定义命令，传入类名与参数：

CMD_0(CMD_CLOSE);
CMD_0(CMD_RENDER);
CMD_1(CMD_PICK,vector<int> mResults);

需要特别注意的是通过static变量为每个类生成唯一id，id就是数组下标，可直接定位到命令处理器。

麻烦的是循环发送命令，只能警告程序员尽量不要在命令处理器中发送命令。

最麻烦的是这些命令处理器何时失效。

相比这两大麻烦，我更受不了c++的类成员函数指针或者为一个函数写一个类称之为接口然后去继承。

所以还是用到了项目中，当然实际的会比这跟复杂健壮一些。

以后再慢慢改善。