StateMachine.h

Go to the documentation of this file.

/*
 * Copyright (C) by
 *   MetraLabs GmbH (MLAB), GERMANY
 *  and
 *   Neuroinformatics and Cognitive Robotics Labs (NICR) at TU Ilmenau, GERMANY
 * All rights reserved.
 *
 * Redistribution and modification of this code is strictly prohibited.
 *
 * IN NO EVENT SHALL "MLAB" OR "NICR" BE LIABLE TO ANY PARTY FOR DIRECT,
 * INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF
 * THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF "MLAB" OR
 * "NICR" HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * "MLAB" AND "NICR" SPECIFICALLY DISCLAIM ANY WARRANTIES, INCLUDING,
 * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
 * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
 * ON AN "AS IS" BASIS, AND "MLAB" AND "NICR" HAVE NO OBLIGATION TO
 * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS OR MODIFICATIONS.
 */

#ifndef _MIRA_STATEMACHINE_H_
#define _MIRA_STATEMACHINE_H_

#include <set>

#include <thread/Thread.h>
#include <utils/Path.h>
#include <xml/XMLDom.h>

#include <fw/Framework.h>

#include <sm/StateMachineExports.h>
#include <sm/Transition.h>
#include <sm/TransitionTarget.h>
#include <sm/StateMachineListener.h>

namespace mira { namespace sm {


template <typename T, typename Sequence = std::vector<T>, typename Compare = std::less<typename Sequence::value_type>>
class iterable_priority_queue : public std::priority_queue<T, Sequence, Compare>
{
public:
    typedef typename Sequence::iterator iterator;
    typedef typename Sequence::const_iterator const_iterator;

    iterator begin() { return this->c.begin(); }
    iterator end() { return this->c.end(); }
    const_iterator begin() const { return this->c.begin(); }
    const_iterator end() const { return this->c.end(); }

};


class MIRA_STATEMACHINE_EXPORT StateMachine
{
public:

    StateMachine(Authority* authority = NULL, const std::string& name = "");
    ~StateMachine();

    template<typename Reflector>
    void reflect(Reflector& r)
    {
        r.interface("IStateMachine");
        r.method("sendEvent", &StateMachine::sendEvent, this, "Send an event",
                 "event", "Event");
        r.method("sendEventByName",
                 (void(StateMachine::*)(const std::string&))(&StateMachine::sendEventByName),
                 this, "Send an event by name",
                 "event", "Event name", "MyEvent");
        r.method("sendEventByName",
                 (void(StateMachine::*)(const std::string&, const std::string&))(&StateMachine::sendEventByName),
                 this, "Send an event by name",
                 "event", "Event name", "jsonData", "Event data (JSON notation)");
        r.method("sendEventByName",
                 (void(StateMachine::*)(const std::string&, const std::string&, const uint64))(&StateMachine::sendEventByName),
                 this, "Send an event by name",
                 "event", "Event name", "jsonData", "Event data (JSON notation)", "delay", "Delay (in ms) before event is dispatched");
    }

    void load(const Path& filename);
    void run();
    void interrupt() { mRunning = false; }
    void sendEvent(const Event& event);
    void sendEventByName(const std::string& event)                               { sendEventByName(event, ""); }
    void sendEventByName(const std::string& event, const std::string& jsonData)  { sendEventByName(event, jsonData, 0); }
    void sendEventByName(const std::string& event, const std::string& jsonData, const uint64 delay);
    void cancelEvent(const std::string& sendid);
    bool inState(const std::string& state) const;
    bool isRunning() const { return mRunning; }
    void printStates();

    std::set<std::string> getConfiguration() const;
    void addListener(StateMachineListener* listener);
    std::string getNamespace() const;
    std::string resolveName(const std::string& name) const;
    std::string resolveServiceName(const std::string& name) const;

protected:

    void onChannelData(ChannelRead<void> data);

    void executeContent(XMLDom::iterator executable);
    void executePython(const std::string& script, bool ignoreErrors = false);
    void executeTransitionContent(TransitionList& t);
    void createDataModel(TransitionTargetPtr t);
    void setDataModel(TransitionTargetPtr t);

    bool isInFinalState(TransitionTargetPtr s);
    bool isType1(TransitionPtr t);
    bool isType2(TransitionPtr t);
    bool isType3(TransitionPtr t);
    bool preemtsTransition(TransitionPtr t1, TransitionPtr t2);
    TransitionList filterPreempted(TransitionList& enabledTransitions);
    bool matchesCondition(const std::string& condition);

    TransitionList selectTransitions(const std::string& event);
    TransitionList selectEventlessTransitions();
    void enterStates(TransitionList& tlist);
    void exitStates(TransitionList& tlist);
    void addStatesToEnter(TransitionTargetPtr t, TransitionTargetSet& statesToEnter, TransitionTargetSet& statesForDefaultEntry);
    TransitionTargetList getTargetStates(const std::string& target);

    void microstep(TransitionList& enabledTransitions);

    TransitionPtr parseTransition(XMLDom::iterator node, TransitionTargetPtr source);
    void parseDataModel(XMLDom::iterator node, TransitionTargetPtr parent);
    FinalStatePtr parseFinal(XMLDom::iterator node, TransitionTargetPtr parent);
    HistoryStatePtr parseHistory(XMLDom::iterator node, TransitionTargetPtr parent);
    TransitionTargetPtr parseState(XMLDom::iterator node, TransitionTargetPtr parent);
    TransitionTargetPtr parseParallel(XMLDom::iterator node, TransitionTargetPtr parent);
    void parseScriptSrc(XMLDom::iterator node);
    void parseExecutableContent(XMLDom::iterator node, const std::string& nodeInfo = "");

    void publishConfiguration();

public:

    std::string mName;
    XMLDom mDocument;
    uint32 mCurrentID;
    TransitionTargetPtr mSCXML;
    std::string mBinding;
    std::map<std::string, TransitionTargetPtr> mTargets;
    std::map<std::string, TransitionTargetSet> mHistoryValue;

    mutable boost::mutex mRunMutex;
    bool mRunning;
    TransitionTargetSet mConfiguration;
    struct EventLessComp {
        bool operator() (const Event& lhs, const Event&rhs) const {
            if (rhs.delay == 0 && lhs.delay != 0)
                return true;
            if (lhs.delay == 0)
                return false;
            Time lhsTime = lhs.invocationTime;
            Time rhsTime = rhs.invocationTime;
            assert(lhsTime.isValid() && rhsTime.isValid());
            return lhsTime > rhsTime;
        }
    };
    typedef iterable_priority_queue<Event, std::vector<Event>, EventLessComp> EventQueue;
    EventQueue mInternalEvents;
    EventQueue mExternalEvents;
    std::set<std::string> mSubscribedChannels;
    Channel<std::set<std::string>> mStateChannel;
    Channel<std::set<std::string>> mCompressedStateChannel;
    Event mCurrentEvent;

    std::vector<StateMachineListener*> mListener;

    boost::python::object mPythonContext;

    Authority* mParentAuthority;
    boost::shared_ptr<Authority> mAuthority;
};


}} // namespace

#endif