template <typename SUPER_STATE >
class mcx::state_machine::ErrorHandle;

inline ErrorHandle(
    StateMachine< SUPER_STATE > * state_machine
)

ErrorHandle() =default

ErrorHandle(
    ErrorHandle & orig
) =delete

ErrorHandle & operator=(
    ErrorHandle & orig
) =delete

virtual ~ErrorHandle(
    void 
) =default

inline void setStateMachine(
    StateMachine< SUPER_STATE > * state_machine
)

inline void addParameters(
    const std::string & param_name,
    parameter_server::Parameter * parent
)

inline void setName(
    const std::string & name
)

inline const std::string & getName() const

inline void create(
    const std::string & name,
    const char * error_name_prefix,
    parameter_server::Parameter * parent
)

inline const std::map< Error, MotorcortexError > & getActiveErrors() const

inline MotorcortexError getActiveError() const

inline virtual bool empty() override

inline virtual bool hasError(
    const Error & error
) override

inline virtual bool hasErrorLevel(
    MotorcortexErrorLevel error_level
) override

inline bool acknowledgeAll()

inline bool acknowledgeWarnings()

inline virtual bool acknowledge(
    bool warnings_only =false
) override

inline virtual bool warning(
    const Error & error
) override

inline virtual bool forcedDisengaged(
    const Error & error
) override

inline virtual bool shutdown(
    const Error & error
) override

inline virtual bool emergencyStop(
    const Error & error
) override

inline void iterate(
    double dt_sec
)

inline const ErrorPublisher & getErrorPublisher() const

inline virtual signal_monitor::SignalMonitorBase * getSignalMonitor() override

inline void enableErrors(
    const ErrorGroup & error_group
)

template <class STATE ,
typename... STATES>
inline void enableErrors(
    const ErrorGroup & error_group
)

inline void disableErrors(
    const ErrorGroup & error_group
)

template <class STATE ,
typename... STATES>
inline void disableErrors(
    const ErrorGroup & error_group
)

inline void resetErrors(
    const ErrorGroup & error_group
)

template <class STATE ,
typename... STATES>
inline void resetErrors(
    const ErrorGroup & error_group
)

inline void addEmergencyStop(
    const Error & error_id,
    bool * input_ptr,
    bool objective_val,
    TriggerType trigger_type =TriggerType::TRIGGER_ALWAYS,
    double start_time_s =0,
    double stop_time_s =std::numeric_limits< double >::max()
)

inline void addEmergencyStop(
    const Error & error_id,
    const bool && input_val,
    bool objective_val,
    TriggerType trigger_type =TriggerType::TRIGGER_ALWAYS,
    double start_time_s =0,
    double stop_time_s =std::numeric_limits< double >::max()
)

inline void addShutdown(
    const Error & error_id,
    bool * input_ptr,
    bool objective_val,
    TriggerType trigger_type =TriggerType::TRIGGER_ALWAYS,
    double start_time_s =0,
    double stop_time_s =std::numeric_limits< double >::max()
)

inline void addShutdown(
    const Error & error_id,
    const bool && input_val,
    bool objective_val,
    TriggerType trigger_type =TriggerType::TRIGGER_ALWAYS,
    double start_time_s =0,
    double stop_time_s =std::numeric_limits< double >::max()
)

inline void addForceDisengage(
    const Error & error_id,
    bool * input_ptr,
    bool objective_val,
    TriggerType trigger_type =TriggerType::TRIGGER_ALWAYS,
    double start_time_s =0,
    double stop_time_s =std::numeric_limits< double >::max()
)

inline void addForceDisengage(
    const Error & error_id,
    const bool && input_val,
    bool objective_val,
    TriggerType trigger_type =TriggerType::TRIGGER_ALWAYS,
    double start_time_s =0,
    double stop_time_s =std::numeric_limits< double >::max()
)

inline void addWarning(
    const Error & error_id,
    bool * input_ptr,
    bool objective_val,
    TriggerType trigger_type =TriggerType::TRIGGER_ALWAYS,
    double start_time_s =0,
    double stop_time_s =std::numeric_limits< double >::max()
)

inline void addWarning(
    const Error & error_id,
    const bool && input_val,
    bool objective_val,
    TriggerType trigger_type =TriggerType::TRIGGER_ALWAYS,
    double start_time_s =0,
    double stop_time_s =std::numeric_limits< double >::max()
)

inline void addSignal(
    const Error & error_id,
    bool * input_val,
    bool objective_val,
    const std::function< bool(const Error &signal_id)> & callback,
    TriggerType trigger_type =TriggerType::TRIGGER_ALWAYS,
    double start_time_s =0,
    double stop_time_s =std::numeric_limits< double >::max()
)