level_machine.h

Go to the documentation of this file.

 
#ifndef _ADTF_UCOM_ANT_CLASSES_LEVEL_MASCHINE_HEADER_
#define _ADTF_UCOM_ANT_CLASSES_LEVEL_MASCHINE_HEADER_
 
namespace adtf
{
namespace ucom
{
namespace ant
{
 
template <typename Subclass, typename LevelType, LevelType START_LEVEL>
class level_machine
{
    private:
        LevelType m_eLevel = START_LEVEL;
 
    protected:
 
        enum tDirection : uint8_t
        {
            Inc = 0,
            Dec = 1
        };
 
        virtual ~level_machine() = default;
 
        typedef tResult (Subclass::*tChangeMethod)();
        template<LevelType level, tDirection direction, tChangeMethod method>
        struct handler
        {
                static const LevelType eLevel = level;
                static const tDirection eDirection = direction;
 
                static tChangeMethod GetMethod()
                {
                    return method;
                }
        };
 
        LevelType GetLevel() const
        {
            return m_eLevel;
        }
 
    protected:
 
        template<typename ...InnerHandlers>
        struct dispatcher
        {
                static tResult DispatchMethod(Subclass* /* pObj */, LevelType /* eLevel */, tDirection /* eDir */)
                {
                    RETURN_NOERROR;
                }
        };
 
        template<typename Handler, typename ...InnerHandlers>
        struct dispatcher<Handler, InnerHandlers...>
        {
            static tResult DispatchMethod(Subclass* pObj, LevelType eLevel, tDirection eDir)
            {
                if (Handler::eLevel == eLevel && Handler::eDirection == eDir)
                {
                    RETURN_IF_FAILED((pObj->*Handler::GetMethod())());
                }
 
                return dispatcher<InnerHandlers...>::DispatchMethod(pObj, eLevel, eDir);
            }
        };
 
    public:
 
        template<typename ...InnerHandlers>
        tResult ChangeLevel(LevelType eLevel)
        {            
            if (m_eLevel < eLevel)
            {
                for (int64_t nNext = static_cast<int64_t>(m_eLevel) + 1; nNext <= static_cast<int64_t>(eLevel); ++nNext)
                {
                    RETURN_IF_FAILED(dispatcher<InnerHandlers...>::DispatchMethod(static_cast<Subclass*>(this), static_cast<LevelType>(nNext), Inc));
                    m_eLevel = static_cast<LevelType>(nNext);
                }
            }
            else if (m_eLevel > eLevel)
            {
                for (int64_t nNext = static_cast<int64_t>(m_eLevel) - 1; nNext >= static_cast<int64_t>(eLevel); --nNext)
                {
                    RETURN_IF_FAILED(dispatcher<InnerHandlers...>::DispatchMethod(static_cast<Subclass*>(this), static_cast<LevelType>(nNext), Dec));
                    m_eLevel = static_cast<LevelType>(nNext);
                }
            }
 
            RETURN_NOERROR;
        }
};
 
}
 
using ant::level_machine;
 
}
 
}
 
#endif