State.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 "StateUtil.h"
 
#include <ArmarXCore/observers/variant/Variant.h>
#include <ArmarXCore/observers/variant/StringValueMap.h>
#include <ArmarXCore/observers/variant/SingleTypeVariantList.h>
 
#include <type_traits>
 
 
namespace armarx
{
    template <class StateType>
    class StateTemplate;
 
    class RemoteState;
    using RemoteStatePtr = IceInternal::Handle<RemoteState>;
 
    class State;
    using StatePtr = IceInternal::Handle<State>;
 
    class State :
        virtual public StateUtility
    {
 
    protected:
        State();
        State(const State& source);
        State& operator=(const State& source);
        ~State() override;
    public:
        bool init(StatechartContextInterface* context, StatechartManager* manager);
 
 
 
 
        unsigned int getId() const;
 
        std::string getGlobalIdString() const;
 
 
 
        StateBasePtr getInitState() const;
 
        bool isUnbreakable() const;
 
        StateParameterMap& getOutputParameters() override;
 
        template<typename T>
        typename std::enable_if_t<std::is_base_of_v<VariantDataClass, T>, IceInternal::Handle<T> >
        getOutput(const std::string& key) const;
 
        template<typename T>
        typename std::enable_if_t < !(std::is_base_of_v<VariantDataClass, T> || std::is_base_of_v<VariantContainerBase, T>), T >
        getOutput(const std::string& key) const;
 
 
    public:
 
        StateBasePtr addState(StateBasePtr pNewState);
 
        template <class derivedState>
        IceInternal::Handle<derivedState> addState(std::string const& stateName = "");
 
        virtual RemoteStatePtr addRemoteState(std::string stateName, std::string proxyName, std::string instanceName = "");
 
        virtual RemoteStatePtr addDynamicRemoteState(std::string instanceName);
 
 
        TransitionIceBase&  addTransition(EventPtr event, StateIceBasePtr sourceState,
                                          StateIceBasePtr destinationState,
                                          ParameterMappingIceBasePtr mappingToNextStatesInput = nullptr,
                                          ParameterMappingIceBasePtr mappingToParentStatesLocal = nullptr,
                                          ParameterMappingIceBasePtr mappingToParentStatesOutput = nullptr);
 
        template <class EventType>
        TransitionIceBase&  addTransition(StateIceBasePtr sourceState,
                                          StateIceBasePtr destinationState,
                                          ParameterMappingIceBasePtr mappingToNextStatesInput = nullptr,
                                          ParameterMappingIceBasePtr mappingToParentStatesLocal = nullptr,
                                          ParameterMappingIceBasePtr mappingToParentStatesOutput = nullptr);
 
        template <class EventType>
        TransitionIceBase&  addTransitionFromAllStates(
            StateIceBasePtr destinationState,
            ParameterMappingIceBasePtr mappingToNextStatesInput = nullptr,
            ParameterMappingIceBasePtr mappingToParentStatesLocal = nullptr,
            ParameterMappingIceBasePtr mappingToParentStatesOutput = nullptr);
 
        void inheritInputFromSubstate(std::string stateName);
 
        bool addToInput(const std::string& key, const ContainerType& type, bool optional, VariantContainerBasePtr defaultValue = VariantContainerBasePtr());
 
        bool addToInput(const std::string& key, VariantTypeId type, bool optional, VariantPtr defaultValue = VariantPtr());
 
        bool addToLocal(const std::string& key, VariantTypeId type, VariantPtr defaultValue = VariantPtr());
 
        bool addToLocal(const std::string& key, const ContainerType& type, VariantContainerBasePtr defaultValue = VariantContainerBasePtr());
 
        bool addToOutput(const std::string& key, VariantTypeId type, bool optional);
 
        bool addToOutput(const std::string& key, const ContainerType& type, bool optional);
 
 
 
 
 
 
 
        StateBasePtr clone() const override;
        StateBasePtr createEmptyCopy() const override;
 
        //**************************
        //    Getters
        //**************************
 
 
        StateParameterMap getInputParameters() override;
 
        template<typename T>
        typename std::enable_if_t<std::is_base_of_v<VariantDataClass, T>, IceInternal::Handle<T> >
        getInput(const std::string& key) const;
 
        template<typename T>
        typename std::enable_if_t < !(std::is_base_of_v<VariantDataClass, T> || std::is_base_of_v<VariantContainerBase, T>), T >
        getInput(const std::string& key) const;
 
        VariantPtr getInput(const std::string& key) const;
 
 
        StateParameterMap& getLocalParameters();
 
        template<typename T>
        typename std::enable_if_t<std::is_base_of_v<VariantDataClass, T>, IceInternal::Handle<T> >
        getLocal(const std::string& key) const;
 
        template<typename T>
        typename std::enable_if_t < !(std::is_base_of_v<VariantDataClass, T> || std::is_base_of_v<VariantContainerBase, T>), T >
        getLocal(const std::string& key) const;
 
 
 
 
        VariantContainerBasePtr getLocalContainer(std::string const& key);
 
 
 
        bool isInputParameterSet(const std::string& key) const;
        bool isLocalParameterSet(const std::string& key) const;
        bool isOutputParameterSet(const std::string& key) const;
 
        //**************************
        //    Setters
        //**************************
        void setInput(std::string const& key, const Variant& value);
 
        void setInput(std::string const& key, const VariantContainerBase& valueList);
 
 
        void setLocal(std::string const& key, const Variant& value);
 
        void setLocal(std::string const& key, const VariantContainerBase& valueList);
 
 
        void setOutput(std::string const& key, const Variant& value);
 
        void setOutput(std::string const& key, const VariantContainerBase& valueList);
 
 
        StateBasePtr setInitState(StateBasePtr initState, ParameterMappingPtr initialStateMapping = ParameterMappingPtr());
        void setUnbreakable(bool setUnbreakable = true);
 
        void setUseRunFunction(bool useRunFuntion);
 
        void cancelSubstates();
 
        void setStateName(const std::string& newName);
 
        void setStateClassNameFromTypeName(const std::string& typeName);
 
    public:
        //            /*! @brief Function to jump directly into a state. Should only be called for statemachine-debugging.
 
        //            @param stateName Name of the target state
        //            @param inputDictionary Dictionary for the state specified by @c stateName. Content is copied to the @c inputDictionary of @c stateName.
        //          */
        //            bool JumpToState(std::string stateName, StringVariantMap inputDictionary);
 
        StatePtr operator [](std::string const& stateName);
 
        template <class EventType, class StateType> friend class FinalStateBase;
        template <typename ContextType> friend class RemoteStateOfferer;
        friend class RemoteStateWrapper;
        template <class StateType> friend class StateTemplate;
 
    private:
        struct Impl;
        std::unique_ptr<Impl> simpl;
    };
 
 
 
    template <> StatePtr State::addState<State>(std::string const& stateName);
 
    template <class derivedState>
    IceInternal::Handle<derivedState> State::addState(std::string const& stateName)
    {
        // if the compiler points to the next line, something with the template parameter has been done wrong. see the message-string in the macro for further information
        static_assert(std::is_same_v<typename derivedState::Type, derivedState>,
                      "The template parameter 'derivedState' must be derived from StateTemplate<derivedState> or the class 'State' itself! It must not inherit from a class that inherits from StateTemplate!");
 
 
        __checkPhase(eSubstatesDefinitions, __PRETTY_FUNCTION__);
 
        IceInternal::Handle<derivedState> pNewState = derivedState::createInstance(stateName);
        //        stateName = pNewState->getStateName();
 
        addState(pNewState);
 
        return pNewState;
    }
 
 
    template <class EventType>
    TransitionIceBase& State::addTransition(StateIceBasePtr sourceState,
                                            StateIceBasePtr destinationState,
                                            ParameterMappingIceBasePtr mappingToNextStatesInput,
                                            ParameterMappingIceBasePtr mappingToParentStatesLocal,
                                            ParameterMappingIceBasePtr mappingToParentStatesOutput)
    {
        return addTransition(createEvent<EventType>(), sourceState, destinationState, mappingToNextStatesInput, mappingToParentStatesLocal, mappingToParentStatesOutput);
    }
 
 
    template <class EventType>
    TransitionIceBase& State::addTransitionFromAllStates(
        StateIceBasePtr destinationState,
        ParameterMappingIceBasePtr mappingToNextStatesInput,
        ParameterMappingIceBasePtr mappingToParentStatesLocal,
        ParameterMappingIceBasePtr mappingToParentStatesOutput)
    {
        __checkPhase(eSubstatesDefinitions, __PRETTY_FUNCTION__);
        TransitionIceBase t;
 
        assert(destinationState._ptr);
        t.evt = new EventType(EVENTTOALL);
        t.destinationState = destinationState;
 
        if (mappingToNextStatesInput)
        {
            t.mappingToNextStatesInput = PMPtr::dynamicCast(mappingToNextStatesInput)->clone();
        }
 
        if (mappingToParentStatesLocal)
        {
            t.mappingToParentStatesLocal = PMPtr::dynamicCast(mappingToParentStatesLocal)->clone();
        }
 
        if (mappingToParentStatesOutput)
        {
            t.mappingToParentStatesOutput = PMPtr::dynamicCast(mappingToParentStatesOutput)->clone();
        }
 
        t.fromAll = true;
 
        if (__checkExistenceOfTransition(t))
            throw exceptions::local::eStatechartLogicError("Cannot insert a general transition on event '" + t.evt->eventName
                    + "' from any state to '" + destinationState->stateName + "' into state '" + getStateName() + "'! There already exists a transition to that state on that event.");
 
        transitions.push_back(t);
        return *transitions.rbegin();
    }
 
    template<typename T>
    typename std::enable_if_t<std::is_base_of_v<VariantDataClass, T>, IceInternal::Handle<T> >
    State::getInput(const std::string& key) const
    {
        __checkPhaseMin(eDefined, __PRETTY_FUNCTION__);
        VariantContainerBasePtr varContainer;
        getParameterContainer(inputParameters, key, varContainer);
        if (varContainer && !SingleVariantPtr::dynamicCast(varContainer)) // we are only interested in real containers, not singlevariant containers
        {
            return IceInternal::Handle<T>::dynamicCast(varContainer);
        }
        else
        {
            VariantPtr var;
            getParameter(inputParameters, key, var);
            return IceInternal::Handle<T>::dynamicCast(var->get<T>());
        }
    }
 
 
    template<typename T>
    typename std::enable_if_t < !(std::is_base_of_v<VariantDataClass, T> || std::is_base_of_v<VariantContainerBase, T>), T >
    State::getInput(const std::string& key) const
    {
        __checkPhaseMin(eDefined, __PRETTY_FUNCTION__);
        VariantPtr var;
        getParameter(inputParameters, key, var);
        return var->get<T>();
    }
 
 
    template<typename T>
    typename std::enable_if_t<std::is_base_of_v<VariantDataClass, T>, IceInternal::Handle<T> >
    State::getLocal(const std::string& key) const
    {
        __checkPhaseMin(eDefined, __PRETTY_FUNCTION__);
        VariantContainerBasePtr varContainer;
        getParameterContainer(localParameters, key, varContainer);
        if (varContainer && !SingleVariantPtr::dynamicCast(varContainer)) // we are only interested in real containers, not singlevariant containers
        {
            return IceInternal::Handle<T>::dynamicCast(varContainer);
        }
        else
        {
            VariantPtr var;
            getParameter(localParameters, key, var);
            return IceInternal::Handle<T>::dynamicCast(var->get<T>());
        }
    }
 
 
    template<typename T>
    typename std::enable_if_t < !(std::is_base_of_v<VariantDataClass, T> || std::is_base_of_v<VariantContainerBase, T>), T >
    State::getLocal(const std::string& key) const
    {
        __checkPhaseMin(eDefined, __PRETTY_FUNCTION__);
        VariantPtr var;
        getParameter(localParameters, key, var);
        return var->get<T>();
    }
 
 
    template<typename T>
    typename std::enable_if_t<std::is_base_of_v<VariantDataClass, T>, IceInternal::Handle<T> >
    State::getOutput(const std::string& key) const
    {
        __checkPhaseMin(eDefined, __PRETTY_FUNCTION__);
        VariantContainerBasePtr varContainer;
        getParameterContainer(outputParameters, key, varContainer);
        if (varContainer && !SingleVariantPtr::dynamicCast(varContainer)) // we are only interested in real containers, not singlevariant containers
        {
            return IceInternal::Handle<T>::dynamicCast(varContainer);
        }
        else
        {
            VariantPtr var;
            getParameter(outputParameters, key, var);
            return IceInternal::Handle<T>::dynamicCast(var->get<T>());
        }
    }
 
 
    template<typename T>
    typename std::enable_if_t < !(std::is_base_of_v<VariantDataClass, T> || std::is_base_of_v<VariantContainerBase, T>), T >
    State::getOutput(const std::string& key) const
    {
        __checkPhaseMin(eDefined, __PRETTY_FUNCTION__);
        VariantPtr var;
        getParameter(outputParameters, key, var);
        return var->get<T>();
    }
 
 
 
}