state Machine Demo

#include <stdlib.h>
#include <stdio.h>
#include <stdint.h>
#include <glib.h>
#include <unistd.h>

using namespace std;


typedef enum _EngineState
{
    ENGINE_SERVER_STATE_NONE,
    ENGINE_SERVER_STATE_READY,
    ENGINE_SERVER_STATE_STARTING,
    ENGINE_SERVER_STATE_SENDING,
    ENGINE_SERVER_STATE_PROCESSING,
    ENGINE_SERVER_STATE_MAX
}EngineState;


typedef enum _eEngineMsg
{
    ENGINE_MSG_NONE,
    ENGINE_MSG_START,
    ENGINE_MSG_REQUEST,
    ENGINE_MSG_STOP,
    ENGINE_MSG_MAX
}eEngineMsg;

typedef struct _EngineMsg
{
    eEngineMsg                  MsgType;
    long                        param_1;
    long                        param_2;
    char*                       param_3;
    bool                        param_4;
}EngineMsg;

typedef struct _ServerTask
{
    GThread             *Thread;
    GAsyncQueue         *Queue;
    gint                 running;
}ServerTask;


class CEngineServer
{
public:
    CEngineServer()
    {

    }

    virtual ~CEngineServer()
    {

    }

    void SetServerSRState(EngineState state)
    {
        m_EngineState = state;
    }
    EngineState GetServerSRState(void)
    {
        return m_EngineState;
    }
    static CEngineServer *GetInstance(void)
    {
        if(m_pInstance == NULL)
        {
            m_pInstance = new CEngineServer();
        }
        return m_pInstance;
    }
    bool SetServerSRMsg(eEngineMsg MsgType, long MsgParam1 = 0, long MsgParam2 = 0, void* MsgParam3 = NULL, bool openFlag = true)
    {
        if(m_pServerTask == NULL)
        {
            printf("[ERROR] Task is not created yet..\n");
            return false;
        }

        if(g_atomic_int_get(&m_pServerTask->running))
        {
            EngineMsg* tmpMsg = (EngineMsg*)malloc(sizeof(EngineMsg));
            if(tmpMsg == NULL)
            {
                printf("memory allocation fail");
                return false;
            }
            tmpMsg->MsgType = ENGINE_MSG_NONE;
            tmpMsg->param_1 = 0;
            tmpMsg->param_2 = 0;
            tmpMsg->param_3 = NULL;
            tmpMsg->param_4 = true;

            tmpMsg->MsgType = MsgType;
            tmpMsg->param_1 = (long)MsgParam1;
            tmpMsg->param_2 = (long)MsgParam2;
            tmpMsg->param_3 = (char*)MsgParam3;
            tmpMsg->param_4 = openFlag;

            g_async_queue_push(m_pServerTask->Queue, (gpointer)tmpMsg);

        }
        else
        {
            printf("[ERROR] Task is not running ..\n");
            return false;
        }

        printf("[Engine] success ..\n");
        return true;

    }
    static gpointer  t_ServerSRThread(gpointer data)
    {
        printf("t_ServerSRThread run !\n");
        CEngineServer* pSvr = CEngineServer::GetInstance();
        pSvr->SetServerSRState(ENGINE_SERVER_STATE_READY);

        EngineMsg loopMsg;
        while(g_atomic_int_get(&m_pServerTask->running))
        {
                EngineMsg* msg = NULL;
                msg = (EngineMsg*) g_async_queue_try_pop (m_pServerTask->Queue);

                if(msg != NULL)
                {
                    loopMsg.MsgType = msg->MsgType;
                    loopMsg.param_1 = msg->param_1;
                    loopMsg.param_2 = msg->param_2;
                    loopMsg.param_3 = msg->param_3;
                    loopMsg.param_4 = msg->param_4;
                }

                switch(pSvr->GetServerSRState())
                {
                    case ENGINE_SERVER_STATE_READY:
                    {
                        if(loopMsg.MsgType == ENGINE_MSG_START)
                        {
                            loopMsg.MsgType = ENGINE_MSG_NONE;
                            pSvr->SetServerSRState(ENGINE_SERVER_STATE_STARTING);
                            printf("[Engine] -READY- Start ..\n");
                        }
                        break;
                    }
                    case ENGINE_SERVER_STATE_STARTING:
                    {
                        if(loopMsg.MsgType == ENGINE_MSG_REQUEST)
                        {
                            int nServerMode = (int)loopMsg.param_1;
                            if(nServerMode == (0x01 | 0x02))
                            {
                                pSvr->SetServerSRState(ENGINE_SERVER_STATE_SENDING);
                                printf("[Engine] -STARTING- Open Success, -Sending-\n");
                            }
                        }
                        break;
                    }
                    case ENGINE_SERVER_STATE_SENDING:
                    {
                        if(loopMsg.MsgType == ENGINE_MSG_STOP)
                        {
                            loopMsg.MsgType = ENGINE_MSG_NONE;
                            pSvr->SetServerSRState(ENGINE_SERVER_STATE_PROCESSING);
                            printf("[Engine] -SENDING- Receive the Stop, Change Status to Processing ..\n");
                        }
                        break;
                    }
                    case ENGINE_SERVER_STATE_PROCESSING:
                    {
                        bool bEngineStop = true;
                        if(bEngineStop){
                            pSvr->SetServerSRState(ENGINE_SERVER_STATE_READY);
                            printf("[Engine] -ENGINE_SERVER_STATE_READY..\n");
                        }
                        if(loopMsg.MsgType == ENGINE_MSG_STOP)
                        {
                            pSvr->SetServerSRState(ENGINE_SERVER_STATE_READY);
                            printf("[Engine] -PROCESSING- ");
                        }
                        break;
                    }
                    default:
                        break;
                }
            }
        usleep(8000);
    }

    int CreateServerTask(void)
    {
        if(m_pServerTask == NULL)
        {
            m_pServerTask = g_new(ServerTask, 1);
            m_pServerTask->Queue = g_async_queue_new();
            g_atomic_int_set (&m_pServerTask->running, 1);
            m_pServerTask->Thread = g_thread_new("t_ServerSR", t_ServerSRThread,NULL);
            return 0;
        }
        else
        {
            printf("[Error] Create Engine Server Task is exist .. ");
            return 0;
        }
    }

private:
    EngineState m_EngineState;
    static ServerTask * m_pServerTask;
    static CEngineServer * m_pInstance;
};
ServerTask *CEngineServer::m_pServerTask = NULL;
CEngineServer* CEngineServer::m_pInstance = NULL;

int main()
{
    CEngineServer server;
    server.CreateServerTask();

    GMainLoop *mainloop = g_main_loop_new(NULL, FALSE);

    sleep(3);
    server.SetServerSRMsg(ENGINE_MSG_START);

    sleep(3);
    int mode = 0x01 | 0x02;
    server.SetServerSRMsg(ENGINE_MSG_REQUEST, mode);

    sleep(3);
    server.SetServerSRMsg(ENGINE_MSG_STOP);

    g_main_loop_run(mainloop);
    return 0;
}