StateUtil.h

Go to the documentation of this file.

/*
* This file is part of ArmarX.
*
* Copyright (C) 2011-2016, High Performance Humanoid Technologies (H2T), Karlsruhe Institute of Technology (KIT), all rights reserved.
*
* ArmarX is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
* ArmarX 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
* @package    ArmarXCore::Statechart
* @author     Mirko Waechter( mirko.waechter at kit dot edu)
* @date       2012
* @copyright  http://www.gnu.org/licenses/gpl-2.0.txt
*             GNU General Public License
*/
#pragma once
 
#include <ArmarXCore/observers/Event.h>
#include <ArmarXCore/observers/condition/Term.h>
#include "StateController.h"
 
 
namespace armarx
{
    class StatechartContext;
    using StatechartContextPtr = IceInternal::Handle<StatechartContext>;
 
    class ChannelRef;
    using ChannelRefPtr = IceInternal::Handle<ChannelRef>;
 
 
    class StateUtility :
        virtual public StateController
    {
        std::string contextString;
 
        bool checkEventIsHandled(const EventPtr& event) const;
    public:
        struct ActionEventIdentifier
        {
            ChannelRefBasePtr actionId;
            ConditionIdentifier conditionId;
        };
 
 
        template <class EventClass>
        EventPtr createEvent()
        {
            EventPtr event = new EventClass(this->stateName);
            return event;
        }
        EventPtr createEvent(const std::string& eventName, const StringVariantContainerBaseMap& properties = StringVariantContainerBaseMap());
    protected:
        ConditionIdentifier installCondition(const Term& condition, const EventPtr evt, const std::string& desc = "");
        template <class Eventclass>
        ConditionIdentifier installCondition(const Term& condition, const std::string& desc = "")
        {
            return installCondition(condition, createEvent<Eventclass>(), desc);
        }
 
        void removeCondition(ConditionIdentifier conditionId);
        ActionEventIdentifier setTimeoutEvent(int timeoutDurationMs, const EventPtr& evt);
        template <class Eventclass>
        ActionEventIdentifier setTimeoutEvent(int timeoutDurationMs)
        {
            return setTimeoutEvent(timeoutDurationMs, createEvent<Eventclass>());
        }
        ActionEventIdentifier setCounterEvent(int counterThreshold, const EventPtr& evt, int initialValue = 0);
        template <class Eventclass>
        ActionEventIdentifier setCounterEvent(int counterThreshold, int initialValue = 0)
        {
            return setCounterEvent(counterThreshold, createEvent<Eventclass>(), initialValue);
        }
 
        void removeTimeoutEvent(const ActionEventIdentifier& id);
        void removeCounterEvent(const ActionEventIdentifier& id);
 
        void sendEvent(const EventPtr event, StateBasePtr eventProcessor = nullptr);
        template <class Event>
        void sendEvent(StateBasePtr eventProcessor = nullptr)
        {
            sendEvent(createEvent<Event>(), eventProcessor);
        }
 
        //        //! Function for identifying this state
        //        std::string getScope() const;
        //        //! same function as getScope(), only shorter
        //        std::string s() const
        //        {
        //            return getScope();
        //        }
 
        //void startWorkerThread();
 
 
    private:
        std::vector< ConditionIdentifier > __installedConditionIdentifiers;
        std::vector< ChannelRefBasePtr > __installedTimerChannelRefs;
        std::vector< ChannelRefBasePtr > __installedCounterChannelRefs;
 
        void _removeInstalledConditions() override;
    };
 
}