FSM/FSM_OOP/childtest/ParentFSM.c

#include <stdio.h>
#include <stdlib.h>

#include "parentFSM.h"
#include "FSM_protected.h"

#define     DEFAULT_STATE       Idle
#define     NAME                Parent

typedef struct _ParentFSM
{   
    FSM base;
}ParentFSM;

typedef enum _State{
    Idle,
    A,
    B,
    C,

    Count_State,
}State;

typedef enum _Event{
    Idle_Event,
    Start,
    A2B,
    B2A,
    B2C,
    C2A,

    Count_Event,
}Event;

const static char *stateStr[] = {
    "Idle",
    "A",
    "B",
    "C",
};

const static char *eventStr[] = {
    "Idle",
    "Start",
    "A2B",
    "B2A",
    "B2C",
    "C2A",
};


State StartHandler(){
    printf(" start ");
    return A;
}

State A2BHandler(){
    printf(" A2B ");
    return B;
}

State B2AHandler(){
    printf(" B2A ");
    return A;
}

State B2CHandler(){
    printf(" B2C ");
    return C;
}

State C2AHandler(){
    printf(" C2A ");
    return A;
}


void A_enterAction(){
    printf(" enterA ");
}
void A_duringAction(){
    printf(" duringA ");
}
void A_exitAction(){
    printf(" exitA ");
}

void B_enterAction(FSM *pFSM){
    printf(" enterB ");
    
    FSM *cFSM = pFSM->privateVars.childFSM[0];
    cFSM->vtbl.step(cFSM);
}
void B_duringAction(FSM *pFSM){
    printf(" duringB ");

    FSM *cFSM = pFSM->privateVars.childFSM[0];
    cFSM->vtbl.step(cFSM);
}
void B_exitAction(FSM *pFSM){
    FSM *cFSM = pFSM->privateVars.childFSM[0];
    cFSM->vtbl.reset(cFSM);

    printf(" exitB ");
}


void C_enterAction(){
    printf(" enterC ");
}
void C_duringAction(){
    printf(" duringC ");
}
void C_exitAction(){
    printf(" exitC ");
}



static void setupHandler(FSMHandler* fcns){
    typedef int (*transitionHandlerPtr)(FSM* pFSM);
    #define     AVOID_WARNING(handler)        (transitionHandlerPtr)handler

    fcns->duringActionTable[A] = A_duringAction;
    fcns->duringActionTable[B] = B_duringAction;
    fcns->duringActionTable[C] = C_duringAction;

    fcns->enterActionTable[B] = B_enterAction;
    fcns->enterActionTable[C] = C_enterAction;
    fcns->enterActionTable[A] = A_enterAction;

    fcns->exitActionTable[A] = A_exitAction;
    fcns->exitActionTable[B] = B_exitAction;
    fcns->exitActionTable[C] = C_exitAction;

    fcns->transitionTable[index(Idle, Start)] = AVOID_WARNING(StartHandler);
    fcns->transitionTable[index(A, A2B)] = AVOID_WARNING(A2BHandler);
    fcns->transitionTable[index(B, B2A)] = AVOID_WARNING(B2AHandler);
    fcns->transitionTable[index(B, B2C)] = AVOID_WARNING(B2CHandler);
    fcns->transitionTable[index(C, C2A)] = AVOID_WARNING(C2AHandler);
}



/* 
    用户自定义事件选择逻辑—————————————————begin 
*/
Event peventArr[20] = {
    Idle_Event,
    Start,
    A2B,
    Idle_Event,
    Idle_Event,
    Idle_Event,
    Idle_Event,
    Idle_Event,
    B2C,
    C2A,
    A2B,
    B2A,
};

static Event selectEvent(ParentFSMData *data){
    return peventArr[data->arrindex];
}
/* 
    用户自定义事件选择逻辑————————end
*/

static void printFSM(ParentFSM* pFSM){
    printf("\tParentFSM: ");

    printf("当前状态:%s, 当前事件:%s, 动作：", stateStr[pFSM->base.privateVars.curState], eventStr[pFSM->base.privateVars.curEvent]);
}


static void step(ParentFSM* pFSM){
    printFSM(pFSM);
    stepBaseFSM(BASE_FSM(pFSM));
}

static void reset(ParentFSM* pFSM){
    resetBaseFSM(BASE_FSM(pFSM));
    printf(" ParentFSM-reset");
}

static void initData(ParentFSM *pFSM){
    ParentFSMData *data = (ParentFSMData *)malloc(sizeof(ParentFSMData));
    data->arrindex = 0;

    pFSM->base.data = data;
}


ParentFSM *createParentFSM(){
  
    ParentFSM *pFSM;
    pFSM = (ParentFSM *)newBaseFSM(Count_State, Count_Event, DEFAULT_STATE);

    pFSM->base.vtbl.step = (Avoid_WARNING_void_FSM)step;
    pFSM->base.vtbl.selectEvent = (Avoid_WARNING_int_data)selectEvent;
    pFSM->base.vtbl.initData = (Avoid_WARNING_void_FSM)initData;
    pFSM->base.vtbl.setupHandler = (Avoid_WARNING_void_fcns)setupHandler;

    
    constructFSM((FSM_Ptr)pFSM);
    return pFSM;
}