ControlFlow.cpp

Go to the documentation of this file.

/*
    Copyright (C) 2010-2012
    Johannes Feuser <feuser@uni-bremen.de>
    This file is part of the openETCS library.

    The openETCS library is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    any later version.

    The openETCS library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with the openETCS library.  If not, see <http://www.gnu.org/licenses/>.
*/

/*!
 *  \author Johannes Feuser <feuser@uni-bremen.de>
 *  \brief control flow classes 
 */

#include "ControlFlow.h"
#include "Transition.h"




namespace oETCS {

namespace DF {


CControlFlow::CState::CState(oETCS::DF::CControlFlow * const pParent, const std::string & StateName, const ::std::vector< oETCS::DF::CFunctionBlock * >& FunctionBlocks, const ::std::vector< oETCS::DF::CAbstractFlow * >& Flows, const bool & bIsFinal, const bool & bIsInitial)  throw()  
:m_Name(StateName),
 m_bIsFinal(bIsFinal),
 m_pParent(pParent),
 m_TransitionStack(0),
 m_FunctionBlocks(FunctionBlocks),
 m_Flows(Flows)
{
  // Bouml preserved body begin 00068882
    // check, if parent pointer is valid
    if (pParent != 0)
    {
        // register this instance at parent control flow
        pParent->AddState(this, bIsInitial);
        
    } // if (pParent != 0)
  // Bouml preserved body end 00068882

} //  CControlFlow::CState::CState()  throw() 




CControlFlow::CState::~CState()  throw()  
{
  // Bouml preserved body begin 00068902
    // empty constructor
  // Bouml preserved body end 00068902

} // CControlFlow::CState::~CState()  throw() 




bool CControlFlow::CState::IsActiveFunctionBlock(const oETCS::DF::CFunctionBlock * const pFunctionBlock)  const throw()  
{
  // Bouml preserved body begin 00093782
    bool                        bFound(false);
    unsigned int                x(0);
    const unsigned int          NUMBER_FUNCTION_BLOCKS(m_FunctionBlocks.size());
    
    
    
    // process all function block objects
    for (x = 0; x < NUMBER_FUNCTION_BLOCKS && !bFound; x++)
    {
        // check current function block object for identity
        bFound = (m_FunctionBlocks[x] == pFunctionBlock);
        
        // check, if not is identical, if current is a (nested) control flow
        if (!bFound && dynamic_cast< ::oETCS::DF::CControlFlow* >(m_FunctionBlocks[x]) != 0)
        {
            // call method recursively on control flow
            bFound = dynamic_cast< ::oETCS::DF::CControlFlow* >(m_FunctionBlocks[x])->IsActiveFunctionBlock(pFunctionBlock);
            
        } // if (!bFound && dynamic_cast< ::oETCS::DF::CControlFlow* >(m_FunctionBlocks[x]) != 0)
        
    } // for (x = 0; x < NUMBER_FUNCTION_BLOCKS && !bFound; x++)
    
    // return found flag
    return bFound;
  // Bouml preserved body end 00093782

} // bool CControlFlow::CState::IsActiveFunctionBlock()  const throw() 




bool CControlFlow::CState::IsActiveFlow(const oETCS::DF::CAbstractFlow * const pFlow)  const throw()  
{
  // Bouml preserved body begin 000CA382
    bool                                bFound(false);
    decltype (m_Flows.begin())          f;
    decltype (m_FunctionBlocks.begin()) fb;

    
    
    // process all flow object
    for (f = m_Flows.begin(); f != m_Flows.end() && not bFound; f++)
    {
        // check current function block object for identity
        bFound = (*f == pFlow);
        
    } // for (f = m_Flows.begin(); f != m_Flows.end() && not bFound; f++)
    
    // check all control flow objects
    for (fb = m_FunctionBlocks.begin(); fb != m_FunctionBlocks.end() && not bFound; fb++)
    {
        // check, if current is a  control flow
        if (!bFound && dynamic_cast< ::oETCS::DF::CControlFlow* >(*fb) != 0)
        {
            // call method recursively on control flow
            bFound = dynamic_cast< ::oETCS::DF::CControlFlow* >(*fb)->IsActiveFlow(pFlow);

        } // if (!bFound && dynamic_cast< ::oETCS::DF::CControlFlow* >(*fb) != 0)

    } // for (fb = m_FunctionBlocks.begin(); fb != m_FunctionBlocks.end() && not bFound; fb++)
    
    // return found flag
    return bFound;
  // Bouml preserved body end 000CA382

} // bool CControlFlow::CState::IsActiveFlow()  const throw() 




void CControlFlow::CState::Execute()  throw(::oETCS::DF::Error::CException)  
{
  // Bouml preserved body begin 00074D02
    unsigned int                        x(0);
    const unsigned int                  NUMBER_FUNCTION_BLOCKS(m_FunctionBlocks.size());
    ::oETCS::DF::CTransition*           pTransition(0);
    
    
    
    
#ifdef __DEBUG_OUTPUT__
                // DEBUG
            ::std::cerr << std::this_thread::get_id() << " " << "CState::Execute()() ----> method entered of state " << this->m_Name << ::std::endl;
#endif
    try
    {
        // execute all related function block objects
        for (x = 0; x < NUMBER_FUNCTION_BLOCKS; x++)
        {
#ifdef __DEBUG_OUTPUT__
                // DEBUG
            ::std::cerr << std::this_thread::get_id() << " " << "CState::Execute()() ----> about to execute function block " << x << ::std::endl;
#endif
            
            // calculate current function block
            m_FunctionBlocks[x]->Calculate();
            
        } // for (x = 0; x < NUMBER_FUNCTION_BLOCKS; x++)
        
        
        // check, if transition stack is not empty
        if (!m_TransitionStack.empty())
        {
            // store first transition on stack
            pTransition = m_TransitionStack[0];
            
            // find transition with highest priority
            for (x = 0; x < m_TransitionStack.size(); x++)
            {
                // compare priorities
                if (pTransition->GetPriority() < m_TransitionStack[x]->GetPriority())
                {
                    // store current transition
                    pTransition = m_TransitionStack[x];
                     
                } // if (pTransition->GetPriority() < m_TransitionStack[x]->GetPriority())
                
            } // for (x = 0; x < m_TransitionStack.size(); x++)
             
            // execute transition
            m_pParent->m_pCurrentState = pTransition->GetTargetState();
            
#ifdef __DEBUG_OUTPUT__
                // DEBUG
            ::std::cerr << std::this_thread::get_id() << " " << "CState::Execute()() ----> executed transition to new state " << m_pParent->m_pCurrentState << ::std::endl;
#endif
            
        } // if (!m_TransitionStack.empty())
        
        // check, if this state is a final state
        if (m_bIsFinal)
        {
            // tell parent control flow to terminate
            m_pParent->m_pCurrentState = 0;
            
#ifdef __DEBUG_OUTPUT__
                // DEBUG
            ::std::cerr << std::this_thread::get_id() << " " << "CState::Execute()() ----> final state reached" << ::std::endl;
#endif
            
        } // if (m_bIsFinal)
        
    } // try
    catch (const ::oETCS::DF::Error::CException&)
    {
        // re-throw exception
        throw;
        
    } // catch (const ::oETCS::DF::Error::CException&)
  // Bouml preserved body end 00074D02

} // void CControlFlow::CState::Execute()  throw(::oETCS::DF::Error::CException) 




CControlFlow::CControlFlow(oETCS::DF::CEVCStateMachine * const pStateMachine)  throw()  
:CFunctionBlock(pStateMachine),
 m_bStart(false),
 m_pCurrentState(0),
 m_pInitialState(0)
{
  // Bouml preserved body begin 00063182
    // empty constructor
  // Bouml preserved body end 00063182

} //  CControlFlow::CControlFlow()  throw() 




CControlFlow::~CControlFlow()  throw()  
{
  // Bouml preserved body begin 00063202
    unsigned int            x(0);


    // delete all states
    for (x = 0; x < m_AvailableStates.size(); x++)
    {
        // delete current telegram
        delete m_AvailableStates[x];

    } // for (x = 0; x < m_AvailableStates.size(); x++)
  // Bouml preserved body end 00063202

} // CControlFlow::~CControlFlow()  throw() 




void CControlFlow::AddState(oETCS::DF::CControlFlow::CState * const pState, const bool& bIsInitial)  throw()  
{
  // Bouml preserved body begin 00091D82
    // check, if state pointer is valid
    if (pState != 0)
    {
        // add state object to vector
        m_AvailableStates.push_back(pState);
        
        // check, if state is initial state
        if (bIsInitial)
        {
            // set state object as initial state object
            m_pInitialState = pState;
            
        } // if (bIsInitial)
        
    } // if (pState != 0)
  // Bouml preserved body end 00091D82

} // void CControlFlow::AddState()  throw() 




bool CControlFlow::IsActiveFunctionBlock(const oETCS::DF::CFunctionBlock * const pFunctionBlock)  const throw()  
{
  // Bouml preserved body begin 00093702
    bool                bFound(false);
    
    
    // check, if control flow is running
    if (m_pCurrentState != 0)
    {
        // get result form active state
        bFound = m_pCurrentState->IsActiveFunctionBlock(pFunctionBlock);
        
    } // if (m_pCurrentState != 0)
    
    // return found value
    return bFound;
  // Bouml preserved body end 00093702

} // bool CControlFlow::IsActiveFunctionBlock()  const throw() 




bool CControlFlow::IsActiveFlow(const oETCS::DF::CAbstractFlow * const pFlow)  const throw()  
{
  // Bouml preserved body begin 000CA402
    bool                bFound(false);
    
    
    // check, if control flow is running
    if (m_pCurrentState != 0)
    {
        // get result form active state
        bFound = m_pCurrentState->IsActiveFlow(pFlow);
        
    } // if (m_pCurrentState != 0)
    
    // return found value
    return bFound;
  // Bouml preserved body end 000CA402

} // bool CControlFlow::IsActiveFlow()  const throw() 




oETCS::DF::CControlFlow::CState* const CControlFlow::GetCurrentState()  const throw()  
{
  // Bouml preserved body begin 00086102
    // return pointer to current state
    return m_pCurrentState;
  // Bouml preserved body end 00086102

} // oETCS::DF::CControlFlow::CState CControlFlow::GetCurrentState()  const throw() 




void CControlFlow::Calculate()  throw(::oETCS::DF::Error::CException)  
{
  // Bouml preserved body begin 00063102
    unsigned int                x(0);
    const unsigned int          NUMBER_RUNNING_OUTPUTS(m_IsRunning.size());
    const unsigned int          NUMBER_STATE_OUTPUTS(m_ActiveStateName.size());
    
 
    
#ifdef __DEBUG_OUTPUT__
                // DEBUG
    ::std::cerr << std::this_thread::get_id() << " " << "CControlFlow::Calculate() ----> method entered " << ::std::endl;
#endif
    
    // check, if control flow is started and was not running
    if (m_pCurrentState == 0 && m_pInitialState != 0 && m_bStart())
    {       
        // assign initial state object as current one
        m_pCurrentState = m_pInitialState;
        
#ifdef __DEBUG_OUTPUT__
                // DEBUG
        ::std::cerr << std::this_thread::get_id() << " " << "CControlFlow::Calculate() ----> (re)started control flow with initial state " << m_pCurrentState << ::std::endl;
#endif

    } // if (m_pCurrentState == 0 && m_pInitialState != 0 && m_bStart())
    
    // check, if a current state is available
    if (m_pCurrentState != 0)
    {
#ifdef __DEBUG_OUTPUT__
                // DEBUG
        ::std::cerr << std::this_thread::get_id() << " " << "CControlFlow::Calculate() ----> about to execute current state " << m_pCurrentState << ::std::endl;
#endif
        
        for (x = 0; x < NUMBER_STATE_OUTPUTS; x++)
        {
            // set current output
            *(m_ActiveStateName[x]) = m_pCurrentState->m_Name;

        } // for (x = 0; x < NUMBER_STATE_OUTPUTS; x++)

        try
        {
            // execute current active state
            m_pCurrentState->Execute();

        } // try
        catch (const ::oETCS::DF::Error::CException&)
        {
            // re-throw exception
            throw;

        } // catch (const ::oETCS::DF::Error::CException&)

    } // if (m_pCurrentState != 0)
    
    // set running flag in all outputs
    for (x = 0; x < NUMBER_RUNNING_OUTPUTS; x++)
    {
        // set current output
        *(m_IsRunning[x]) = (m_pCurrentState != 0);

    } // for (x = 0; x < NUMBER_RUNNING_OUTPUTS; x++)

  // Bouml preserved body end 00063102

} // void CControlFlow::Calculate()  throw(::oETCS::DF::Error::CException) 






} // namespace oETCS::DF

} // namespace oETCS