EVCStateMachine.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 EVC State machine class and all further classes needed for the core functionality
 */

#include "EVCStateMachine.h"
#include "Transition.h"
#include "Language.h"
#include "Storage.h"
#include "FunctionBlocks.h"




namespace oETCS {

namespace DF {


CEVCStateMachine::CEVCState::CDataFlow::CDataFlow(oETCS::DF::CEVCStateMachine::CEVCState * const pState, const std::string & ApplicationLevel, const ::std::vector< oETCS::DF::CFunctionBlock * >& FunctionBlocks, const ::std::vector< oETCS::DF::CAbstractFlow * >& Flows, oETCS::DF::CDMISubject * const pDMI, oETCS::DF::CEVCStateMachine::CEVCState * const pFaultState)  throw()  
:m_pDMI(pDMI),
 m_FunctionBlocks(FunctionBlocks),
 m_Flows(Flows),
 m_pParent(pState),
 m_pFaultState(pFaultState)
{
  // Bouml preserved body begin 0005F982
    // add this data flow object to parent EVC state
    m_pParent->AddDataFlow(ApplicationLevel, this);
  // Bouml preserved body end 0005F982

} //  CEVCStateMachine::CEVCState::CDataFlow::CDataFlow()  throw() 




CEVCStateMachine::CEVCState::CDataFlow::~CDataFlow()  throw()  
{
  // Bouml preserved body begin 0005FA02
    // delete DMI widget
    delete m_pDMI;
  // Bouml preserved body end 0005FA02

} // CEVCStateMachine::CEVCState::CDataFlow::~CDataFlow()  throw() 




::std::vector< oETCS::DF::CFunctionBlock* > CEVCStateMachine::CEVCState::CDataFlow::GetFunctionBlocks()  const throw()  
{
  // Bouml preserved body begin 00087B02
    // return vector of function block pointers
    return (m_FunctionBlocks);
  // Bouml preserved body end 00087B02

} // oETCS::DF::CFunctionBlock CEVCStateMachine::CEVCState::CDataFlow::GetFunctionBlocks()  const throw() 




bool CEVCStateMachine::CEVCState::CDataFlow::IsActiveFunctionBlock(const oETCS::DF::CFunctionBlock * const pFunctionBlock)  const throw()  
{
  // Bouml preserved body begin 00063482
    unsigned int            x;
    const unsigned int      NUMBER_FUNCTION_BLOCKS(m_FunctionBlocks.size());
    bool                    bFound(false);
    
    
    // process all function block objects
    for (x = 0; x < NUMBER_FUNCTION_BLOCKS && !bFound; x++)
    {
        // compare current function block address with parameter
        bFound = (pFunctionBlock == m_FunctionBlocks[x]);
        
        // check, if not is identical, if current function block is a control flow
        if (!bFound && dynamic_cast< ::oETCS::DF::CControlFlow* >(m_FunctionBlocks[x]) != 0)
        {
            // get result form 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 00063482

} // bool CEVCStateMachine::CEVCState::CDataFlow::IsActiveFunctionBlock()  const throw() 




bool CEVCStateMachine::CEVCState::CDataFlow::IsActiveFlow(const oETCS::DF::CAbstractFlow * const pFlow)  const throw()  
{
  // Bouml preserved body begin 000C5682
    bool                                bFound(false);
    decltype (m_Flows.begin())          f;
    decltype (m_FunctionBlocks.begin()) fb;
    
    
    
    // check all flows in this data flow for parameter
    for (f = m_Flows.begin(); f != m_Flows.end() && not bFound; f++)
    {
        // check, if current flow is searched flow
        bFound = (pFlow == *f);
        
    } // 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) != nullptr)
        {
            // call method recursively on control flow
            bFound = static_cast< ::oETCS::DF::CControlFlow* >(*fb)->IsActiveFlow(pFlow);

        } // if (!bFound && dynamic_cast< ::oETCS::DF::CControlFlow* >(*fb) != nullptr)
        
    } // for (fb = m_FunctionBlocks.begin(); fb != m_FunctionBlocks.end() && not bFound; fb++)
    
    // return found flag
    return (bFound);
  // Bouml preserved body end 000C5682

} // bool CEVCStateMachine::CEVCState::CDataFlow::IsActiveFlow()  const throw() 




void CEVCStateMachine::CEVCState::CDataFlow::Execute()  throw(::oETCS::DF::Error::CException)  
{
  // Bouml preserved body begin 00066A82
    unsigned int            x;
    const unsigned int      NUMBER_FUNCTION_BLOCKS(m_FunctionBlocks.size());
    
    
    try
    {
        // execute all function block elements in their order
        for (x = 0; x < NUMBER_FUNCTION_BLOCKS; x++)
        {
            // check, if this is first execution point (k=0) for this data flow
            if (::oETCS::DF::CEnteredTrigger::m_bEnteredState)
            {
                // check, if current function block object is of type CComBlockIn
                if (dynamic_cast< ::oETCS::DF::CComBlockIn* >(m_FunctionBlocks[x]) != nullptr)
                {
                    // clear all old telegrams on object
                    static_cast< ::oETCS::DF::CComBlockIn* >(m_FunctionBlocks[x])->Clear();

                } // if (dynamic_cast< ::oETCS::DF::CComBlockIn* >(m_FunctionBlocks[x]) != nullptr)

            } // if (::oETCS::DF::CEnteredTrigger::m_bEnteredState)

            // execute current function block object
            m_FunctionBlocks[x]->Calculate();

        } // for (x = 0; x < NUMBER_FUNCTION_BLOCKS; x++)
    
    } // try
    catch (const ::oETCS::DF::Error::CException& Exception)
    {
        
#ifdef __DEBUG_OUTPUT__
            // DEBUG
            ::std::cerr << std::this_thread::get_id() << " " << "CDataFlow::Execute() ----> exception in function block object " << x << ::std::endl;
#endif
        
        // check, if fault state is available in this data flow
        if (m_pFaultState != 0)
        {
            // currently no differentiation between exception types (faults / errors)
            m_pParent->m_pParent->m_pCurrentState = m_pFaultState;
            
            // activate level switch
            m_pParent->m_bStateLevelSwitch = true;
            
            // print error for debugging purpose
            ::std::cerr << "Error while executing data flow: " << Exception.what() << " in " << __FILE__ << " at line " << __LINE__ << ::std::endl;
            
        } // if (m_pFaultState != 0)
        else
        {
            // without fault state simply re-throw exception (disabled for testing purpose)
            //throw;
            
            // print warning and just ignore error (for testing purpose)
            ::std::cerr << "Error while executing data flow, but now fault state available: " << Exception.what() << " in " << __FILE__ << " at line " << __LINE__ << ::std::endl;
            
        } // else
        
    } // catch (const ::oETCS::DF::Error::CException& Exception)
    
  // Bouml preserved body end 00066A82

} // void CEVCStateMachine::CEVCState::CDataFlow::Execute()  throw(::oETCS::DF::Error::CException) 




CEVCStateMachine::CEVCState::CEVCState(oETCS::DF::CEVCStateMachine * const pParent)  throw()  
:m_bStateLevelSwitch(false),
 m_iLockedThreads(0),
 m_pParent(pParent),
 m_Transitions(0),
 m_CurrentDataFlow(0)
{
  // Bouml preserved body begin 0005FB02
    // check, if pointer to parent is valid
    if (m_pParent != 0)
    {
        // add this state to parent state machine
        m_pParent->AddState(this);
        
    } // if (m_pParent != 0)
  // Bouml preserved body end 0005FB02

} //  CEVCStateMachine::CEVCState::CEVCState()  throw() 




CEVCStateMachine::CEVCState::~CEVCState()  throw()  
{
  // Bouml preserved body begin 0005FB82
    unsigned int                     x(0);
    decltype (m_DataFlows.begin())   y(0);
    
    
    
    // check, if state is running
    if (this->IsRunning())
    {
        // stop state
        this->Stop();
        
    } // if (this->IsRunning())
    
    // delete all transitions
    for (x = 0; x < m_Transitions.size(); x++)
    {
        // delete current transition object
        delete m_Transitions[x];
        
    } // for (x = 0; x < m_Transitions.size(); x++)
    
    // delete all data flows by their application level
    for (y = m_DataFlows.begin(); y != m_DataFlows.end(); y++)
    {
        // delete all data flow objects in current application level
        for (x = 0; x < y->second.size(); x++)
        {
            // delete current data flow
            delete y->second[x];
            
        } // for (x = 0; x < y->second.size(); x++)
        
    } // for (y = m_DataFlows.begin(); y != m_DataFlows.end(); y++)
    
    
  // Bouml preserved body end 0005FB82

} // CEVCStateMachine::CEVCState::~CEVCState()  throw() 




void CEVCStateMachine::CEVCState::Start()  throw(::oETCS::DF::Error::CException)  
{
  // Bouml preserved body begin 00063282
    decltype (m_DataFlows.begin())      x(m_DataFlows.find(m_pParent->m_CurrentApplicationLevel));
    unsigned int                        y(0);
    
    
       
    // check, if data flow(s) exist for application level
    if (x == m_DataFlows.end())
    {
        // throw exception
        throw (::oETCS::DF::Error::CInternal("no corresponding application level in data flow"));
        
    } // if (x == m_DataFlows.end())
    
    // check, if another data flow is been executed
    if (this->IsRunning() && m_CurrentDataFlow != x->second)
    {
        // throw exception
        throw (::oETCS::DF::Error::CInternal("another data flow is currently be executed"));
        
    } // if (this->IsRunning() && m_CurrentDataFlow != x->second)
    
    // check, if no data flow is currently executed
    if (m_CurrentDataFlow.empty())
    {
        // assign current data flow from map
        m_CurrentDataFlow = x->second;
        
        // reset switch flag
        m_bStateLevelSwitch = false;
        
        // reset number of locked threads
        m_iLockedThreads = 0;
        
        // resize vector of threads
        m_Threads.resize(m_CurrentDataFlow.size());
        
        // start all independent data flows
        for (y = 0; y < m_CurrentDataFlow.size(); y++)
        {
            try
            {
                // set flag for newly entered data flow
                ::oETCS::DF::CEnteredTrigger::m_bEnteredState = true;
                
                // create new thread
                m_Threads[y] = (new ::std::thread(&::oETCS::DF::CEVCStateMachine::CEVCState::DataFlowThread, this, y));
                
#ifdef __DEBUG_OUTPUT__
                // DEBUG
                ::std::cerr << std::this_thread::get_id() << " " << "StateThread ----> new state object started " << this << ::std::endl;
#endif
                
            } // try
            catch (const ::std::bad_alloc&)
            {
                // delete all already created threads
                for (y = 0; y < m_Threads.size(); y++)
                {
                    // delete current thread
                    delete m_Threads[y];
                    
                } // for (y = 0; y < m_Threads.size(); y++)
                
                // clear current data flow vector
                m_CurrentDataFlow.clear();

                // clear vector with thread pointers
                m_Threads.clear();

                // reset state/level switch flag
                m_bStateLevelSwitch = false;
                
                // throw exception
                throw (::oETCS::DF::Error::CInternal("not enough memory available for creating thread"));
                
            } // catch (const ::std::bad_alloc&)
            catch (const ::std::exception& Exception)
            {
#ifdef __DEBUG_OUTPUT__
                // DEBUG
                ::std::cerr << std::this_thread::get_id() << " " << "StateThread ----> uncaught ::std::exception " << Exception.what() << ::std::endl;
#endif
                
            } // catch (const ::std::exception& Exception)
            
        } // for (y = 0; y < m_CurrentDataFlow.size(); y++)
        
        // notify all observers via parent EVC state machine about new state/application level
        m_pParent->Notify();
        
        // wait for all threads to finish and delete them
        for (y = 0; y < m_Threads.size(); y++)
        {
            // check, if current thread is joinable
            if (m_Threads[y]->joinable())
            {
#ifdef __DEBUG_OUTPUT__
                // DEBUG
                ::std::cerr << std::this_thread::get_id() << " " << "CEVCState::Start() -----> waiting for thread " << y << ::std::endl;
#endif
                
                // wait for current thread                
                m_Threads[y]->join();
            
            } // if (m_Threads[y]->joinable())
            
            // delete current thread
            delete m_Threads[y];
            
#ifdef __DEBUG_OUTPUT__
            // DEBUG
            ::std::cerr << std::this_thread::get_id() << " " << "CEVCState::Start() -----> deleted thread " << y << ::std::endl;
#endif
            
        } // for (y = 0; y < m_Threads.size(); y++)
        
        // clear current data flow vector
        m_CurrentDataFlow.clear();

        // clear vector with thread pointers
        m_Threads.clear();
        
        // reset state/level switch flag
        m_bStateLevelSwitch = false;
        
        // check, if exception ny data flows where stored in the stack
        if (m_DataFlowExceptions.size() > 0)
        {
            // clear exception stack
            m_DataFlowExceptions.clear();
            
            // throw exception
            throw (::oETCS::DF::Error::CInternal("error during execution of data flow"));
            
        } // if (m_DataFlowExceptions.size() > 0)
        
    } // if (m_CurrentDataFlow.empty())
    
  // Bouml preserved body end 00063282

} // void CEVCStateMachine::CEVCState::Start()  throw(::oETCS::DF::Error::CException) 




void CEVCStateMachine::CEVCState::Stop()  throw()  
{
  // Bouml preserved body begin 00063402
    // check, if state is currently running
    if (this->IsRunning())
    {
#ifdef __DEBUG_OUTPUT__
        // DEBUG
        ::std::cerr << std::this_thread::get_id() << " " << "CEVCState::Stop() called " << ::std::endl;
#endif
        
        // use state/level switch to enable soft finishing
        m_bStateLevelSwitch = true;

#ifdef __DEBUG_OUTPUT__
        // DEBUG
        ::std::cerr << std::this_thread::get_id() << " " << "CEVCState::Stop() -----> waiting for this EVC state " << this << ::std::endl;
#endif

        // wait until all data flow threads notify their termination
        while (this->IsRunning())
        {
            // yield
            ::std::this_thread::yield();
            
            // use state/level switch to enable soft finishing (reset here to ensure notification)
            m_bStateLevelSwitch = true;
            
        } // while (this->IsRunning())

#ifdef __DEBUG_OUTPUT__
        // DEBUG
        ::std::cerr << std::this_thread::get_id() << " " << "CEVCState::Stop() -----> # threads after waiting " << m_Threads.size() << ::std::endl;
#endif
            
    } // if (this->IsRunning())

  // Bouml preserved body end 00063402

} // void CEVCStateMachine::CEVCState::Stop()  throw() 




bool CEVCStateMachine::CEVCState::IsRunning()  const throw()  
{
  // Bouml preserved body begin 0006FB02
    // return execution flag
    return (!m_CurrentDataFlow.empty());
  // Bouml preserved body end 0006FB02

} // bool CEVCStateMachine::CEVCState::IsRunning()  const throw() 




bool CEVCStateMachine::CEVCState::IsActiveFunctionBlock(oETCS::DF::CFunctionBlock * const pFunctionBlock)  const throw()  
{
  // Bouml preserved body begin 00090202
    bool                    bActive(false);
    unsigned int            x(0);
    const unsigned int      NUMBER_DATA_FLOWS(m_CurrentDataFlow.size());
    
    
    
    // process all data flows in this state for current application level
    for (x = 0; x < NUMBER_DATA_FLOWS && !bActive; x++)
    {
        // process current data flow
        bActive = m_CurrentDataFlow[x]->IsActiveFunctionBlock(pFunctionBlock);
        
    } // for (x = 0; x < NUMBER_DATA_FLOWS && !bActive; x++)
    
    // return active flag
    return (bActive);
  // Bouml preserved body end 00090202

} // bool CEVCStateMachine::CEVCState::IsActiveFunctionBlock()  const throw() 




bool CEVCStateMachine::CEVCState::IsActiveFlow(oETCS::DF::CAbstractFlow * const pFlow)  const throw()  
{
  // Bouml preserved body begin 000C7082
    bool                    bActive(false);
    unsigned int            x(0);
    const unsigned int      NUMBER_DATA_FLOWS(m_CurrentDataFlow.size());
    
    
    
    // process all data flows in this state for current application level
    for (x = 0; x < NUMBER_DATA_FLOWS && !bActive; x++)
    {
        // process current data flow
        bActive = m_CurrentDataFlow[x]->IsActiveFlow(pFlow);
        
    } // for (x = 0; x < NUMBER_DATA_FLOWS && !bActive; x++)
    
    // return active flag
    return (bActive);
  // Bouml preserved body end 000C7082

} // bool CEVCStateMachine::CEVCState::IsActiveFlow()  const throw() 




::std::vector< oETCS::DF::CTransition* > CEVCStateMachine::CEVCState::GetTransitions()  const throw()  
{
  // Bouml preserved body begin 00086082
    // return all transitions
    return (m_Transitions);
  // Bouml preserved body end 00086082

} // oETCS::DF::CTransition CEVCStateMachine::CEVCState::GetTransitions()  const throw() 




::std::vector< oETCS::DF::CEVCStateMachine::CEVCState::CDataFlow* > CEVCStateMachine::CEVCState::GetCurrentDataFlow()  const throw()  
{
  // Bouml preserved body begin 00086182
    // return current data flow(s)
    return (m_CurrentDataFlow);
  // Bouml preserved body end 00086182

} // oETCS::DF::CEVCStateMachine::CEVCState::CDataFlow CEVCStateMachine::CEVCState::GetCurrentDataFlow()  const throw() 




void CEVCStateMachine::CEVCState::AddDataFlow(const std::string& ApplicationLevel, oETCS::DF::CEVCStateMachine::CEVCState::CDataFlow * const pDataFlow)  throw()  
{
  // Bouml preserved body begin 0008CB82
    // check, if pointer is valid
    if (pDataFlow !=0)
    {
        // add pointer to vector in map
        m_DataFlows[ApplicationLevel].push_back(pDataFlow);
        
    } // if (pDataFlow !=0)
  // Bouml preserved body end 0008CB82

} // void CEVCStateMachine::CEVCState::AddDataFlow()  throw() 




void CEVCStateMachine::CEVCState::AddTransition(oETCS::DF::CTransition * const pTransition)  throw()  
{
  // Bouml preserved body begin 0008CB02
    // check, if pointer is valid
    if (pTransition !=0)
    {
        // add pointer to vector
        m_Transitions.push_back(pTransition);
        
    } // if (m_pTransitions !=0)
  // Bouml preserved body end 0008CB02

} // void CEVCStateMachine::CEVCState::AddTransition()  throw() 




void CEVCStateMachine::CEVCState::DataFlowThread(const unsigned int & iIndex)  throw()  
{
  // Bouml preserved body begin 00071582
    ::std::mutex                                                            Mutex;
    ::std::unique_lock< ::std::mutex >                                      Lock(Mutex);
    ::std::chrono::time_point< ::std::chrono::high_resolution_clock, 
    ::std::chrono::duration< long long, 
     ::std::chrono::high_resolution_clock::duration::period > >             StartTime;
    ::std::chrono::duration< long long, 
     ::std::chrono::high_resolution_clock::duration::period >               SleepTime;
    const ::std::chrono::duration< long long, 
    ::std::chrono::high_resolution_clock::duration::period >                SAMPLE_TIME(::std::chrono::microseconds(__DATA_FLOW_SAMPLE_TIME__));
    const ::oETCS::DF::CEVCTransition*                                      pStateTransition(0);
    unsigned int                                                            x(0);
    

    
    
    // synchronise with all other threads at start
    // check, if this is already last thread for synchronisation 
    if (m_iLockedThreads == (m_Threads.size() - 1))
    {
   
        // notify all other threads to proceed
        m_Barrier.notify_all();

    } // if (m_iLockedThreads == (m_Threads.size() - 1))
    else
    {                
        // increase number of locked threads
        m_iLockedThreads++;

        // wait for all remaining executing threads
        m_Barrier.wait(Lock);

    } // else
    
    // compute start time once
    StartTime = ::std::chrono::high_resolution_clock::now();

    // execute thread until a state and/or level switch
    while (!m_bStateLevelSwitch)
    {
        try
        {
            // execute related data flow once
            m_CurrentDataFlow[iIndex]->Execute();

#ifdef __DEBUG_OUTPUT__
            // DEBUG
            ::std::cerr << std::this_thread::get_id() << " " << "DataFlowThread ----> # executed data flow " << iIndex << ::std::endl;
#endif

        } // try
        catch (const ::oETCS::DF::Error::CException& Exception)
        {
            // create and print error message to stderr
            ::std::cerr << "Error while executing data flow # " << iIndex << ": " << Exception.what() << " in " << __FILE__ << " at line " << __LINE__ << ::std::endl;

            // store exception on stack
            m_DataFlowExceptions.push_back(Exception);

            // stop execution of all threads by using the switch flag
            m_bStateLevelSwitch = true;

        } // catch (const ::oETCS::DF::Error::CException& Exception)
        
        
#ifdef __DEBUG_OUTPUT__
        // DEBUG
        ::std::cerr << std::this_thread::get_id() << " " << "DataFlowThread ----> # locked threads " << m_iLockedThreads << " # threads " << m_Threads.size() << ::std::endl;
#endif

        // check, if this is already last thread for synchronisation 
        if (m_iLockedThreads == (m_Threads.size() - 1))
        {
            // check, if any transitions were placed on stack
            if (m_TransitionStack.size() > 0)
            {
                // store very first pointer
                pStateTransition = m_TransitionStack[0];

                // search all other transition on stack for higher priority
                for (x = 1; x < m_TransitionStack.size(); x++)
                {
                    // compare current priority with stored one
                    if (pStateTransition->GetPriority() < m_TransitionStack[x]->GetPriority())
                    {
                        // store current transition
                        pStateTransition = m_TransitionStack[x];

                    } // if (pStateTransition->GetPriority() < m_TransitionStack[x]->GetPriority())

                } // for (x = 0; x < m_TransitionStack.size(); x++)

                // do sanity check of transition object
                if (pStateTransition->GetStartState() != this)
                {
                    // print error message to stderr
                    ::std::cerr << "In file " << __FILE__ << " at line " << __LINE__ << ": activated transition object has false start state" << ::std::endl;

                } // if (pStateTransition->GetStartState() != this)

                // set pointer to new state in parent state machine
                m_pParent->m_pCurrentState = pStateTransition->GetTargetState();

#ifdef __DEBUG_OUTPUT__
                // DEBUG
                ::std::cerr << std::this_thread::get_id() << " " << "DataFlowThread ----> switch to new state object " <<  m_pParent->m_pCurrentState << ::std::endl;
#endif

                // activate flag for state/level switch
                m_bStateLevelSwitch = true; 

                // clear transition stack
                m_TransitionStack.clear();

            } // if (m_TransitionStack.size() > 0)

            // reset the number of locked threads
            m_iLockedThreads = 0;
            
            // reset entered flag
            ::oETCS::DF::CEnteredTrigger::m_bEnteredState = false;

            // notify all other threads to proceed
            m_Barrier.notify_all();

        } // if (m_iLockedThreads == (m_Threads.size() - 1))
        else
        {                
            // increase number of locked threads
            m_iLockedThreads++;

            // wait for all remaining executing threads
            m_Barrier.wait(Lock);

        } // else


        // compute sleep time by execution time until now
        SleepTime = SAMPLE_TIME - (::std::chrono::high_resolution_clock::now() - StartTime);

        // check, if sample time was no exceeded
        if (SleepTime.count() >= 0 )
        {
            // put thread to sleep
            ::std::this_thread::sleep_for(SleepTime);

        } // if (SleepTime.count() >= 0 )
        else
        {
            // print warning to stderr
            ::std::cerr << "In file " << __FILE__ << " in line " << __LINE__ << ": sample time exceeded in thread" << std::endl;

        } // else

        // calculate next start time point to avoid global drifts
        StartTime += SAMPLE_TIME;

    } // while (!m_bStateLevelSwitch)

#ifdef __DEBUG_OUTPUT__
    // DEBUG
    ::std::cerr << std::this_thread::get_id() << " " << "DataFlowThread ----> execution self stopped (end of while)" << ::std::endl;
#endif

  // Bouml preserved body end 00071582

} // void CEVCStateMachine::CEVCState::DataFlowThread()  throw() 




CEVCStateMachine::CEVCStateMachine()  throw()  
:m_bStarted(false),
 m_AvailableStates(0),
 m_Transitions(0),
 m_FunctionBlocks(0),
 m_CurrentApplicationLevel(),
 m_pCurrentState(0),
 m_pThread(0)
{
  // Bouml preserved body begin 00064E02
    // empty constructor
  // Bouml preserved body end 00064E02

} //  CEVCStateMachine::CEVCStateMachine()  throw() 




CEVCStateMachine::~CEVCStateMachine()  throw()  
{
  // Bouml preserved body begin 00064E82
    unsigned int                    x(0);
    decltype (m_Flows.begin())      f;
    
    
    // check, if a current state is available and executing
    if (m_pCurrentState != 0 && m_pCurrentState->IsRunning())
    {
        // stop current state
        this->Stop();
        
    } // if (m_pCurrentState != 0 && m_pCurrentState->IsRunning())
    
    // delete all state objects
    for (x = 0; x < m_AvailableStates.size(); x++)
    {
        // delete current state object
        delete m_AvailableStates[x];
        
    } // for (x = 0; x < m_AvailableStates.size(); x++)
    
    // delete all transition objects
    for (x = 0; x < m_Transitions.size(); x++)
    {
        // delete current transition object
        delete m_Transitions[x];

    } // for (x = 0; x < m_Transitions.size(); x++)
    
    // delete all language objects
    for (x = 0; x < m_Language.size(); x++)
    {
        // delete current language object
        delete m_Language[x];

    } // for (x = 0; x < m_Language.size(); x++)
    
    // delete all flows objetcs
    for (f = m_Flows.begin(); f != m_Flows.end(); f++)
    {
        // delete current flow object
        delete *f;
        
    } // for (f = m_Flows.begin(); f != m_Flows.end(); f++)
    
  // Bouml preserved body end 00064E82

} // CEVCStateMachine::~CEVCStateMachine()  throw() 




void CEVCStateMachine::AddFunctionBlock(oETCS::DF::CFunctionBlock * const pFunctionBlock)  throw()  
{
  // Bouml preserved body begin 0008CD02
    // check, if pointer is valid
    if (pFunctionBlock != 0)
    {
        // add pointer to local vector
        m_FunctionBlocks.push_back(pFunctionBlock);

    } // if (pFunctionBlock != 0)
  // Bouml preserved body end 0008CD02

} // void CEVCStateMachine::AddFunctionBlock()  throw() 




void CEVCStateMachine::AddState(oETCS::DF::CEVCStateMachine::CEVCState * const pState)  throw()  
{
  // Bouml preserved body begin 0008CC02
    // check, if pointer is valid
    if (pState != 0)
    {
        // add pointer to local vector
        m_AvailableStates.push_back(pState);
        
    } // if (pState != 0)
  // Bouml preserved body end 0008CC02

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




void CEVCStateMachine::AddTransition(oETCS::DF::CEVCTransition * const pTransition)  throw()  
{
  // Bouml preserved body begin 0008CC82
    // check, if pointer is valid
    if (pTransition != 0)
    {
        // add pointer to local vector
        m_Transitions.push_back(pTransition);
        
    } // if (pTransition != 0)
  // Bouml preserved body end 0008CC82

} // void CEVCStateMachine::AddTransition()  throw() 




void CEVCStateMachine::AddLanguage(oETCS::DF::CLanguage * const pLanguage)  throw()  
{
  // Bouml preserved body begin 000A6C82
    // check, if pointer is valid
    if (pLanguage != 0)
    {
        // add pointer to local vector
        m_Language.push_back(pLanguage);
        
    } // if (pLanguage != 0)
  // Bouml preserved body end 000A6C82

} // void CEVCStateMachine::AddLanguage()  throw() 




void CEVCStateMachine::AddFlow(oETCS::DF::CAbstractFlow * const pFlow)  throw()  
{
  // Bouml preserved body begin 000C8A02
    // check, if pointer is valid
    if (pFlow != 0)
    {
        // add pointer to local vector
        m_Flows.push_back(pFlow);
        
    } // if (pLanguage != 0)
  // Bouml preserved body end 000C8A02

} // void CEVCStateMachine::AddFlow()  throw() 




void CEVCStateMachine::AttachObserver(oETCS::DF::CDMIObserver * const pDMIObserver)  throw()  
{
  // Bouml preserved body begin 000C3A02
    // check, if pointer to observer is valid
    if (pDMIObserver != nullptr)
    {
        // add current pointer to vector
        m_Observers.push_back(pDMIObserver);
        
    } // if (pDMIObserver != nullptr)
  // Bouml preserved body end 000C3A02

} // void CEVCStateMachine::AttachObserver()  throw() 




void CEVCStateMachine::DetachObserver(oETCS::DF::CDMIObserver * const pDMIObserver)  throw()  
{
  // Bouml preserved body begin 000C3A82
    decltype (m_Observers.begin())      o;
    
    
    
    // check, if pointer to observer is valid
    if (pDMIObserver != nullptr)
    {
        // try to find observer in vector
        for (o = m_Observers.begin(); o != m_Observers.end(); o++)
        {
            // check, if current pointer matches
            if (*o == pDMIObserver)
            {
                // remove current entry from vector
                o = m_Observers.erase(o) - 1;
                
            } // if (*o == pDMIObserver)
            
        } // for (o = m_Observers.begin(); o != m_Observers.end(); o++)
        
    } // if (pDMIObserver != nullptr)
  // Bouml preserved body end 000C3A82

} // void CEVCStateMachine::DetachObserver()  throw() 




oETCS::DF::CEVCStateMachine::CEVCState* const CEVCStateMachine::GetActiveState()  const throw()  
{
  // Bouml preserved body begin 00072F02
    // return pointer to current state
    return (m_pCurrentState);
  // Bouml preserved body end 00072F02

} // oETCS::DF::CEVCStateMachine::CEVCState CEVCStateMachine::GetActiveState()  const throw() 




::std::vector< oETCS::DF::CEVCTransition* > CEVCStateMachine::GetTransitions()  const throw()  
{
  // Bouml preserved body begin 00072F82
    // return vector with all transitions
    return (m_Transitions);
  // Bouml preserved body end 00072F82

} // ::std::vector< oETCS::DF::CEVCTransition* > CEVCStateMachine::GetTransitions()  const throw() 




::std::vector< oETCS::DF::CEVCStateMachine::CEVCState* > CEVCStateMachine::GetStates()  const throw()  
{
  // Bouml preserved body begin 00089782
    // return vector with all states
    return (m_AvailableStates);
  // Bouml preserved body end 00089782

} // ::std::vector< oETCS::DF::CEVCStateMachine::CEVCState* > CEVCStateMachine::GetStates()  const throw() 




oETCS::DF::CDMISubject* CEVCStateMachine::GetCurrentDMI()  throw()  
{
  // Bouml preserved body begin 000C3B02
    ::oETCS::DF::CDMISubject*           pCurrentDMI(nullptr);
    
    
    
    // check, if current state is valid
    if (m_pCurrentState != nullptr)
    {
        // check, if current state has at least one data flow object
        if (not m_pCurrentState->GetCurrentDataFlow().empty())
        {
            // set current DMI from first data flow
            pCurrentDMI = m_pCurrentState->GetCurrentDataFlow()[0]->m_pDMI;
        
        } // if (not m_pCurrentState->GetCurrentDataFlow().empty())
            
    } // if (m_pCurrentState != nullptr)
    
    // return pointer to current DMI subject
    
    return (pCurrentDMI);
  // Bouml preserved body end 000C3B02

} // oETCS::DF::CDMISubject CEVCStateMachine::GetCurrentDMI()  throw() 




void CEVCStateMachine::Start(oETCS::DF::CEVCStateMachine::CEVCState * const pStartState, const std::string & ApplicationLevel)  throw(::oETCS::DF::Error::CException)  
{
  // Bouml preserved body begin 0006FA02
    unsigned int            x(0);
    bool                    bFound(false);
    
    
    // check, if a current state is valid
    if (pStartState == 0)
    {
        // throw exception
        throw (::oETCS::DF::Error::CInternal("pointer to start state is not valid"));
        
    } // if (pStartState == 0)
    
    // check, if state machine is not already running
    if (m_pCurrentState == 0 || !m_pCurrentState->IsRunning())
    {
        // try to find start state in available states
        for (x = 0; x < m_AvailableStates.size() && !bFound; x++)
        {
            // compare current state
            if (m_AvailableStates[x] == pStartState)
            {
                // set found flag to true
                bFound = true;
                
            } // if (m_AvailableStates[x] == pStartState)
            
        } // for (x = 0; x < m_AvailableStates.size() && !bFound; x++)
        
        // check, if start state is included in available states
        if (!bFound)
        {
            // throw exception
            throw (::oETCS::DF::Error::CInternal("start state is not listed in available states"));
            
        } // if (!bFound)
        
        // set start flag to started
        m_bStarted = true;
        
        // set current application level
        m_CurrentApplicationLevel = ApplicationLevel;
        
        // set current state
        m_pCurrentState = pStartState;
        
        try
        {
            // start thread for EVC state execution
            m_pThread = new ::std::thread(&::oETCS::DF::CEVCStateMachine::StateThread, this);
            
        } // try
        catch (...)
        {
            // set start flag to stopped
            m_bStarted = false;

            // delete thread object, if exists
            delete m_pThread;

            // set current state to invalid
            m_pCurrentState = 0;
            
            // throw exception
            throw (::oETCS::DF::Error::CInternal("could not create EVC state thread object"));

        } // catch (...)
        
    } // if (m_pCurrentState == 0 || !m_pCurrentState->IsRunning())
  // Bouml preserved body end 0006FA02

} // void CEVCStateMachine::Start()  throw(::oETCS::DF::Error::CException) 




void CEVCStateMachine::Stop()  throw(::oETCS::DF::Error::CException)  
{
  // Bouml preserved body begin 0006FA82
    // check, if a current state is available
    if (m_pCurrentState == 0)
    {
        // throw exception
        throw (::oETCS::DF::Error::CInternal("no current state available"));

    } // if (m_pCurrentState == 0)

    // check, if current state is already running
    if (m_pCurrentState->IsRunning())
    {
#ifdef __DEBUG_OUTPUT__
        // DEBUG
        ::std::cerr << std::this_thread::get_id() << " " << "CEVCStateMachine::Stop() called " << ::std::endl;
#endif
        
        // explicitly set the state machine to stop
        m_bStarted = false;

        // start execution of current state
        m_pCurrentState->Stop();
        
        // check, if thread is joinable
        if (m_pThread->joinable())
        {
#ifdef __DEBUG_OUTPUT__
            // DEBUG
            ::std::cerr << std::this_thread::get_id() << " " << "CEVCStateMachine::Stop() -----> waiting for thread" << ::std::endl;
#endif
            
            // wait for thread to terminate
            m_pThread->join();
            
        } //if (m_pThread->joinable())

        // finally delete thread object
        delete m_pThread;
        
        // reset thread pointer
        m_pThread = 0;
        
#ifdef __DEBUG_OUTPUT__
        // DEBUG
        ::std::cerr << std::this_thread::get_id() << " " << "CEVCStateMachine::Stop() -----> all stopped" << ::std::endl;
#endif

    } // if (m_pCurrentState->IsRunning())
  // Bouml preserved body end 0006FA82

} // void CEVCStateMachine::Stop()  throw(::oETCS::DF::Error::CException) 




void CEVCStateMachine::Notify()  throw()  
{
  // Bouml preserved body begin 000C3882
    decltype (m_Observers.begin())          o;
    
    
    // proceed all attached observers
    for (o = m_Observers.begin(); o != m_Observers.end(); o++)
    {
        // call update on current observer
        (*o)->Update();
        
    } // for (o = m_Observers.begin(); o != m_Observers.end(); o++)
  // Bouml preserved body end 000C3882

} // void CEVCStateMachine::Notify()  throw() 




void CEVCStateMachine::StateThread()  throw()  
{
  // Bouml preserved body begin 0008E882
    // re-execute current state (after state or level switch). while this state machine is set to running
    while (m_bStarted)
    {
        
#ifdef __DEBUG_OUTPUT__
        // DEBUG output
        ::std::cerr << std::this_thread::get_id() << " " << "StateThread ----> about to start state in level " << m_CurrentApplicationLevel << ::std::endl;
#endif
        
        try
        {
            // start execution of current state
            m_pCurrentState->Start();

        } // try
        catch (const ::oETCS::DF::Error::CException& Exception)
        {
            // set start flag to stopped
            m_bStarted = false;

            // create and print error message to stderr
            ::std::cerr << "Error while executing current EVC state: " << Exception.what() << " in " << __FILE__ << " at line " << __LINE__ << " and no fault state available!" << ::std::endl;

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

#ifdef __DEBUG_OUTPUT__
        // DEBUG
        ::std::cerr << std::this_thread::get_id() << " " << "StateThread ----> execution of current state stopped" << ::std::endl;
#endif
        
    } // while (m_bStarted)
  // Bouml preserved body end 0008E882

} // void CEVCStateMachine::StateThread()  throw() 




CEVCTransition::CEVCTransition(oETCS::DF::CEVCCondition * const pCondition, oETCS::DF::CEVCStateMachine::CEVCState * const pStartState, oETCS::DF::CEVCStateMachine::CEVCState * const pTargetState, const unsigned int & iPriority)  throw()  
:m_pCondition(pCondition),
 m_pStartState(pStartState),
 m_pTargetState(pTargetState),
 m_iPriority(iPriority)
{
  // Bouml preserved body begin 00068682
    // add this instance to parent state machine
    m_pStartState->m_pParent->AddTransition(this);
  // Bouml preserved body end 00068682

} //  CEVCTransition::CEVCTransition()  throw() 




CEVCTransition::~CEVCTransition()  throw()  
{
  // Bouml preserved body begin 00068702
    // empty destructor
  // Bouml preserved body end 00068702

} // CEVCTransition::~CEVCTransition()  throw() 




const oETCS::DF::CEVCCondition* CEVCTransition::GetCondition()  const throw()  
{
  // Bouml preserved body begin 00073002
    // return pointer to related condition object
    return (m_pCondition);
  // Bouml preserved body end 00073002

} // oETCS::DF::CEVCCondition CEVCTransition::GetCondition()  const throw() 




oETCS::DF::CEVCStateMachine::CEVCState* const CEVCTransition::GetStartState()  const throw()  
{
  // Bouml preserved body begin 00073082
    // return pointer to related start state object
    return (m_pStartState);
  // Bouml preserved body end 00073082

} // oETCS::DF::CEVCStateMachine::CEVCState CEVCTransition::GetStartState()  const throw() 




oETCS::DF::CEVCStateMachine::CEVCState* const CEVCTransition::GetTargetState()  const throw()  
{
  // Bouml preserved body begin 00073102
    // return pointer to related target state object
    return (m_pTargetState);
  // Bouml preserved body end 00073102

} // oETCS::DF::CEVCStateMachine::CEVCState CEVCTransition::GetTargetState()  const throw() 




unsigned int CEVCTransition::GetPriority()  const throw()  
{
  // Bouml preserved body begin 00073182
    // return numerical priority
    return (m_iPriority);
  // Bouml preserved body end 00073182

} // unsigned int CEVCTransition::GetPriority()  const throw() 




CFunctionBlock::CFunctionBlock(oETCS::DF::CEVCStateMachine * const pStateMachine)  throw()  
:m_pStateMachine(pStateMachine)
{
  // Bouml preserved body begin 00064F02
    // check, if pointer to state machien is valid
    if (pStateMachine != nullptr)
    {
        // add this instance to state machine
        m_pStateMachine->AddFunctionBlock(this);
        
    } // if (pStateMachine != nullptr)
  // Bouml preserved body end 00064F02

} //  CFunctionBlock::CFunctionBlock()  throw() 




CFunctionBlock::~CFunctionBlock()  throw()  
{
  // Bouml preserved body begin 000DDC82
    // empty destructor
  // Bouml preserved body end 000DDC82

} // CFunctionBlock::~CFunctionBlock()  throw() 




oETCS::DF::CFunctionBlock& CFunctionBlock::operator=(oETCS::DF::CFunctionBlock& Source)  throw()  
{
  // Bouml preserved body begin 00068602
    // return this instance
    return (*this);
  // Bouml preserved body end 00068602

} // oETCS::DF::CFunctionBlock CFunctionBlock::operator=()  throw() 




CAbstractFlow::CAbstractFlow(oETCS::DF::CEVCStateMachine * const pStateMachine)  throw()  
:m_pStateMachine(pStateMachine)
{
  // Bouml preserved body begin 000C7002
  // Bouml preserved body end 000C7002

} //  CAbstractFlow::CAbstractFlow()  throw() 




CAbstractFlow::~CAbstractFlow()  throw()  
{
  // Bouml preserved body begin 000C5482
    // empty destructor (only needed for polymorphism)
  // Bouml preserved body end 000C5482

} //  CAbstractFlow::~CAbstractFlow()  throw() 




CBitFlow::CBitFlow(oETCS::DF::CStorage * const pInput, oETCS::DF::CEVCStateMachine * const pStateMachine)  throw()  
:CAbstractFlow(pStateMachine),
 m_pInput(pInput)
{
  // Bouml preserved body begin 000CBD82
    // empty constructor
  // Bouml preserved body end 000CBD82

} //  CBitFlow::CBitFlow()  throw() 




void CBitFlow::operator=(const oETCS::DF::CStorage& Value)  throw()  
{
  // Bouml preserved body begin 000CBE02
    // check, if this flow is part of the current data flow (active state nullptr means test case)
    if (m_pStateMachine->GetActiveState() == nullptr || m_pStateMachine->GetActiveState()->IsActiveFlow(this))
    {
        // switch last input type
        switch (Value.GetLastInputType())
        {
            case ::oETCS::DF::BOOL:
                // copy value to boolean input of connected storage object
                m_pInput->m_bBoolInput = Value.m_bBoolInput();

                break;


            case :: oETCS::DF::DOUBLE:
                // copy value to double input of connected storage object
                m_pInput->m_dDoubleInput = Value.m_dDoubleInput();

                break;


            case :: oETCS::DF::DOUBLE_ARRAY:
                // copy value to double array input of connected storage object
                m_pInput->m_DoubleArrayInput = Value.m_DoubleArrayInput();

                break;


            case :: oETCS::DF::INT:
                // copy value to integer input of connected storage object
                m_pInput->m_iIntInput = Value.m_iIntInput();

                break;


            case :: oETCS::DF::STRING:
                // copy value to string input of connected storage object
                m_pInput->m_StringInput = Value.m_StringInput();

                break;

        } // switch (Value.GetLastInputType())

    } // if (m_pStateMachine->GetActiveState() == nullptr || m_pStateMachine->GetActiveState()->IsActiveFlow(this))
  // Bouml preserved body end 000CBE02

} // void CBitFlow::operator=()  throw() 




oETCS::DF::CStorage* CBitFlow::operator->()  throw()  
{
  // Bouml preserved body begin 000DF602
    // return the pointer to the input instance of this flow
    return (m_pInput);
  // Bouml preserved body end 000DF602

} // oETCS::DF::CStorage* CBitFlow::operator->()  throw() 




CLevelCondition::CLevelCondition(oETCS::DF::CEVCStateMachine * const pStateMachine, const std::string & ApplicationLevel)  throw()  
:CFunctionBlock(pStateMachine),
 m_bLevelSwitch(false),
 m_TargetApplicationLevel(ApplicationLevel)
{
  // Bouml preserved body begin 00066B82
    // empty constructor
  // Bouml preserved body end 00066B82

} //  CLevelCondition::CLevelCondition()  throw() 




CLevelCondition::~CLevelCondition()  throw()  
{
  // Bouml preserved body begin 00066C02
    // empty destructor
  // Bouml preserved body end 00066C02

} // CLevelCondition::~CLevelCondition()  throw() 




void CLevelCondition::Calculate()  throw(::oETCS::DF::Error::CException)  
{
  // Bouml preserved body begin 00066B02
    // check, if application level switch was activated
    if (m_bLevelSwitch())
    {
        // set the new application level in parent EVC state machine
         //m_pStateMachine->SetApplicationLevel(m_TargetApplicationLevel);
        m_pStateMachine->m_CurrentApplicationLevel = m_TargetApplicationLevel;
        
#ifdef __DEBUG_OUTPUT__
        // DEBUG
        ::std::cerr << std::this_thread::get_id() << " " << "CLevelCondition::Calculate() -----> set new application level: " << m_pStateMachine->m_CurrentApplicationLevel << ::std::endl;
#endif
        
        // activate level/state switch in current state
        m_pStateMachine->GetActiveState()->m_bStateLevelSwitch = true;
        
    } // if (m_bLevelSwitch())
  // Bouml preserved body end 00066B02

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




CEVCCondition::CEVCCondition(oETCS::DF::CEVCStateMachine * const pStateMachine)  throw()  
:CFunctionBlock(pStateMachine),
 m_bGuard(false)
{
  // Bouml preserved body begin 0005F802
    // empty constructor
  // Bouml preserved body end 0005F802

} //  CEVCCondition::CEVCCondition()  throw() 




CEVCCondition::~CEVCCondition()  throw()  
{
  // Bouml preserved body begin 0005F882
    // empty destructor
  // Bouml preserved body end 0005F882

} // CEVCCondition::~CEVCCondition()  throw() 




void CEVCCondition::Calculate()  throw(::oETCS::DF::Error::CException)  
{
  // Bouml preserved body begin 00065102
    unsigned int            x;
    const unsigned int      NUMBER_TRANSITIONS(m_pStateMachine->GetTransitions().size());
    bool                    bFound(false);
    
    // check, if guard was activated
    if (m_bGuard())
    {
        // try find corresponding transition object in EVC state machine
        for (x = 0; x < NUMBER_TRANSITIONS && !bFound; x++)
        {
            // check if current transition is connected with current condition and current state
            if (m_pStateMachine->GetTransitions()[x]->GetCondition() == this && m_pStateMachine->GetTransitions()[x]->GetStartState() == m_pStateMachine->GetActiveState())
            {
                // add pointer to transition to stack
                m_pStateMachine->GetActiveState()->m_TransitionStack.push_back(m_pStateMachine->GetTransitions()[x]);
                
                // set found flag
                bFound = true;
                
            } // if ((*m_pStateMachine->GetTransitions())[x].GetCondition() == this &&  (*m_pStateMachine->GetTransitions())[x].GetStartState() == m_pStateMachine->GetActiveState())
            
        } // for (x = 0; x < NUMBER_TRANSITIONS && !bFound; x++)
        
        // finally reset guard
        m_bGuard = false;
        
        // call method  to reset modified flag
        m_bGuard.IsModified();
        
        // check if a matching transition was found
        if (!bFound)
        {
            // throw exception
            throw (::oETCS::DF::Error::CInternal("no matching EVC transition found for EVC condition"));
            
        } // if (!bFound)
                
    } // if (m_bGuard())
  // Bouml preserved body end 00065102

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




CDMISubject::CDMISubject(const ::std::vector< oETCS::DF::CDMIInput * >& Inputs, const ::std::vector< oETCS::DF::CDMIOutput * >& Outputs)  throw()  
:m_Inputs(Inputs),
 m_Outputs(Outputs)
{
  // Bouml preserved body begin 0006DF82
   // empty constructor
  // Bouml preserved body end 0006DF82

} //  CDMISubject::CDMISubject()  throw() 




CDMISubject::~CDMISubject()  throw()  
{
  // Bouml preserved body begin 0006E002
    // empty descructor
  // Bouml preserved body end 0006E002

} // CDMISubject::~CDMISubject()  throw() 




CDMIObserver::CDMIObserver(oETCS::DF::CEVCStateMachine * const pStateMachine)  throw()  
:m_pStateMachine(pStateMachine)
{
  // Bouml preserved body begin 000C3982
  // Bouml preserved body end 000C3982

} //  CDMIObserver::CDMIObserver()  throw() 




::std::ostream& operator<<(::std::ostream & OutStream, const ::std::vector< double >& Vector)  throw()  
{
  // Bouml preserved body begin 000E7702
    decltype (Vector.begin())       x;
    
    
    
    
    // output starting of vector
    OutStream << "[";
    
    // output vector element-wise
    for (x = Vector.begin(); x != Vector.end(); x++)
    {
        // output current element
        OutStream << *x << "; ";
        
    } // for (x = Vector.begin(); x != Vector.end(); x++)
    
    // output end of vector
    OutStream << "]";
    
    
    // return reference to out stream
    return (OutStream);
  // Bouml preserved body end 000E7702

} // ::std::ostream& operator<<()  throw() 






} // namespace oETCS::DF

} // namespace oETCS