base.hpp

Go to the documentation of this file.

#ifndef SGDK_AI_FSM_BASE_HPP
#define SGDK_AI_FSM_BASE_HPP

/*
 * Defines the sgdk::IndexTypeTransitionFunction class template.
 */
#include <swiss_gd_knife/ai/fsm/transition.hpp>

namespace sgdk {


template <
#ifndef SGDK_DOX
    typename StateInputMatrix
  , typename Index = unsigned int
#endif  /* SGDK_DOX */
>
class IndexTypeFSM
{
 public:
#ifdef SGDK_DOX
    typedef implementation_defined TransitionFunction;
#else
    typedef IndexTypeTransitionFunction<StateInputMatrix,Index>
            TransitionFunction;
#endif  /* SGDK_DOX */

 private:
    TransitionFunction _transition_function;
    Index              _start_state;
    Index              _current_state;
    Index              _end_state;

 public:

    IndexTypeFSM()
      : _transition_function()
      , _start_state()
      , _current_state()
      , _end_state()
    {
    }

    template <typename IndexTypeFSMBuilder>
    explicit IndexTypeFSM(const IndexTypeFSMBuilder& fsm_builder)
      : _transition_function()
      , _start_state()
      , _current_state()
      , _end_state()
    {
        initialize(fsm_builder);
    }


    IndexTypeFSM(const IndexTypeFSM& copy)
      : _transition_function(copy._transition_function)
      , _start_state(copy._start_state)
      , _current_state(copy._current_state)
      , _end_state(copy._end_state)
    {
    }


    IndexTypeFSM& operator=(const IndexTypeFSM& copy)
    {
        _transition_function = copy._transition_function;
        _start_state         = copy._start_state;
        _current_state       = copy._current_state;
        _end_state           = copy._end_state;
        return *this;
    }

    template <typename IndexTypeFSMBuilder>
    void initialize(const IndexTypeFSMBuilder& fsm_builder);

    inline const TransitionFunction& getTransitionFunction() const
    {
        return _transition_function;
    }

    inline void reset()
    {
        _current_state = _start_state;
    }

    inline Index getCurrentState() const
    {
        return _current_state;
    }

    template <typename BackInsertionSequence>
    void makeNontrivialInputs(BackInsertionSequence& sequence) const;

    inline Index getNextState(const Index input) const
    {
        if (_current_state != _end_state)
        {
            return _transition_function(_current_state, input);
        }
        else
        {
            return _current_state;
        }
    }

    inline void processInput(const Index input)
    {
        if (_current_state != _end_state)
        {
            _current_state = _transition_function(_current_state, input);
        }
    }

    inline bool hasReachedTargetState() const
    {
        return _current_state == _end_state;
    }
};

#ifndef SGDK_DOX
template <typename StateInputMatrix, typename Index>
template <typename IndexTypeFSMBuilder>
#endif  /* SGDK_DOX */
void
    IndexTypeFSM<
#ifndef SGDK_DOX
        StateInputMatrix
      , Index
#endif  /* SGDK_DOX */
    >::initialize(const IndexTypeFSMBuilder& fsm_builder)
{
    fsm_builder.buildTransitionFunction(_transition_function);
    _start_state = fsm_builder.getSourceState();
    _current_state = _start_state;
    _end_state = fsm_builder.getTargetState();
}

#ifndef SGDK_DOX
template <typename StateInputMatrix, typename Index>
template <typename BackInsertionSequence>
#endif  /* SGDK_DOX */
void
    IndexTypeFSM<
#ifndef SGDK_DOX
        StateInputMatrix
      , Index
#endif  /* SGDK_DOX */
    >::makeNontrivialInputs(BackInsertionSequence& sequence) const
{
    for (
        Index input = 0;
        input < _transition_function.getInputCount();
        ++input
    )
    {
        if (_current_state != _transition_function(_current_state, input))
        {
            sequence.push_back(input);
        }
    }
}
}  // namespace sgdk

#endif  /* SGDK_AI_FSM_BASE_HPP */

---

Swiss GD Knife is hosted by .