From 4487b81de88deb9c7688f23fd63093767120e815 Mon Sep 17 00:00:00 2001 From: Alexey Rybalchenko Date: Wed, 17 Jul 2019 11:39:44 +0200 Subject: [PATCH] Extract States & Transitions to own header, use in plugins --- fairmq/CMakeLists.txt | 9 +-- fairmq/FairMQDevice.h | 8 +-- fairmq/PluginServices.cxx | 119 +------------------------------------- fairmq/PluginServices.h | 61 +++---------------- fairmq/StateMachine.cxx | 86 +-------------------------- fairmq/StateMachine.h | 49 +--------------- fairmq/States.cxx | 116 +++++++++++++++++++++++++++++++++++++ fairmq/States.h | 66 +++++++++++++++++++++ 8 files changed, 206 insertions(+), 308 deletions(-) create mode 100644 fairmq/States.cxx create mode 100644 fairmq/States.h diff --git a/fairmq/CMakeLists.txt b/fairmq/CMakeLists.txt index b36f3e18..9e558707 100644 --- a/fairmq/CMakeLists.txt +++ b/fairmq/CMakeLists.txt @@ -27,7 +27,6 @@ if(BUILD_FAIRMQ OR BUILD_SDK) install(FILES ${CMAKE_BINARY_DIR}/${PROJECT_NAME_LOWER}/Version.h DESTINATION ${PROJECT_INSTALL_INCDIR} ) - ######### # Tools # @@ -71,7 +70,7 @@ if(BUILD_FAIRMQ OR BUILD_SDK) OUTPUT_NAME FairMQ${target} ) install( - TARGETS ${target} + TARGETS ${target} EXPORT ${PROJECT_EXPORT_SET} RUNTIME DESTINATION ${PROJECT_INSTALL_BINDIR} LIBRARY DESTINATION ${PROJECT_INSTALL_LIBDIR} @@ -92,10 +91,12 @@ if(BUILD_FAIRMQ OR BUILD_SDK) set(FSM_PUBLIC_HEADER_FILES StateMachine.h + States.h ) set(FSM_SOURCE_FILES StateMachine.cxx + States.cxx ) add_library(${target} @@ -111,7 +112,7 @@ if(BUILD_FAIRMQ OR BUILD_SDK) target_link_libraries(${target} PUBLIC FairLogger::FairLogger - + PRIVATE Boost::boost Tools @@ -122,7 +123,7 @@ if(BUILD_FAIRMQ OR BUILD_SDK) OUTPUT_NAME FairMQ${target} ) install( - TARGETS ${target} + TARGETS ${target} EXPORT ${PROJECT_EXPORT_SET} RUNTIME DESTINATION ${PROJECT_INSTALL_BINDIR} LIBRARY DESTINATION ${PROJECT_INSTALL_LIBDIR} diff --git a/fairmq/FairMQDevice.h b/fairmq/FairMQDevice.h index 87060d7d..f98a8321 100644 --- a/fairmq/FairMQDevice.h +++ b/fairmq/FairMQDevice.h @@ -491,7 +491,7 @@ class FairMQDevice public: bool ChangeState(const fair::mq::Transition transition) { return fStateMachine.ChangeState(transition); } - bool ChangeState(const std::string& transition) { return fStateMachine.ChangeState(fair::mq::StateMachine::GetTransition(transition)); } + bool ChangeState(const std::string& transition) { return fStateMachine.ChangeState(fair::mq::GetTransition(transition)); } bool ChangeState(const int transition) __attribute__((deprecated("Use ChangeState(const fair::mq::Transition transition)."))); @@ -500,7 +500,7 @@ class FairMQDevice fair::mq::State WaitForNextState(); void WaitForState(fair::mq::State state); - void WaitForState(const std::string& state) { WaitForState(fair::mq::StateMachine::GetState(state)); } + void WaitForState(const std::string& state) { WaitForState(fair::mq::GetState(state)); } void TransitionTo(const fair::mq::State state); @@ -519,8 +519,8 @@ class FairMQDevice fair::mq::State GetCurrentState() const { return fStateMachine.GetCurrentState(); } std::string GetCurrentStateName() const { return fStateMachine.GetCurrentStateName(); } - static std::string GetStateName(const fair::mq::State state) { return fair::mq::StateMachine::GetStateName(state); } - static std::string GetTransitionName(const fair::mq::Transition transition) { return fair::mq::StateMachine::GetTransitionName(transition); } + static std::string GetStateName(const fair::mq::State state) { return fair::mq::GetStateName(state); } + static std::string GetTransitionName(const fair::mq::Transition transition) { return fair::mq::GetTransitionName(transition); } struct DeviceStateError : std::runtime_error { using std::runtime_error::runtime_error; }; diff --git a/fairmq/PluginServices.cxx b/fairmq/PluginServices.cxx index cc2aa559..d7f1f4c8 100644 --- a/fairmq/PluginServices.cxx +++ b/fairmq/PluginServices.cxx @@ -11,135 +11,20 @@ using namespace fair::mq; using namespace std; -const unordered_map PluginServices::fkDeviceStateStrMap = { - {"OK", DeviceState::Ok}, - {"ERROR", DeviceState::Error}, - {"IDLE", DeviceState::Idle}, - {"INITIALIZING DEVICE", DeviceState::InitializingDevice}, - {"INITIALIZED", DeviceState::Initialized}, - {"BINDING", DeviceState::Binding}, - {"BOUND", DeviceState::Bound}, - {"CONNECTING", DeviceState::Connecting}, - {"DEVICE READY", DeviceState::DeviceReady}, - {"INITIALIZING TASK", DeviceState::InitializingTask}, - {"READY", DeviceState::Ready}, - {"RUNNING", DeviceState::Running}, - {"RESETTING TASK", DeviceState::ResettingTask}, - {"RESETTING DEVICE", DeviceState::ResettingDevice}, - {"EXITING", DeviceState::Exiting} -}; -const unordered_map> PluginServices::fkStrDeviceStateMap = { - {DeviceState::Ok, "OK"}, - {DeviceState::Error, "ERROR"}, - {DeviceState::Idle, "IDLE"}, - {DeviceState::InitializingDevice, "INITIALIZING DEVICE"}, - {DeviceState::Initialized, "INITIALIZED"}, - {DeviceState::Binding, "BINDING"}, - {DeviceState::Bound, "BOUND"}, - {DeviceState::Connecting, "CONNECTING"}, - {DeviceState::DeviceReady, "DEVICE READY"}, - {DeviceState::InitializingTask, "INITIALIZING TASK"}, - {DeviceState::Ready, "READY"}, - {DeviceState::Running, "RUNNING"}, - {DeviceState::ResettingTask, "RESETTING TASK"}, - {DeviceState::ResettingDevice, "RESETTING DEVICE"}, - {DeviceState::Exiting, "EXITING"} -}; -const unordered_map PluginServices::fkDeviceStateTransitionStrMap = { - {"AUTO", DeviceStateTransition::Auto}, - {"INIT DEVICE", DeviceStateTransition::InitDevice}, - {"COMPLETE INIT", DeviceStateTransition::CompleteInit}, - {"BIND", DeviceStateTransition::Bind}, - {"CONNECT", DeviceStateTransition::Connect}, - {"INIT TASK", DeviceStateTransition::InitTask}, - {"RUN", DeviceStateTransition::Run}, - {"STOP", DeviceStateTransition::Stop}, - {"RESET TASK", DeviceStateTransition::ResetTask}, - {"RESET DEVICE", DeviceStateTransition::ResetDevice}, - {"END", DeviceStateTransition::End}, - {"ERROR FOUND", DeviceStateTransition::ErrorFound}, -}; -const unordered_map> PluginServices::fkStrDeviceStateTransitionMap = { - {DeviceStateTransition::Auto, "Auto"}, - {DeviceStateTransition::InitDevice, "INIT DEVICE"}, - {DeviceStateTransition::CompleteInit, "COMPLETE INIT"}, - {DeviceStateTransition::Bind, "BIND"}, - {DeviceStateTransition::Connect, "CONNECT"}, - {DeviceStateTransition::InitTask, "INIT TASK"}, - {DeviceStateTransition::Run, "RUN"}, - {DeviceStateTransition::Stop, "STOP"}, - {DeviceStateTransition::ResetTask, "RESET TASK"}, - {DeviceStateTransition::ResetDevice, "RESET DEVICE"}, - {DeviceStateTransition::End, "END"}, - {DeviceStateTransition::ErrorFound, "ERROR FOUND"}, -}; -const unordered_map> PluginServices::fkDeviceStateMap = { - {State::Ok, DeviceState::Ok}, - {State::Error, DeviceState::Error}, - {State::Idle, DeviceState::Idle}, - {State::InitializingDevice, DeviceState::InitializingDevice}, - {State::Initialized, DeviceState::Initialized}, - {State::Binding, DeviceState::Binding}, - {State::Bound, DeviceState::Bound}, - {State::Connecting, DeviceState::Connecting}, - {State::DeviceReady, DeviceState::DeviceReady}, - {State::InitializingTask, DeviceState::InitializingTask}, - {State::Ready, DeviceState::Ready}, - {State::Running, DeviceState::Running}, - {State::ResettingTask, DeviceState::ResettingTask}, - {State::ResettingDevice, DeviceState::ResettingDevice}, - {State::Exiting, DeviceState::Exiting} -}; -const unordered_map PluginServices::fkStateMap = { - {DeviceState::Ok, State::Ok}, - {DeviceState::Error, State::Error}, - {DeviceState::Idle, State::Idle}, - {DeviceState::InitializingDevice, State::InitializingDevice}, - {DeviceState::Initialized, State::Initialized}, - {DeviceState::Binding, State::Binding}, - {DeviceState::Bound, State::Bound}, - {DeviceState::Connecting, State::Connecting}, - {DeviceState::DeviceReady, State::DeviceReady}, - {DeviceState::InitializingTask, State::InitializingTask}, - {DeviceState::Ready, State::Ready}, - {DeviceState::Running, State::Running}, - {DeviceState::ResettingTask, State::ResettingTask}, - {DeviceState::ResettingDevice, State::ResettingDevice}, - {DeviceState::Exiting, State::Exiting} -}; -const unordered_map> PluginServices::fkDeviceStateTransitionMap = { - {DeviceStateTransition::Auto, Transition::Auto}, - {DeviceStateTransition::InitDevice, Transition::InitDevice}, - {DeviceStateTransition::CompleteInit, Transition::CompleteInit}, - {DeviceStateTransition::Bind, Transition::Bind}, - {DeviceStateTransition::Connect, Transition::Connect}, - {DeviceStateTransition::InitTask, Transition::InitTask}, - {DeviceStateTransition::Run, Transition::Run}, - {DeviceStateTransition::Stop, Transition::Stop}, - {DeviceStateTransition::ResetTask, Transition::ResetTask}, - {DeviceStateTransition::ResetDevice, Transition::ResetDevice}, - {DeviceStateTransition::End, Transition::End}, - {DeviceStateTransition::ErrorFound, Transition::ErrorFound} -}; - auto PluginServices::ChangeDeviceState(const string& controller, const DeviceStateTransition next) -> bool { lock_guard lock{fDeviceControllerMutex}; if (!fDeviceController) fDeviceController = controller; - bool result = false; - if (fDeviceController == controller) { - result = fDevice.ChangeState(fkDeviceStateTransitionMap.at(next)); + return fDevice.ChangeState(next); } else { throw DeviceControlError{tools::ToString( "Plugin '", controller, "' is not allowed to change device states. ", "Currently, plugin '", *fDeviceController, "' has taken control." )}; } - - return result; } void PluginServices::TransitionDeviceStateTo(const std::string& controller, DeviceState state) @@ -149,7 +34,7 @@ void PluginServices::TransitionDeviceStateTo(const std::string& controller, Devi if (!fDeviceController) fDeviceController = controller; if (fDeviceController == controller) { - fDevice.TransitionTo(fkStateMap.at(state)); + fDevice.TransitionTo(state); } else { throw DeviceControlError{tools::ToString( "Plugin '", controller, "' is not allowed to change device states. ", diff --git a/fairmq/PluginServices.h b/fairmq/PluginServices.h index 1d994000..7eb565ad 100644 --- a/fairmq/PluginServices.h +++ b/fairmq/PluginServices.h @@ -10,6 +10,7 @@ #define FAIR_MQ_PLUGINSERVICES_H #include +#include #include #include #include @@ -58,41 +59,8 @@ class PluginServices PluginServices(const PluginServices&) = delete; PluginServices operator=(const PluginServices&) = delete; - /// See https://github.com/FairRootGroup/FairRoot/blob/dev/fairmq/docs/Device.md#13-state-machine - enum class DeviceState : int - { - Ok, - Error, - Idle, - InitializingDevice, - Initialized, - Binding, - Bound, - Connecting, - DeviceReady, - InitializingTask, - Ready, - Running, - ResettingTask, - ResettingDevice, - Exiting - }; - - enum class DeviceStateTransition : int // transition event between DeviceStates - { - Auto, - InitDevice, - CompleteInit, - Bind, - Connect, - InitTask, - Run, - Stop, - ResetTask, - ResetDevice, - End, - ErrorFound - }; + using DeviceState = fair::mq::State; + using DeviceStateTransition = fair::mq::Transition; // Control API @@ -100,29 +68,26 @@ class PluginServices /// @param state to convert /// @return DeviceState enum entry /// @throw std::out_of_range if a string cannot be resolved to a DeviceState - static auto ToDeviceState(const std::string& state) -> DeviceState { return fkDeviceStateStrMap.at(state); } + static auto ToDeviceState(const std::string& state) -> DeviceState { return GetState(state); } /// @brief Convert string to DeviceStateTransition /// @param transition to convert /// @return DeviceStateTransition enum entry /// @throw std::out_of_range if a string cannot be resolved to a DeviceStateTransition - static auto ToDeviceStateTransition(const std::string& transition) -> DeviceStateTransition { return fkDeviceStateTransitionStrMap.at(transition); } + static auto ToDeviceStateTransition(const std::string& transition) -> DeviceStateTransition { return GetTransition(transition); } /// @brief Convert DeviceState to string /// @param state to convert /// @return string representation of DeviceState enum entry - static auto ToStr(DeviceState state) -> std::string { return fkStrDeviceStateMap.at(state); } + static auto ToStr(DeviceState state) -> std::string { return GetStateName(state); } /// @brief Convert DeviceStateTransition to string /// @param transition to convert /// @return string representation of DeviceStateTransition enum entry - static auto ToStr(DeviceStateTransition transition) -> std::string { return fkStrDeviceStateTransitionMap.at(transition); } - - friend auto operator<<(std::ostream& os, const DeviceState& state) -> std::ostream& { return os << ToStr(state); } - friend auto operator<<(std::ostream& os, const DeviceStateTransition& transition) -> std::ostream& { return os << ToStr(transition); } + static auto ToStr(DeviceStateTransition transition) -> std::string { return GetTransitionName(transition); } /// @return current device state - auto GetCurrentDeviceState() const -> DeviceState { return fkDeviceStateMap.at(static_cast(fDevice.GetCurrentState())); } + auto GetCurrentDeviceState() const -> DeviceState { return fDevice.GetCurrentState(); } /// @brief Become device controller /// @param controller id @@ -171,7 +136,7 @@ class PluginServices auto SubscribeToDeviceStateChange(const std::string& subscriber, std::function callback) -> void { fDevice.SubscribeToStateChange(subscriber, [&,callback](fair::mq::State newState){ - callback(fkDeviceStateMap.at(newState)); + callback(newState); }); } @@ -310,14 +275,6 @@ class PluginServices /// @brief Decreases logging verbosity, or sets it to highest if it is already lowest auto CycleLogVerbosityDown() -> void { Logger::CycleVerbosityDown(); } - static const std::unordered_map fkDeviceStateStrMap; - static const std::unordered_map> fkStrDeviceStateMap; - static const std::unordered_map fkDeviceStateTransitionStrMap; - static const std::unordered_map> fkStrDeviceStateTransitionMap; - static const std::unordered_map> fkDeviceStateMap; - static const std::unordered_map fkStateMap; - static const std::unordered_map> fkDeviceStateTransitionMap; - private: fair::mq::ProgOptions& fConfig; FairMQDevice& fDevice; diff --git a/fairmq/StateMachine.cxx b/fairmq/StateMachine.cxx index 7337fa49..4201d075 100644 --- a/fairmq/StateMachine.cxx +++ b/fairmq/StateMachine.cxx @@ -6,7 +6,7 @@ * copied verbatim in the file "LICENSE" * ********************************************************************************/ -#include "StateMachine.h" +#include #include // Increase maximum number of boost::msm states (default is 10) @@ -25,10 +25,8 @@ #include #include #include -#include #include #include -#include using namespace std; using namespace boost::msm; @@ -76,80 +74,6 @@ struct RESET_DEVICE_E { static string Name() { return "RESET_DEVICE"; } static struct END_E { static string Name() { return "END"; } static Transition Type() { return Transition::End; } }; struct ERROR_FOUND_E { static string Name() { return "ERROR_FOUND"; } static Transition Type() { return Transition::ErrorFound; } }; -static array stateNames = -{ - { - "OK", - "Error", - "IDLE", - "INITIALIZING_DEVICE", - "INITIALIZED", - "BINDING", - "BOUND", - "CONNECTING", - "DEVICE_READY", - "INITIALIZING_TASK", - "READY", - "RUNNING", - "RESETTING_TASK", - "RESETTING_DEVICE", - "EXITING" - } -}; - -static array transitionNames = -{ - { - "AUTO", - "INIT_DEVICE", - "COMPLETE_INIT", - "BIND", - "CONNECT", - "INIT_TASK", - "RUN", - "STOP", - "RESET_TASK", - "RESET_DEVICE", - "END", - "ERROR_FOUND" - } -}; - -static map stateNumbers = -{ - { "OK", State::Ok }, - { "Error", State::Error }, - { "IDLE", State::Idle }, - { "INITIALIZING_DEVICE", State::InitializingDevice }, - { "INITIALIZED", State::Initialized }, - { "BINDING", State::Binding }, - { "BOUND", State::Bound }, - { "CONNECTING", State::Connecting }, - { "DEVICE_READY", State::DeviceReady }, - { "INITIALIZING_TASK", State::InitializingTask }, - { "READY", State::Ready }, - { "RUNNING", State::Running }, - { "RESETTING_TASK", State::ResettingTask }, - { "RESETTING_DEVICE", State::ResettingDevice }, - { "EXITING", State::Exiting } -}; - -static map transitionNumbers = -{ - { "AUTO", Transition::Auto }, - { "INIT_DEVICE", Transition::InitDevice }, - { "COMPLETE_INIT", Transition::CompleteInit }, - { "BIND", Transition::Bind }, - { "CONNECT", Transition::Connect }, - { "INIT_TASK", Transition::InitTask }, - { "RUN", Transition::Run }, - { "STOP", Transition::Stop }, - { "RESET_TASK", Transition::ResetTask }, - { "RESET_DEVICE", Transition::ResetDevice }, - { "END", Transition::End }, - { "ERROR_FOUND", Transition::ErrorFound } -}; - // defining the boost MSM state machine struct Machine_ : public state_machine_def { @@ -369,7 +293,7 @@ try { return false; } } else { - LOG(state) << "Transition " << transitionNames.at(static_cast(transition)) << " incoming, but another state transition is already ongoing."; + LOG(state) << "Transition " << GetTransitionName(transition) << " incoming, but another state transition is already ongoing."; return false; } } catch (exception& e) { @@ -461,9 +385,3 @@ void StateMachine::ProcessWork() throw; } } - -string StateMachine::GetStateName(const State state) { return stateNames.at(static_cast(state)); } -string StateMachine::GetTransitionName(const Transition transition) { return transitionNames.at(static_cast(transition)); } -State StateMachine::GetState(const string& state) { return stateNumbers.at(state); } -Transition StateMachine::GetTransition(const string& transition) { return transitionNumbers.at(transition); } - diff --git a/fairmq/StateMachine.h b/fairmq/StateMachine.h index 18fdc34d..0db91007 100644 --- a/fairmq/StateMachine.h +++ b/fairmq/StateMachine.h @@ -9,15 +9,13 @@ #ifndef FAIRMQSTATEMACHINE_H_ #define FAIRMQSTATEMACHINE_H_ +#include + #include #include #include #include -#include -#include -#include -#include #include namespace fair @@ -25,41 +23,6 @@ namespace fair namespace mq { -enum class State : int -{ - Ok, - Error, - Idle, - InitializingDevice, - Initialized, - Binding, - Bound, - Connecting, - DeviceReady, - InitializingTask, - Ready, - Running, - ResettingTask, - ResettingDevice, - Exiting -}; - -enum class Transition : int -{ - Auto, - InitDevice, - CompleteInit, - Bind, - Connect, - InitTask, - Run, - Stop, - ResetTask, - ResetDevice, - End, - ErrorFound -}; - class StateMachine { public: @@ -89,20 +52,12 @@ class StateMachine void ProcessWork(); - static std::string GetStateName(const State); - static std::string GetTransitionName(const Transition); - static State GetState(const std::string& state); - static Transition GetTransition(const std::string& transition); - struct ErrorStateException : std::runtime_error { using std::runtime_error::runtime_error; }; private: std::shared_ptr fFsm; }; -inline std::ostream& operator<<(std::ostream& os, const State& state) { return os << StateMachine::GetStateName(state); } -inline std::ostream& operator<<(std::ostream& os, const Transition& transition) { return os << StateMachine::GetTransitionName(transition); } - } // namespace mq } // namespace fair diff --git a/fairmq/States.cxx b/fairmq/States.cxx new file mode 100644 index 00000000..a10666b8 --- /dev/null +++ b/fairmq/States.cxx @@ -0,0 +1,116 @@ +/******************************************************************************** + * Copyright (C) 2019 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH * + * * + * This software is distributed under the terms of the * + * GNU Lesser General Public Licence (LGPL) version 3, * + * copied verbatim in the file "LICENSE" * + ********************************************************************************/ + +#include + +#include +#include + +using namespace std; + +namespace fair +{ +namespace mq +{ + +array stateNames = +{ + { + "OK", + "ERROR", + "IDLE", + "INITIALIZING DEVICE", + "INITIALIZED", + "BINDING", + "BOUND", + "CONNECTING", + "DEVICE READY", + "INITIALIZING TASK", + "READY", + "RUNNING", + "RESETTING TASK", + "RESETTING DEVICE", + "EXITING" + } +}; + +unordered_map states = +{ + { "OK", State::Ok }, + { "ERROR", State::Error }, + { "IDLE", State::Idle }, + { "INITIALIZING DEVICE", State::InitializingDevice }, + { "INITIALIZED", State::Initialized }, + { "BINDING", State::Binding }, + { "BOUND", State::Bound }, + { "CONNECTING", State::Connecting }, + { "DEVICE READY", State::DeviceReady }, + { "INITIALIZING TASK", State::InitializingTask }, + { "READY", State::Ready }, + { "RUNNING", State::Running }, + { "RESETTING TASK", State::ResettingTask }, + { "RESETTING DEVICE", State::ResettingDevice }, + { "EXITING", State::Exiting } +}; + +array transitionNames = +{ + { + "AUTO", + "INIT DEVICE", + "COMPLETE INIT", + "BIND", + "CONNECT", + "INIT TASK", + "RUN", + "STOP", + "RESET TASK", + "RESET DEVICE", + "END", + "ERROR FOUND" + } +}; + +unordered_map transitions = +{ + { "AUTO", Transition::Auto }, + { "INIT DEVICE", Transition::InitDevice }, + { "COMPLETE INIT", Transition::CompleteInit }, + { "BIND", Transition::Bind }, + { "CONNECT", Transition::Connect }, + { "INIT TASK", Transition::InitTask }, + { "RUN", Transition::Run }, + { "STOP", Transition::Stop }, + { "RESET TASK", Transition::ResetTask }, + { "RESET DEVICE", Transition::ResetDevice }, + { "END", Transition::End }, + { "ERROR FOUND", Transition::ErrorFound } +}; + +string GetStateName(const State state) +{ + return stateNames.at(static_cast(state)); +} + +string GetTransitionName(const Transition transition) +{ + return transitionNames.at(static_cast(transition)); +} + +State GetState(const string& state) +{ + return states.at(state); +} + +Transition GetTransition(const string& transition) +{ + return transitions.at(transition); +} + +} // namespace mq +} // namespace fair diff --git a/fairmq/States.h b/fairmq/States.h new file mode 100644 index 00000000..9421bc0f --- /dev/null +++ b/fairmq/States.h @@ -0,0 +1,66 @@ +/******************************************************************************** + * Copyright (C) 2019 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH * + * * + * This software is distributed under the terms of the * + * GNU Lesser General Public Licence (LGPL) version 3, * + * copied verbatim in the file "LICENSE" * + ********************************************************************************/ + +#ifndef FAIRMQSTATES_H_ +#define FAIRMQSTATES_H_ + +#include +#include + +namespace fair +{ +namespace mq +{ + +enum class State : int +{ + Ok, + Error, + Idle, + InitializingDevice, + Initialized, + Binding, + Bound, + Connecting, + DeviceReady, + InitializingTask, + Ready, + Running, + ResettingTask, + ResettingDevice, + Exiting +}; + +enum class Transition : int +{ + Auto, + InitDevice, + CompleteInit, + Bind, + Connect, + InitTask, + Run, + Stop, + ResetTask, + ResetDevice, + End, + ErrorFound +}; + +std::string GetStateName(const State); +std::string GetTransitionName(const Transition); +State GetState(const std::string& state); +Transition GetTransition(const std::string& transition); + +inline std::ostream& operator<<(std::ostream& os, const State& state) { return os << GetStateName(state); } +inline std::ostream& operator<<(std::ostream& os, const Transition& transition) { return os << GetTransitionName(transition); } + +} // namespace mq +} // namespace fair + +#endif /* FAIRMQSTATES_H_ */