base_functors.h

Go to the documentation of this file.

#pragma once

// Static asserts
#include <type_traits>
// Internal Transition Event
#include <aerial_autonomy/types/internal_transition_event.h>

template <class EventT, class RobotSystemT, class LogicStateMachineT>
struct ActionFunctor {
  virtual void run(EventT const &event, RobotSystemT &robot_system) = 0;

  template <class FSM, class SourceState, class TargetState>
  void operator()(EventT const &event, FSM &logic_state_machine, SourceState &,
                  TargetState &) {
    static_assert(
        std::is_convertible<decltype(
                                logic_state_machine.robot_system_container_()),
                            RobotSystemT &>::value,
        "Robot system in logic state machine is not the same as one used in "
        "action functor");
    static_assert(
        std::is_base_of<FSM, LogicStateMachineT>::value,
        "Template Logic state machine arg is not subclass of provided FSM");
    run(event, logic_state_machine.robot_system_container_());
  }

  virtual ~ActionFunctor() {}
};

template <class EventT, class RobotSystemT, class LogicStateMachineT>
struct GuardFunctor {
  virtual bool guard(EventT const &event, RobotSystemT &robot_system) = 0;
  template <class FSM, class SourceState, class TargetState>
  bool operator()(EventT const &event, FSM &logic_state_machine, SourceState &,
                  TargetState &) {
    static_assert(
        std::is_convertible<decltype(
                                logic_state_machine.robot_system_container_()),
                            RobotSystemT &>::value,
        "Robot system in logic state machine is not the same as one used in "
        "action functor");
    static_assert(
        std::is_base_of<FSM, LogicStateMachineT>::value,
        "Template Logic state machine arg is not subclass of provided FSM");
    return guard(event, logic_state_machine.robot_system_container_());
  }
  virtual ~GuardFunctor() {}
};

template <class RobotSystemT, class LogicStateMachineT>
struct EventAgnosticActionFunctor {
  virtual void run(RobotSystemT &robot_system) = 0;

  template <class EventT, class FSM, class SourceState, class TargetState>
  void operator()(EventT const &, FSM &logic_state_machine, SourceState &,
                  TargetState &) {
    static_assert(
        std::is_convertible<decltype(
                                logic_state_machine.robot_system_container_()),
                            RobotSystemT &>::value,
        "Robot system in logic state machine is not the same as one used in "
        "action functor");
    static_assert(
        std::is_base_of<FSM, LogicStateMachineT>::value,
        "Template Logic state machine arg is not subclass of provided FSM");
    run(logic_state_machine.robot_system_container_());
  }

  virtual ~EventAgnosticActionFunctor() {}
};

template <class RobotSystemT, class LogicStateMachineT>
struct EventAgnosticGuardFunctor {
  virtual bool guard(RobotSystemT &robot_system) = 0;

  template <class EventT, class FSM, class SourceState, class TargetState>
  bool operator()(EventT const &, FSM &logic_state_machine, SourceState &,
                  TargetState &) {
    static_assert(
        std::is_convertible<decltype(
                                logic_state_machine.robot_system_container_()),
                            RobotSystemT &>::value,
        "Robot system in logic state machine is not the same as one used in "
        "action functor");
    static_assert(
        std::is_base_of<FSM, LogicStateMachineT>::value,
        "Template Logic state machine arg is not subclass of provided FSM");
    return guard(logic_state_machine.robot_system_container_());
  }

  virtual ~EventAgnosticGuardFunctor() {}
};

template <class RobotSystemT, class LogicStateMachineT>
struct InternalActionFunctor {
  virtual bool run(RobotSystemT &robot_system,
                   LogicStateMachineT &logic_state_machine) = 0;

  template <class EventT, class FSM, class SourceState, class TargetState>
  bool operator()(EventT const &, FSM &logic_state_machine, SourceState &,
                  TargetState &) {
    static_assert(
        std::is_convertible<decltype(
                                logic_state_machine.robot_system_container_()),
                            RobotSystemT &>::value,
        "Robot system in logic state machine is not the same as one used in "
        "action functor");
    static_assert(
        std::is_base_of<FSM, LogicStateMachineT>::value,
        "Template Logic state machine arg is not subclass of provided FSM");
    LogicStateMachineT *logic_state_machine_cast =
        static_cast<LogicStateMachineT *>(&logic_state_machine);
    return run(logic_state_machine.robot_system_container_(),
               *logic_state_machine_cast);
  }

  virtual ~InternalActionFunctor() {}
};