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.
 */
 
#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 <list>
#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& stateMachine, Context* context, EventQueue& events);
 
    ~Executor();
 
    std::string formatStatus(const bool usefullyqualified = false);
 
    std::string formatModel();
 
    std::list<State*> getStatus();
 
    void printStatus(const bool usefullyqualified = false);
 
    void setContext(Context* 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;
 
    /*
     * use std::list<State*> instead of std::set<State*>
     * to preserve the insertion order.
     *
     * Note that std::set<> is ordered container and the default order
     * is given by comparing the State* pointers. The values of the pointers
     * depends on the memory allocation algorithm. Most of the times but NOT
     * always new pointers have larger values.
     *
     * By using std::list we lose the check of already exiting elements
     * in the container. However this check has only linear complexity.
     * Better adding the check and keep the order, than keeping the check
     * and have to sort again after.
     */
    std::list<State*> mCurrentStatus;
    std::list<State*> mPreviousStatus;
    std::list<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;
 
    void addUniqueStateToList(State* s, std::list<State*>& l);
 
    //void addStateToInvoke(State* s);
    void addStateToCurrentStatus(State* s);
 
    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::list<State*>& status);
 
    Executor(const Executor&);             
    Executor& operator=(const Executor&);  
};
 
}  // namespace scxml4cpp
 
#endif  // SCXML4CPP_EXECUTOR_H