FairMQ/fairmq/FairMQStateMachine.cxx
2015-06-19 12:33:06 +02:00

186 lines
5.5 KiB
C++

/********************************************************************************
* Copyright (C) 2014 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH *
* *
* This software is distributed under the terms of the *
* GNU Lesser General Public Licence version 3 (LGPL) version 3, *
* copied verbatim in the file "LICENSE" *
********************************************************************************/
/**
* FairMQStateMachine.cxx
*
* @since 2012-10-25
* @author D. Klein, A. Rybalchenko
*/
#include <boost/exception/all.hpp>
#include <boost/chrono.hpp> // for WaitForEndOfStateForMs()
#include "FairMQStateMachine.h"
#include "FairMQLogger.h"
FairMQStateMachine::FairMQStateMachine()
{
start();
}
FairMQStateMachine::~FairMQStateMachine()
{
stop();
}
int FairMQStateMachine::GetInterfaceVersion()
{
return FAIRMQ_INTERFACE_VERSION;
}
int FairMQStateMachine::GetEventNumber(std::string event)
{
if (event == "INIT_DEVICE") return INIT_DEVICE;
if (event == "INIT_TASK") return INIT_TASK;
if (event == "RUN") return RUN;
if (event == "PAUSE") return PAUSE;
if (event == "RESUME") return RESUME;
if (event == "STOP") return STOP;
if (event == "RESET_DEVICE") return RESET_DEVICE;
if (event == "RESET_TASK") return RESET_TASK;
if (event == "END") return END;
LOG(ERROR) << "Requested number for non-existent event... " << event << std::endl
<< "Supported are: INIT_DEVICE, INIT_TASK, RUN, PAUSE, RESUME, STOP, RESET_DEVICE, RESET_TASK, END";
return -1;
}
bool FairMQStateMachine::ChangeState(int event)
{
try
{
switch (event)
{
case INIT_DEVICE:
process_event(FairMQFSM::INIT_DEVICE());
return true;
case internal_DEVICE_READY:
process_event(FairMQFSM::internal_DEVICE_READY());
return true;
case INIT_TASK:
process_event(FairMQFSM::INIT_TASK());
return true;
case internal_READY:
process_event(FairMQFSM::internal_READY());
return true;
case RUN:
process_event(FairMQFSM::RUN());
return true;
case PAUSE:
process_event(FairMQFSM::PAUSE());
return true;
case RESUME:
process_event(FairMQFSM::RESUME());
return true;
case STOP:
process_event(FairMQFSM::STOP());
return true;
case RESET_DEVICE:
process_event(FairMQFSM::RESET_DEVICE());
return true;
case RESET_TASK:
process_event(FairMQFSM::RESET_TASK());
return true;
case internal_IDLE:
process_event(FairMQFSM::internal_IDLE());
return true;
case END:
process_event(FairMQFSM::END());
return true;
default:
LOG(ERROR) << "Requested unsupported state: " << event << std::endl
<< "Supported are: INIT_DEVICE, INIT_TASK, RUN, PAUSE, RESUME, STOP, RESET_TASK, RESET_DEVICE, END";
return false;
}
}
catch (boost::exception &e)
{
LOG(ERROR) << boost::diagnostic_information(e);
}
}
bool FairMQStateMachine::ChangeState(std::string event)
{
return ChangeState(GetEventNumber(event));
}
void FairMQStateMachine::WaitForEndOfState(int event)
{
try
{
switch (event)
{
case INIT_DEVICE:
case INIT_TASK:
case RUN:
case RESET_TASK:
case RESET_DEVICE:
{
boost::unique_lock<boost::mutex> lock(fStateMutex);
while (!fStateFinished)
{
fStateCondition.wait(lock);
}
break;
}
default:
LOG(ERROR) << "Requested state is either synchronous or does not exist.";
break;
}
}
catch (boost::exception &e)
{
LOG(ERROR) << boost::diagnostic_information(e);
}
}
void FairMQStateMachine::WaitForEndOfState(std::string event)
{
return WaitForEndOfState(GetEventNumber(event));
}
bool FairMQStateMachine::WaitForEndOfStateForMs(int event, int durationInMs)
{
try
{
switch (event)
{
case INIT_DEVICE:
case INIT_TASK:
case RUN:
case RESET_TASK:
case RESET_DEVICE:
{
boost::unique_lock<boost::mutex> lock(fStateMutex);
while (!fStateFinished)
{
fStateCondition.wait_until(lock, boost::chrono::system_clock::now() + boost::chrono::milliseconds(durationInMs));
if (!fStateFinished)
{
return false;
}
}
return true;
break;
}
default:
LOG(ERROR) << "Requested state is either synchronous or does not exist.";
return false;
}
}
catch (boost::exception &e)
{
LOG(ERROR) << boost::diagnostic_information(e);
}
}
bool FairMQStateMachine::WaitForEndOfStateForMs(std::string event, int durationInMs)
{
return WaitForEndOfStateForMs(GetEventNumber(event), durationInMs);
}