C++ FSM类代码示例

int main (int argc, char **argv)
{
	std::string input;
	std::string file = "./10021.response";
	char buf[1024];

	if (argc > 1)
		file = argv[1];

	FSM fsm;
	fsm.init(file);

	// XXX: integrating into deceptiond framework
	// timeouts can be set via the InputStream obj
	// '>>' tokenizes using \s ;( this should be different using
	// the InputStream
	while(1) {
		std::cin.getline(buf, 1023, '\n');
		if (buf[0] == 0)
			break;
		input = buf;
		fsm.parse(input);
	}

	return 0;
}

void HandlePollCompleteResponse(
        FSM & fsm,
        const mf::api::upload::poll_upload::Response & response
    )
{
    if (response.quickkey)
    {
        if (response.filename)
        {
            // Filename was changed
            fsm.ProcessEvent(event::PollComplete{
                *response.quickkey,
                *response.filename
                });
        }
        else
        {
            fsm.ProcessEvent(event::PollComplete{
                *response.quickkey,
                fsm.filename()
                });
        }
    }
    else
    {
        fsm.ProcessEvent(event::Error{
            make_error_code(api::api_code::ContentInvalidData),
            "Successful response missing quickkey"
            });
    }
}

/* Create random input file with i states and MAX_EVENTS events */
void create_test_file(const string& filename, int states, int events) {
	FSM fsm = create_initial_FSM(states, events);
	make_accessible(fsm);
	ofstream file_out(filename);
	if (EXTENSION == ".txt") fsm.print_txt(file_out);
	else if (EXTENSION == ".fsm") fsm.print_fsm(file_out);
	file_out.close();
}

	bool FSMTask::onenter(Agent* pAgent)
	{
		BEHAVIAC_UNUSED_VAR(pAgent);
		FSM* fsm = (FSM*)this->m_node;
		this->m_activeChildIndex = 0;

		this->m_currentNodeId = fsm->GetInitialId();

		return true;
	}

top (sc_module_name name) : sc_module (name), clk("Clk", period){
	fsm = new FSM("Statemachine", 100, 30); //Creating a new state machine with limit = 100.
	fsm->tick(clk);
	fsm->portA(Aout);
	fsm->X(Xin);

	Xcount = 0;
	Acount = 0;
	Xinput = false;

	SC_HAS_PROCESS(top);
	SC_CTHREAD(testbed, clk);
}

bool TestCase3::onInit()
{
    FSM *fsm = new FSMA();
    fsm->create("fsm3").start();
    fsm->subscribeBcEvent("TestEvt1");


    EvtStream data;
    std::string input = "000 hello world! 300 abc123";
    data << 23 << input;
    fsm->sendBcEvent("TestEvt1", data);

    return true;
}

FSM * FSM::create(std::string state, std::function<void()> onEnter)
{
	FSM* fsm = new FSM(state, onEnter);
	if ( fsm && fsm->init())
	{
		fsm->autorelease();
		return fsm;
	}
	else
	{
		CC_SAFE_DELETE(fsm);
		return nullptr;
	}
}

/* This function rerturns the fsm to be equivalent to (fsm1|fsm2) 
 * XXX : Use with caution. This modifies fsm1, but the return value must be 
 * stored back in fsm1 for this to be effective.
 *
 * DO NOT try something like "fsm1 | fsm1", this will ave 
 */
FSM * FSM::operator | (FSM& rhs)
{
	/* Create a new (empty) start and end FSM */
	FSM *startFSM = new FSM();
	FSM *endFSM   = new FSM();

	/* Concatenate one of the two fsm-s with the start and end */
	this->concatenate (*endFSM);
	startFSM->concatenate (*this);

	/* Create a transition to the start state of other fsm */
	rhs.concatenate (*endFSM);

	/* Create a transition from the end state of other fsm */
	startFSM->startState.createTransition ('e', EPSILON, &(rhs.startState));
	return startFSM;
}

FSM* IRParser::parseFSM(llvm::MDNode* node){
    FSM* fsm = new FSM();

    //Parse initial state
    MDString* initialState = cast<MDString>(node->getOperand(0));

    //Parse all fsm state
    MDNode* stateArray = cast<MDNode>(node->getOperand(1));

    for (unsigned i = 0, e = stateArray->getNumOperands(); i != e; ++i){
        MDString* stateMD = cast<MDString>(stateArray->getOperand(i));
        fsm->addState(stateMD->getString());
    }

    // set the initial state after initializing the states
    fsm->setInitialState(initialState->getString());


    //Parse transition
    MDNode* transitionsArray = cast<MDNode>(node->getOperand(2));

    for (unsigned i = 0, e = transitionsArray->getNumOperands(); i != e; ++i){
        MDNode* transitionArray = cast<MDNode>(transitionsArray->getOperand(i));
        MDString* source = cast<MDString>(transitionArray->getOperand(0));


        Value* targetValue = transitionArray->getOperand(1);

        //In case of "undefined" state, no target are given
        if (targetValue != NULL){
            MDNode* targetsArray = cast<MDNode>(targetValue);
            for (unsigned j = 0, f = targetsArray->getNumOperands() ; j != f; ++j){
                MDNode* targetArray = cast<MDNode>(targetsArray->getOperand(j));

                Action* action = getAction(cast<MDNode>(targetArray->getOperand(0)));
                MDString* target = cast<MDString>(targetArray->getOperand(1));


                fsm->addTransition(source->getString(), target->getString(), action);
            }
        }
    }

    return fsm;
}

int main()
{
    enum Message { on, off, ack };
    Message messageArray[10] = { on,off,off,ack,ack,ack,ack,on,off,off };
    FSM* context = new FSM(B::getInstance());
    for (int index=0; index < 10; index++)
    {
        if(messageArray[index] == on)
            context->on();
        else if(messageArray[index] == off)
            context->off();
        else if(messageArray[index] == ack)
            context->ack();
        cout<<endl;
    }

    return 1;
}

FSM fsm_simple() {
    FSM fsm;
    int even = fsm.addState("Even", true);
    int odd = fsm.addState("Odd");
    fsm.addTransition(even, even, 1, "1");
    fsm.addTransition(even, odd, 0, "0");
    fsm.addTransition(odd, odd, 1, "1");
    fsm.addTransition(odd, even, 0, "0");
    return fsm;
}

void StartPoll(const std::string & upload_key, FSM & fsm)
{
    if (upload_key.empty())
    {
        assert(!"Reached poll upload without upload key");
        fsm.ProcessEvent(
                event::Error{make_error_code(uploader::errc::LogicError),
                             "Filsize unavailable."});
        return;
    }

    auto fsmp = fsm.AsFrontShared();

    fsm.GetSessionMaintainer()->Call(
            mf::api::upload::poll_upload::Request(upload_key),
            [fsmp, upload_key](
                    const mf::api::upload::poll_upload::Response & response)
            {
                HandlePollResponse(upload_key, *fsmp, response);
            });
}

void make_accessible(FSM& fsm) {
	vector<int> current_access(fsm.nstates);
	int current = 0; //Initial state
	queue<int> BFS; //Breadth First Search
	BFS.push(current); 
	do_BFS(BFS, current, current_access, fsm);
	/* While there exists an inaccessible state */
	int inaccessible_state = fsm.find_inaccessible(current_access);
	while(inaccessible_state != -1) {
		int event_out = rand() % fsm.nevents;
		int state_out = rand() % fsm.nstates;
		while (transition_is_invalid(fsm, current_access, state_out, event_out)) {
			state_out = rand() % fsm.nstates;
			event_out = rand() % fsm.nevents;
		}
		/* Add transition from accessible state to inaccessible state */
		fsm.transitions[state_out][event_out] = inaccessible_state;
		BFS.push(inaccessible_state);
		do_BFS(BFS, inaccessible_state, current_access, fsm);
		inaccessible_state = fsm.find_inaccessible(current_access);
	}
}

void disconnectedUpdate() {
  if(Particle.connected()) {
    connectionFsm.transitionTo(Online);
  } else if(connectionFsm.timeInCurrentState() > DISCONNECTED_TIMEOUT) {
    connectionFsm.transitionTo(Offline);
  }
}

void error(String message) {
  if(self.isInState(Start)) {
    sd.initErrorPrint(&terminal);
  } else {
    sd.errorPrint(&terminal);
  }
  terminal.flush();

  errorMessage = message;
  self.transitionTo(Error);
}