Executor.h

Go to the documentation of this file.

/*
 *    scampl4cpp/engine
 *
 *    Copyright by European Southern Observatory, 2012
 *    All rights reserved
 *
 *    This library is free software; you can redistribute it and/or
 *    modify it under the terms of the GNU Lesser General Public
 *    License as published by the Free Software Foundation; either
 *    version 2.1 of the License, or (at your option) any later version.
 *
 *    This library is distributed in the hope that it will be useful,
 *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *    Lesser General Public License for more details.
 *
 *    You should have received a copy of the GNU Lesser General Public
 *    License along with this library; if not, write to the Free Software
 *    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
 *    02111-1307 USA.
 */
 
/*
 * $Id: Executor.h 1061 2015-07-13 15:03:59Z landolfa $
 */
 
#ifndef SCXML4CPP_EXECUTOR_H
#define SCXML4CPP_EXECUTOR_H
 
#ifndef __cplusplus
#error This is a C++ include file and cannot be used from plain C
#endif
 
#ifndef SCXML4CPP_STATECOMPARATOR_H
#include "scxml4cpp/StateComparator.h"
#endif
 
#ifndef SCXML4CPP_EVENTQUEUE_H
#include "scxml4cpp/EventQueue.h"
#endif
 
#ifndef SCXML4CPP_HELPER_H
#include "scxml4cpp/Helper.h"
#endif
 
#include <queue>
#include <set>
#include <string>
 
namespace scxml4cpp {
 
class StateMachine;
class State;
class Transition;
class Event;
class EventQueue;
class Context;
class EventListener;
class StatusListener;
 
class Executor {
   public:
    enum EventHandlingPolicy { SILENT = 0, REJECT, DEFFERRED };
 
    Executor(StateMachine&, Context*, EventQueue&);
    ~Executor();
 
    std::string formatStatus(const bool usefullyqualified = false);
    std::string formatModel();
    std::set<State*> getStatus();
    void printStatus(const bool usefullyqualified = false);
 
    void setContext(Context*);
 
    void setEventHandlingPolicy(const EventHandlingPolicy policy);
    EventHandlingPolicy getEventHandlingPolicy();
 
    void addEventListener(EventListener* eventListener);
    void removeEventListener(EventListener* eventListener);
    void removeAllEventListener();
 
    void addStatusListener(StatusListener* statusListener);
    void removeStatusListener(StatusListener* statusListener);
    void removeAllStatusListener();
 
    void startSM();
    void stopSM();
    void start();
    void stop();
 
    void run();
 
    void postEvent(Event* e);
    void processEvent();
    void processEvent(Event* e);
 
    bool isRunning();
    bool isFinal();
 
   private:
    StateMachine& mStateMachine;
    std::set<State*> mCurrentStatus;
    std::set<State*> mPreviousStatus;
    std::set<State*> mStatesToInvoke;
    std::queue<Event*> mInternalEvents;
    EventQueue& mExternalEvents;
    bool mContinue;  // is interpreted started
    bool mFinal;     // is top level final state reached
    StateComparator mStateComparator;
    Context* mContext;
    Helper mHelper;
    EventHandlingPolicy mEventHandlingPolicy;
    std::list<EventListener*> mEventListeners;
    std::list<StatusListener*> mStatusListeners;
 
    StateComparator getStateComparator();
    void processInternalEvents();
    void exitInterpreter();
    std::list<Transition*> selectEventlessTransitions();
    std::list<Transition*> selectTransitions(Event* e);
    void microstep(std::list<Transition*>& enabledTransitions);
    void exitStates(std::list<Transition*>& enabledTransitions);
    void executeTransitionContent(std::list<Transition*>& enabledTransitions);
    void enterStates(std::list<Transition*>& enabledTransitions);
    void addStatesToEnter(State* s, State* root, std::list<State*>& statesToEnter,
                          std::list<State*>& statesForDefaultEntry);
 
    void notifyEventListeners(Event* e);
    void notifyStatusListeners(std::set<State*>& status);
 
    Executor(const Executor&);             
    Executor& operator=(const Executor&);  
};
 
}  // namespace scxml4cpp
 
#endif  // SCXML4CPP_EXECUTOR_H