一步一步完善我的设计（4）：实现

#ifndef __ADD_TASK_H__

#define __ADD_TASK_H__

#include <stdio.h>

#include <iostream>

#include <string>

#include <vector>

#include "json/json.h"



using namespace std;





class Transaction

{

 public:

  virtual ~Transaction(){}

  virtual void Execute() = 0;

};





class CreateTaskTranscation : public Transaction

{

public:

        virtual ~CreateTaskTranscation(){}

        CreateTaskTranscation(){}

        virtual void Execute();

        virtual bool SetCommandNames()=0;

protected:

        //string m_taskId;

        vector<string> m_commandNames;

};



class CreateVideoTaskTranscation : public CreateTaskTranscation

{

        CreateVideoTaskTranscation()

        {

                

        }

public:

        ~CreateVideoTaskTranscation(){}

        static CreateVideoTaskTranscation& GetInstance();

        virtual bool SetCommandNames();

};



class CreateDocTaskTranscation : public CreateTaskTranscation

{

        CreateDocTaskTranscation()

        {

                

        }

public:

        ~CreateDocTaskTranscation(){}

        static CreateDocTaskTranscation& GetInstance();

        virtual bool SetCommandNames();

};



class CreateDpptTaskTranscation : public CreateTaskTranscation

{

        CreateDpptTaskTranscation()

        {

                

        }

public:

        ~CreateDpptTaskTranscation(){}

        static CreateDpptTaskTranscation& GetInstance();

        virtual bool SetCommandNames();

};



class AddTask

{

        AddTask *next; // 1. "next" pointer in the base class

protected:

        CreateTaskTranscation* m_createTaskTranscation;

        vector<string> m_commandNames;

public:

        virtual void GetInfo() = 0;

        AddTask()

        {

                next = NULL; 

        }

        void setNext(AddTask *n)

        {

                next = n;

        }

        void add(AddTask *n)

        {

                if (next)

                        next->add(n);

                else

                        next = n;

        }

        virtual void AddSpacificTask(Json::Value value)

        {

                if(next != NULL)

                        next->AddSpacificTask(value);

                else

                        printf("error");

                        // TODO: log

        }

};



class AddVideoTask : public AddTask

{

        AddVideoTask();

public:

        virtual void GetInfo(){}

        static AddVideoTask& GetInstance();

        virtual void AddSpacificTask(Json::Value value);

};



class AddDocTask : public AddTask

{

        AddDocTask();

public:

        virtual void GetInfo(){}

        static AddDocTask& GetInstance();

        virtual void AddSpacificTask(Json::Value value);

};



class AddDpptTask : public AddTask

{

        AddDpptTask();

public:

        virtual void GetInfo(){}

        static AddDpptTask& GetInstance();

        virtual void AddSpacificTask(Json::Value value);

};



#endif

#include "AddTask.h"

#include "TsManager.h"

#include "CommandDb.h"



//class CommandDb;

extern CommandDb GCommandDb;

////////////////////////// CreateTaskTranscation ////////////////////////



void CreateTaskTranscation::Execute()

{



}



////////////////////////CreateVideoTaskTranscation //////////////////////



CreateVideoTaskTranscation& CreateVideoTaskTranscation::GetInstance()

{

        static  CreateVideoTaskTranscation instance_;

        return instance_;

}



bool CreateVideoTaskTranscation::SetCommandNames()

{

        

}





////////////////////////CreateDocTaskTranscation //////////////////////





CreateDocTaskTranscation& CreateDocTaskTranscation::GetInstance()

{

        static  CreateDocTaskTranscation instance_;

        return instance_;

}



bool CreateDocTaskTranscation::SetCommandNames()

{

        

}



////////////////////////CreateDpptTaskTranscation //////////////////////



CreateDpptTaskTranscation& CreateDpptTaskTranscation::GetInstance()

{

        static  CreateDpptTaskTranscation instance_;

        return instance_;

}

bool CreateDpptTaskTranscation::SetCommandNames()

{

        

}



//==========================  AddTask ===========================



//========================  AddVideoTask =========================

AddVideoTask& AddVideoTask::GetInstance()

{

        static  AddVideoTask instance_;

        return instance_;         

}



AddVideoTask::AddVideoTask()

{

        m_createTaskTranscation = &CreateVideoTaskTranscation::GetInstance();

        GCommandDb.GetCommandNameInSpecificTsType(TS_VIDEO,m_commandNames);

}



void AddVideoTask::AddSpacificTask(Json::Value value)

{

        if(value["command"].asString() == "video_trans_task") {

                cout << "handle video task!" << endl;

        } else {

                AddTask::AddSpacificTask(value);

        }

}



//=========================  AddDocTask ==========================



AddDocTask& AddDocTask::GetInstance()

{

        static  AddDocTask instance_;

        return instance_;         

}



AddDocTask::AddDocTask()

{

        m_createTaskTranscation = &CreateDocTaskTranscation::GetInstance();

        GCommandDb.GetCommandNameInSpecificTsType(TS_DOCUMENT_LINUX,m_commandNames);

        GCommandDb.GetCommandNameInSpecificTsType(TS_DOCUMENT_OFFICE,m_commandNames);

        GCommandDb.GetCommandNameInSpecificTsType(TS_DOCUMENT_WPS,m_commandNames);

}



void AddDocTask::AddSpacificTask(Json::Value value)

{

        if(value["command"].asString() == "doc_trans_task") {

                cout << "handle doc task!" << endl;

                

        } else {

                AddTask::AddSpacificTask(value);

        }

}



//========================  AddDpptTask ==========================

AddDpptTask& AddDpptTask::GetInstance()

{

        static  AddDpptTask instance_;

        return instance_;         

}



AddDpptTask::AddDpptTask()

{

        m_createTaskTranscation = &CreateDpptTaskTranscation::GetInstance();

        GCommandDb.GetCommandNameInSpecificTsType(TS_DYNAMIC_PPT,m_commandNames);

}



void AddDpptTask::AddSpacificTask(Json::Value value)

{

        if(value["command"].asString() == "dynamic_ppt_trans_task"){

                cout << "handle dppt task!" << endl;

        } else {

                AddTask::AddSpacificTask(value);

        }

}

#ifndef __COMMAND_DB_H__

#define __COMMAND_DB_H__

#include <string>

#include "json/json.h"

#include "TsManager.h"

#include "Task.h"



using namespace std;





class Command 

{

protected:

        string m_commandName;

        TsProperty m_tsProperty;

        bool m_isUseTs;

        TsType m_tsType;

        TaskType m_taskType;

public:

        Command();

        virtual ~Command();



        string GetCommansName(){ return m_commandName;}

        TsType GetTsType(){return m_tsType;}

        TaskType GetTaskType(){return m_taskType;}

        

        virtual bool BuildTsCmd(const Json::Value& appCmd,Json::Value& tsCmd);

        virtual bool BuildTsResponse(const Json::Value& tsResult,Json::Value& tsResponse);

        

        virtual bool BuildAppResult(const Json::Value& tsResult,Json::Value& appResult); 

        virtual bool  BuildAppResponse(const Json::Value& appCmd,Json::Value& appResponse) = 0; 

};





///////////////////////////////// specific command //////////////////////////////////////

class CommandServerStatus : public Command

{

public:

        CommandServerStatus();

        ~CommandServerStatus();

        virtual bool  BuildAppResponse(const Json::Value& appCmd,Json::Value& appResponse);

};





class CommandVideoMessage : public Command

{

public:

        CommandVideoMessage()

        {

                m_commandName = "video_message_task";

                m_isUseTs = true;

                m_tsType = TS_VIDEO;

                m_tsProperty = TS_LIGHT;

                m_taskType = VideoTask;

        }



        ~CommandVideoMessage(){}



        virtual bool  BuildAppResponse(const Json::Value& appCmd,Json::Value& appResponse);

};





class CommandVideoTrans : public Command

{

public:

        CommandVideoTrans()

        {

                m_commandName = "video_trans_task";

                m_isUseTs = true;

                m_tsType = TS_VIDEO;

                m_tsProperty = TS_HEAVY;

                m_taskType = VideoTask;

        }



        ~CommandVideoTrans(){}



        virtual bool  BuildAppResponse(const Json::Value& appCmd,Json::Value& appResponse);

};



class CommandPrintScreen : public Command

{

public:

        CommandPrintScreen()

        {

                m_commandName = "print_screen_task";

                m_isUseTs = true;

                m_tsType = TS_VIDEO;

                m_tsProperty = TS_LIGHT;

                m_taskType = VideoTask;

        }

        ~CommandPrintScreen(){}



        virtual bool  BuildAppResponse(const Json::Value& appCmd,Json::Value& appResponse);

};



class CommandVideoCut : public Command

{

public:

        CommandVideoCut()

        {

                m_commandName = "video_cut_task";

                m_isUseTs = true;

                m_tsType = TS_VIDEO;

                m_tsProperty = TS_LIGHT;

                m_taskType = VideoTask;

        }



        virtual bool  BuildAppResponse(const Json::Value& appCmd,Json::Value& appResponse);

};



class CommandVideoMerge : public Command

{

public:

        CommandVideoMerge()

        {

                m_commandName = "video_merge_task";

                m_isUseTs = true;

                m_tsType = TS_VIDEO;

                m_tsProperty = TS_HEAVY;

                m_taskType = VideoTask;

        }



        virtual bool  BuildAppResponse(const Json::Value& appCmd,Json::Value& appResponse);

};





class CommandDocTrans : public Command

{

public:

        CommandDocTrans()

        {

                m_commandName = "doc_trans_task";

                m_isUseTs = true;

                m_taskType = DocTask;

        }



        virtual bool  BuildAppResponse(const Json::Value& appCmd,Json::Value& appResponse);

};





class CommandDynamicPptTrans : public Command

{

public:

        CommandDynamicPptTrans()

        {

                m_commandName = "dynamic_ppt_trans_task";

                m_isUseTs = true;

                m_tsType = TS_DYNAMIC_PPT;

                m_taskType = DpptTask;

        }



        virtual bool  BuildAppResponse(const Json::Value& appCmd,Json::Value& appResponse);

};



class CommandTaskProgress : public Command

{

public:

        CommandTaskProgress()

        {

                m_commandName = "task_progress_request";

                m_isUseTs = false;

                m_taskType = NoTsTask;

        }



        virtual bool  BuildAppResponse(const Json::Value& appCmd,Json::Value& appResponse);

};



/////////////////////////////////  CommandDb  ///////////////////////////////////////



class CommandDb

{



public:

        CommandDb();

        ~CommandDb();

        bool AddCommand(Command* cmd);

        bool GetCommandNameInSpecificTaskType(TaskType taskType,vector<string>& CommandNames);

private:

        map<string,Command*> m_commands;

};

#endif

#include "CommandDb.h"

#include "TsManager.h"



CommandServerStatus GCmdServerStatus;

CommandVideoMessage GCmdVideoMessage;

CommandVideoTrans GCmdVideoTrans;

CommandPrintScreen GCmdPrintScreen;

CommandVideoMerge GCmdVideoMerge;

CommandDocTrans GCmdDocTrans;

CommandDynamicPptTrans GCmdDynamicPptTrans;





CommandDb GCommandDb;





////////////////////////////////////// Command //////////////////////////////////////////



Command::Command()

{



}



Command::~Command()

{



}





bool Command::BuildTsCmd(const Json::Value& appCmd,Json::Value& tsCmd)

{



        return true;

}



bool Command::BuildTsResponse(const Json::Value& tsResult,Json::Value& tsResponse)

{



        return true;

}



bool Command::BuildAppResult(const Json::Value& tsResult,Json::Value& appResult)

{



        return true;

}





//////////////////////////////////// CommandServerStatus ///////////////////////////////////////////



CommandServerStatus::CommandServerStatus()

{

        m_commandName = "server_status_task";

        m_isUseTs = false;

        m_taskType = NoTsTask;

}



CommandServerStatus::~CommandServerStatus()

{



}



bool  CommandServerStatus::BuildAppResponse(const Json::Value& appCmd,Json::Value& appResponse)

{



        return true;

}



////////////////////////////////////// CommandVideoMessage //////////////////////////////////////

bool  CommandVideoMessage::BuildAppResponse(const Json::Value& appCmd,Json::Value& appResponse)

{



        return true;

}

////////////////////////////////////// CommandVideoTrans ///////////////////////////////////////

bool  CommandVideoTrans::BuildAppResponse(const Json::Value& appCmd,Json::Value& appResponse)

{



        return true;

}



///////////////////////////////////// CommandPrintScreen ///////////////////////////////////////

bool CommandPrintScreen::BuildAppResponse(const Json::Value& appCmd,Json::Value& appResponse)

{



        return true;

}



///////////////////////////////////// CommandVideoCut /////////////////////////////////////////

bool CommandVideoCut::BuildAppResponse(const Json::Value& appCmd,Json::Value& appResponse)

{



        return true;

}





///////////////////////////////////// CommandVideoMerge //////////////////////////////////////

bool CommandVideoMerge::BuildAppResponse(const Json::Value& appCmd,Json::Value& appResponse)

{



        return true;

}





//////////////////////////////////// CommandDocTrans ////////////////////////////////////////

bool CommandDocTrans::BuildAppResponse(const Json::Value& appCmd,Json::Value& appResponse)

{



        return true;

}



/////////////////////////////////// CommandDynamicPptTrans //////////////////////////////////

bool CommandDynamicPptTrans::BuildAppResponse(const Json::Value& appCmd,Json::Value& appResponse)

{



        return true;

}





///////////////////////////////// CommandTaskProgress ///////////////////////////////////////

bool CommandTaskProgress::BuildAppResponse(const  Json::Value & appCmd, Json::Value & appResponse)

{



}





/////////////////////////////////////// CommandDb ////////////////////////////////////////

CommandDb::CommandDb()

{

        AddCommand(&GCmdServerStatus);

        AddCommand(&GCmdVideoMessage);

        AddCommand(&GCmdVideoTrans);

        AddCommand(&GCmdPrintScreen);

        AddCommand(&GCmdVideoMerge);

        AddCommand(&GCmdDocTrans);

        AddCommand(&GCmdDynamicPptTrans);

}



CommandDb::~CommandDb()

{



}





bool CommandDb::AddCommand(Command* cmd)

{

        m_commands[cmd->GetCommansName()] = cmd;

        return true;

}





bool CommandDb::GetCommandNameInSpecificTaskType(TaskType taskType,vector<string>& CommandNames)

{

        map<string,Command *>::iterator it;

        

        for(it=m_commands.begin();it!=m_commands.end();++it){

                if(it->second->GetTaskType() == taskType)

                        CommandNames.push_back(it->first);

        }



}