YiSignalTransition.h

Go to the documentation of this file.

// © You i Labs Inc. 2000-2017. All rights reserved.
#ifndef _YI_SIGNAL_TRANSITION_H_
#define _YI_SIGNAL_TRANSITION_H_

#include "deprecated/YiAbstractSignalTransition.h"
#include "deprecated/YiSignalEventGenerator.h"
#include "deprecated/YiStateMachineAbstractSignalEvent.h"

namespace yi
{
namespace deprecated
{
template<typename YI_SLOT_PARAM1 = void, typename YI_SLOT_PARAM2 = void, typename YI_SLOT_PARAM3 = void, typename YI_SLOT_PARAM4 = void>
class CYISignalTransition : public CYIAbstractSignalTransition
{
public:
    CYISignalTransition(CYISignal<YI_SLOT_PARAM1, YI_SLOT_PARAM2, YI_SLOT_PARAM3, YI_SLOT_PARAM4> *signal,
                        CYICompoundState *source,
                        CYIAbstractState *target = 0) :
        CYIAbstractSignalTransition(signal, source, target),
        pSignal(signal)
    {
        SetSource(source);
    }

    virtual CYISignal<YI_SLOT_PARAM1, YI_SLOT_PARAM2, YI_SLOT_PARAM3, YI_SLOT_PARAM4> *GetSignal() override
    {
        return pSignal;
    }

    CYISignal<YI_SLOT_PARAM1, YI_SLOT_PARAM2, YI_SLOT_PARAM3, YI_SLOT_PARAM4> TransitionStartedWithParam;
    CYISignal<YI_SLOT_PARAM1, YI_SLOT_PARAM2, YI_SLOT_PARAM3, YI_SLOT_PARAM4> TransitionEndedWithParam;

protected:
    virtual bool TestEvent(CYIEvent *e) override
    {
        if (CYIAbstractSignalTransition::TestEvent(e) && ((CYIStateMachineAbstractSignalEvent *)e)->GetSignal() == pSignal)
        {
            return true;
        }
        return false;
    }

    virtual void OnTransitionStart(CYIEvent *e) override
    {
        CYIStateMachineSignalEvent<YI_SLOT_PARAM1, YI_SLOT_PARAM2, YI_SLOT_PARAM3, YI_SLOT_PARAM4> *ev = (CYIStateMachineSignalEvent<YI_SLOT_PARAM1, YI_SLOT_PARAM2, YI_SLOT_PARAM3, YI_SLOT_PARAM4> *)e;
        TransitionStartedWithParam(ev->param1, ev->param2, ev->param3, ev->param4);
    }

    virtual void OnTransitionEnd(CYIEvent *e) override
    {
        CYIStateMachineSignalEvent<YI_SLOT_PARAM1, YI_SLOT_PARAM2, YI_SLOT_PARAM3, YI_SLOT_PARAM4> *ev = (CYIStateMachineSignalEvent<YI_SLOT_PARAM1, YI_SLOT_PARAM2, YI_SLOT_PARAM3, YI_SLOT_PARAM4> *)e;
        TransitionEndedWithParam(ev->param1, ev->param2, ev->param3, ev->param4);
    }

    virtual void Connect() override
    {
        pSignal->Connect(*m_pGenerator, &CYISignalEventGenerator::slot4<YI_SLOT_PARAM1, YI_SLOT_PARAM2, YI_SLOT_PARAM3, YI_SLOT_PARAM4>, YI_CONNECTION_ASYNC);
    }

    CYISignal<YI_SLOT_PARAM1, YI_SLOT_PARAM2, YI_SLOT_PARAM3, YI_SLOT_PARAM4> *pSignal;
};

template<typename YI_SLOT_PARAM1, typename YI_SLOT_PARAM2, typename YI_SLOT_PARAM3>
class CYISignalTransition<YI_SLOT_PARAM1, YI_SLOT_PARAM2, YI_SLOT_PARAM3> : public CYIAbstractSignalTransition
{
public:
    CYISignalTransition(CYISignal<YI_SLOT_PARAM1, YI_SLOT_PARAM2, YI_SLOT_PARAM3> *signal,
                        CYICompoundState *source,
                        CYIAbstractState *target = 0) :
        CYIAbstractSignalTransition(signal, source, target),
        pSignal(signal)
    {
        SetSource(source);
    }

    virtual CYISignal<YI_SLOT_PARAM1, YI_SLOT_PARAM2, YI_SLOT_PARAM3> *GetSignal() override
    {
        return pSignal;
    }

    CYISignal<YI_SLOT_PARAM1, YI_SLOT_PARAM2, YI_SLOT_PARAM3> TransitionStartedWithParam;
    CYISignal<YI_SLOT_PARAM1, YI_SLOT_PARAM2, YI_SLOT_PARAM3> TransitionEndedWithParam;

protected:
    virtual bool TestEvent(CYIEvent *e) override
    {
        if (CYIAbstractSignalTransition::TestEvent(e) && ((CYIStateMachineAbstractSignalEvent *)e)->GetSignal() == pSignal)
        {
            return true;
        }
        return false;
    }

    virtual void OnTransitionStart(CYIEvent *e) override
    {
        CYIStateMachineSignalEvent<YI_SLOT_PARAM1, YI_SLOT_PARAM2, YI_SLOT_PARAM3> *ev = (CYIStateMachineSignalEvent<YI_SLOT_PARAM1, YI_SLOT_PARAM2, YI_SLOT_PARAM3> *)e;
        TransitionStartedWithParam(ev->param1, ev->param2, ev->param3);
    }

    virtual void OnTransitionEnd(CYIEvent *e) override
    {
        CYIStateMachineSignalEvent<YI_SLOT_PARAM1, YI_SLOT_PARAM2, YI_SLOT_PARAM3> *ev = (CYIStateMachineSignalEvent<YI_SLOT_PARAM1, YI_SLOT_PARAM2, YI_SLOT_PARAM3> *)e;
        TransitionEndedWithParam(ev->param1, ev->param2, ev->param3);
    }

    virtual void Connect() override
    {
        pSignal->Connect(*m_pGenerator, &CYISignalEventGenerator::slot3<YI_SLOT_PARAM1, YI_SLOT_PARAM2, YI_SLOT_PARAM3>, YI_CONNECTION_ASYNC);
    }

    CYISignal<YI_SLOT_PARAM1, YI_SLOT_PARAM2, YI_SLOT_PARAM3> *pSignal;
};

template<typename YI_SLOT_PARAM1, typename YI_SLOT_PARAM2>
class CYISignalTransition<YI_SLOT_PARAM1, YI_SLOT_PARAM2> : public CYIAbstractSignalTransition
{
public:
    CYISignalTransition(CYISignal<YI_SLOT_PARAM1, YI_SLOT_PARAM2> *signal,
                        CYICompoundState *source,
                        CYIAbstractState *target = 0) :
        CYIAbstractSignalTransition(signal, source, target),
        pSignal(signal)
    {
        SetSource(source);
    }

    virtual CYISignal<YI_SLOT_PARAM1, YI_SLOT_PARAM2> *GetSignal() override
    {
        return pSignal;
    }

    CYISignal<YI_SLOT_PARAM1, YI_SLOT_PARAM2> TransitionStartedWithParam;
    CYISignal<YI_SLOT_PARAM1, YI_SLOT_PARAM2> TransitionEndedWithParam;

protected:
    virtual bool TestEvent(CYIEvent *e) override
    {
        if (CYIAbstractSignalTransition::TestEvent(e) && ((CYIStateMachineAbstractSignalEvent *)e)->GetSignal() == pSignal)
        {
            return true;
        }
        return false;
    }

    virtual void OnTransitionStart(CYIEvent *e) override
    {
        CYIStateMachineSignalEvent<YI_SLOT_PARAM1, YI_SLOT_PARAM2> *ev = (CYIStateMachineSignalEvent<YI_SLOT_PARAM1, YI_SLOT_PARAM2> *)e;
        TransitionStartedWithParam(ev->param1, ev->param2);
    }

    virtual void OnTransitionEnd(CYIEvent *e) override
    {
        CYIStateMachineSignalEvent<YI_SLOT_PARAM1, YI_SLOT_PARAM2> *ev = (CYIStateMachineSignalEvent<YI_SLOT_PARAM1, YI_SLOT_PARAM2> *)e;
        TransitionEndedWithParam(ev->param1, ev->param2);
    }

    virtual void Connect() override
    {
        pSignal->Connect(*m_pGenerator, &CYISignalEventGenerator::slot2<YI_SLOT_PARAM1, YI_SLOT_PARAM2>, YI_CONNECTION_ASYNC);
    }

    CYISignal<YI_SLOT_PARAM1, YI_SLOT_PARAM2> *pSignal;
};

template<typename YI_SLOT_PARAM1>
class CYISignalTransition<YI_SLOT_PARAM1> : public CYIAbstractSignalTransition
{
public:
    CYISignalTransition(CYISignal<YI_SLOT_PARAM1> *signal,
                        CYICompoundState *source,
                        CYIAbstractState *target = 0) :
        CYIAbstractSignalTransition(signal, source, target),
        pSignal(signal)
    {
        SetSource(source);
    }

    virtual CYISignal<YI_SLOT_PARAM1> *GetSignal() override
    {
        return pSignal;
    }

    CYISignal<YI_SLOT_PARAM1> TransitionStartedWithParam;
    CYISignal<YI_SLOT_PARAM1> TransitionEndedWithParam;

protected:
    virtual bool TestEvent(CYIEvent *e) override
    {
        if (CYIAbstractSignalTransition::TestEvent(e) && ((CYIStateMachineAbstractSignalEvent *)e)->GetSignal() == pSignal)
        {
            return true;
        }
        return false;
    }

    virtual void OnTransitionStart(CYIEvent *e) override
    {
        CYIStateMachineSignalEvent<YI_SLOT_PARAM1> *ev = (CYIStateMachineSignalEvent<YI_SLOT_PARAM1> *)e;
        TransitionStartedWithParam(ev->param1);
    }

    virtual void OnTransitionEnd(CYIEvent *e) override
    {
        CYIStateMachineSignalEvent<YI_SLOT_PARAM1> *ev = (CYIStateMachineSignalEvent<YI_SLOT_PARAM1> *)e;
        TransitionEndedWithParam(ev->param1);
    }

    virtual void Connect() override
    {
        pSignal->Connect(*m_pGenerator, &CYISignalEventGenerator::slot1<YI_SLOT_PARAM1>, YI_CONNECTION_ASYNC);
    }

    CYISignal<YI_SLOT_PARAM1> *pSignal;
};

template<>
class CYISignalTransition<> : public CYIAbstractSignalTransition
{
public:
    CYISignalTransition(CYISignal<> *signal,
                        CYICompoundState *source,
                        CYIAbstractState *target = 0) :
        CYIAbstractSignalTransition(signal, source, target),
        pSignal(signal)
    {
        SetSource(source);
    }

    virtual CYISignal<> *GetSignal() override
    {
        return pSignal;
    }

protected:
    virtual bool TestEvent(CYIEvent *e) override
    {
        if (CYIAbstractSignalTransition::TestEvent(e) && ((CYIStateMachineAbstractSignalEvent *)e)->GetSignal() == pSignal)
        {
            return true;
        }
        return false;
    }

    virtual void Connect() override
    {
        pSignal->Connect(*m_pGenerator, &CYISignalEventGenerator::slot0, YI_CONNECTION_ASYNC);
    }

    CYISignal<> *pSignal;
};

} //namespace deprecated

} //namespace yi

#endif /* _YI_SIGNAL_TRANSITION_H_ */