Mirror/FairMQ
1
0
Fork 0
mirror of https://github.com/FairRootGroup/FairMQ.git synced 2025-10-13 08:41:16 +00:00
Code Issues Packages Projects Releases Wiki Activity

simplify state change callback handling

Browse Source
This commit is contained in:
Alexey Rybalchenko 2017-08-28 13:35:45 +02:00 committed by Mohammad Al-Turany
parent eeb994a584
commit 4dd08051cc
3 changed files with 29 additions and 60 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

30
fairmq/FairMQDevice.cxx
View File

@ -261,10 +261,7 @@ void FairMQDevice::InitWrapper()
}
}
}
if (!fStateChangeCallback.empty())
{
fStateChangeCallback(INITIALIZING_DEVICE);
}
CallStateChangeCallbacks(INITIALIZING_DEVICE);
// Bind channels. Here one run is enough, because bind settings should be available locally
// If necessary this could be handled in the same way as the connecting channels
@ -452,10 +449,7 @@ bool FairMQDevice::BindEndpoint(FairMQSocket& socket, string& endpoint)
void FairMQDevice::InitTaskWrapper()
{
if (!fStateChangeCallback.empty())
{
fStateChangeCallback(INITIALIZING_TASK);
}
CallStateChangeCallbacks(INITIALIZING_TASK);
InitTask();
@ -517,10 +511,7 @@ void FairMQDevice::PrintChannel(const string& name)
void FairMQDevice::RunWrapper()
{
if (!fStateChangeCallback.empty())
{
fStateChangeCallback(RUNNING);
}
CallStateChangeCallbacks(RUNNING);
LOG(INFO) << "DEVICE: Running...";
@ -793,10 +784,7 @@ void FairMQDevice::PostRun()
void FairMQDevice::PauseWrapper()
{
if (!fStateChangeCallback.empty())
{
fStateChangeCallback(PAUSED);
}
CallStateChangeCallbacks(PAUSED);
Pause();
}
@ -1237,10 +1225,7 @@ void FairMQDevice::Unblock()
void FairMQDevice::ResetTaskWrapper()
{
if (!fStateChangeCallback.empty())
{
fStateChangeCallback(RESETTING_TASK);
}
CallStateChangeCallbacks(RESETTING_TASK);
ResetTask();
@ -1253,10 +1238,7 @@ void FairMQDevice::ResetTask()
void FairMQDevice::ResetWrapper()
{
if (!fStateChangeCallback.empty())
{
fStateChangeCallback(RESETTING_DEVICE);
}
CallStateChangeCallbacks(RESETTING_DEVICE);
Reset();

6
fairmq/FairMQStateMachine.cxx
View File

@ -228,11 +228,11 @@ bool FairMQStateMachine::WaitForEndOfStateForMs(std::string event, int durationI
void FairMQStateMachine::SubscribeToStateChange(const std::string& key, std::function<void(const State)> callback)
{
fStateChangeCallbacks.insert({key, fStateChangeCallback.connect(callback)});
fStateChangeSignalsMap.insert({key, fStateChangeSignal.connect(callback)});
}
void FairMQStateMachine::UnsubscribeFromStateChange(const std::string& key)
{
fStateChangeCallbacks.at(key).disconnect();
fStateChangeCallbacks.erase(key);
fStateChangeSignalsMap.at(key).disconnect();
fStateChangeSignalsMap.erase(key);
}

53
fairmq/FairMQStateMachine.h
View File

@ -85,8 +85,8 @@ struct FairMQFSM_ : public msmf::state_machine_def<FairMQFSM_>
, fWorkAvailable(false)
, fState()
, fChangeStateMutex()
, fStateChangeCallback()
, fStateChangeCallbacks()
, fStateChangeSignal()
, fStateChangeSignalsMap()
{}
// Destructor
@ -134,10 +134,7 @@ struct FairMQFSM_ : public msmf::state_machine_def<FairMQFSM_>
{
LOG(STATE) << "Entering IDLE state";
fsm.fState = IDLE;
if (!fsm.fStateChangeCallbacks.empty())
{
fsm.fStateChangeCallback(IDLE);
}
fsm.CallStateChangeCallbacks(IDLE);
}
};
@ -167,10 +164,7 @@ struct FairMQFSM_ : public msmf::state_machine_def<FairMQFSM_>
{
LOG(STATE) << "Entering DEVICE READY state";
fsm.fState = DEVICE_READY;
if (!fsm.fStateChangeCallback.empty())
{
fsm.fStateChangeCallback(DEVICE_READY);
}
fsm.CallStateChangeCallbacks(DEVICE_READY);
}
};
@ -194,10 +188,7 @@ struct FairMQFSM_ : public msmf::state_machine_def<FairMQFSM_>
{
LOG(STATE) << "Entering READY state";
fsm.fState = READY;
if (!fsm.fStateChangeCallback.empty())
{
fsm.fStateChangeCallback(READY);
}
fsm.CallStateChangeCallbacks(READY);
}
};
@ -266,10 +257,7 @@ struct FairMQFSM_ : public msmf::state_machine_def<FairMQFSM_>
{
LOG(STATE) << "Entering READY state";
fsm.fState = READY;
if (!fsm.fStateChangeCallback.empty())
{
fsm.fStateChangeCallback(READY);
}
fsm.CallStateChangeCallbacks(READY);
fsm.Unblock();
std::unique_lock<std::mutex> lock(fsm.fWorkMutex);
@ -287,10 +275,7 @@ struct FairMQFSM_ : public msmf::state_machine_def<FairMQFSM_>
{
LOG(STATE) << "RUNNING state finished without an external event, entering READY state";
fsm.fState = READY;
if (!fsm.fStateChangeCallback.empty())
{
fsm.fStateChangeCallback(READY);
}
fsm.CallStateChangeCallbacks(READY);
fsm.Unblock();
}
@ -341,10 +326,7 @@ struct FairMQFSM_ : public msmf::state_machine_def<FairMQFSM_>
{
LOG(STATE) << "Entering EXITING state";
fsm.fState = EXITING;
if (!fsm.fStateChangeCallback.empty())
{
fsm.fStateChangeCallback(EXITING);
}
fsm.CallStateChangeCallbacks(EXITING);
// terminate worker thread
{
@ -370,10 +352,7 @@ struct FairMQFSM_ : public msmf::state_machine_def<FairMQFSM_>
{
LOG(STATE) << "Entering ERROR state";
fsm.fState = ERROR;
if (!fsm.fStateChangeCallback.empty())
{
fsm.fStateChangeCallback(ERROR);
}
fsm.CallStateChangeCallbacks(ERROR);
}
};
@ -488,7 +467,7 @@ struct FairMQFSM_ : public msmf::state_machine_def<FairMQFSM_>
EXITING
};
std::string GetStateName(int state) const
static std::string GetStateName(const int state)
{
switch(state)
{
@ -526,6 +505,14 @@ struct FairMQFSM_ : public msmf::state_machine_def<FairMQFSM_>
bool CheckCurrentState(int state) const { return state == fState; }
bool CheckCurrentState(std::string state) const { return state == GetCurrentStateName(); }
void CallStateChangeCallbacks(const State state) const
{
if (!fStateChangeSignal.empty())
{
fStateChangeSignal(state);
}
}
// this is to run certain functions in a separate thread
std::thread fWorkerThread;
@ -542,8 +529,8 @@ struct FairMQFSM_ : public msmf::state_machine_def<FairMQFSM_>
std::atomic<State> fState;
std::mutex fChangeStateMutex;
boost::signals2::signal<void(const State)> fStateChangeCallback;
std::unordered_map<std::string, boost::signals2::connection> fStateChangeCallbacks;
boost::signals2::signal<void(const State)> fStateChangeSignal;
std::unordered_map<std::string, boost::signals2::connection> fStateChangeSignalsMap;
};
// reactivate the warning for non-virtual destructor