EVCStateMachine.h

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
 */

#ifndef __OETCS_DF_EVCSTATEMACHINE_H__
#define __OETCS_DF_EVCSTATEMACHINE_H__


#include <chrono>
#include <iostream>
#include <algorithm>

#include <string>
#include <vector>
#include "Error/ExceptionTypes.h"
#include <map>
#include <condition_variable>
#include <thread>
#include "Configuration.h"
#include <mutex>
#include <ostream>


namespace oETCS { namespace UT { class CEVCStateMachine; }  }
namespace oETCS { namespace UT { class CFunctionBlock; }  }
namespace oETCS { namespace DF { class CFunctionBlock; }  }
namespace oETCS { namespace DF { class CAbstractFlow; }  }
namespace oETCS { namespace DF { class CEVCCondition; }  }
namespace oETCS { namespace DF { class CEVCStateMachine; }  }
namespace oETCS { namespace DF { class CDMIObserver; }  }
namespace oETCS { namespace DF { class CDMISubject; }  }
namespace oETCS { namespace DF { class CEVCTransition; }  }
namespace oETCS { namespace DF { class CLevelCondition; }  }


namespace oETCS { namespace DF { class CTransition; }  } 
namespace oETCS { namespace DF { class CLanguage; }  } 
namespace oETCS { namespace DF { class CStorage; }  } 
namespace oETCS { namespace DF { class CDMIInput; }  } 
namespace oETCS { namespace DF { class CDMIOutput; }  } 


namespace oETCS {

namespace DF {


/*!
 *  \brief EVC state machine class
 */
class CEVCStateMachine 
{
  public:
    /*!
     *  \brief EVC state class executed by the EVC state machine
     * 
     *  Is a nested class to gain direct access to its parent class.
     */
    class CEVCState 
    {
      public:
        /*!
         *  \brief data flow class for executing data flows and embedded control flows
         *
         *  Is a nested class to gain direct access to its parent class.
         */
        class CDataFlow 
        {
          public:
            /*!
             *  \brief general constructor
             *
             *  Parameterises the data flow with all constant members.
             *  The data flow object takes over the posession of the passed DMI object.
             *
             *  \param[in] pState pointer to the parent EVC state object
             *  \param[in] ApplicationLevel literal name of the application level in which this state object is executed
             *  \param[in] FunctionBlocks vector with pointers to all function block objects
             *  \param[in] Flows vector with pointers to all concrete CFlow/function block connection objects
             *  \param[in] pDMI pointer to the DMI object of the data flow
             *  \param[in] pFaultState optional pointer to the target state in case of a fault
             */
            explicit CDataFlow(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, CEVCState * const pFaultState = 0) throw();
            
            

            /*!
             *  \brief destructor
             */
            virtual ~CDataFlow() throw();
            
            

            /*!
             *  \brief gets all function block objects
             *
             *  \return vector with pointers all function block objects
             */
            ::std::vector< oETCS::DF::CFunctionBlock* > GetFunctionBlocks() const throw();
            
            

            /*!
             *  \brief returns true, if a CFunctionBlock objects is active in a data flow
             *
             *  \param[in] pFunctionBlock pointer to a function block object to be testetd
             *  \return active state flag
             */
            bool IsActiveFunctionBlock(const oETCS::DF::CFunctionBlock * const pFunctionBlock) const throw();
            
            

            /*!
             *  \brief returns true, if a CFlow object is active in a data flow
             *
             *  \param[in] pFlow pointer to a concerete flow object
             *  \return active flow flag
             */
            bool IsActiveFlow(const oETCS::DF::CAbstractFlow * const pFlow) const throw();
            
            

            /*!
             *  \brief executes all includes CFunctionBlock order (by their order) for one sample point
             */
            void Execute() throw(::oETCS::DF::Error::CException);
            
            

            /*!
             *  \brief pointer to DMI widget of data flow
             */
            oETCS::DF::CDMISubject* const  m_pDMI;
            
            


          private:
            /*!
             *  \brief vector of pointers to all function blocks used in this data flow in their execution order
             */
            const ::std::vector< oETCS::DF::CFunctionBlock* > m_FunctionBlocks;
            
            

            /*!
             *  \brief vector with pointer to all flows/connections used in a data flow
             */
            ::std::vector< oETCS::DF::CAbstractFlow* > m_Flows;
            
            

            /*!
             *  \brief pointer to the parent EVC state object
             */
            CEVCState* const m_pParent;
            
            

            /*!
             *  \brief optinal pointer to a EVC state object to which is switched in case of a fault
             */
            CEVCState* m_pFaultState;
            
            


        }; // class CDataFlow
        
        
        

        /*!
         *  \brief general constructor
         *
         *  Parameterises the EVC state with all constant members.
         *  The EVC state object takes over the posession of all variables/memory
         *  passed by pointer.
         *
         *  \param[in] pParent pointer to the parent EVC state machine object
         */
        CEVCState(CEVCStateMachine * const pParent) throw();
        
        

        /*!
         *  \brief destructor
         */
        virtual ~CEVCState() throw();
        
        

        /*!
         *  \brief starts the permanent execution of the related data flow
         *
         *  If the number of independent CDataFLow objects for the current application level is
         *  greater than 1, this method will start for each additional group a additinal thread,
         *  while this method always is blocking.
         *  If a CEVCState is executed under the same parent CEVCStateMachine object, this will be
         *  stopped before by its CEVCState::Stop() method.
         *
         */
        void Start() throw(::oETCS::DF::Error::CException);
        
        

        /*!
         *  \brief stops the execution the data flow by the underlying CFunctionBlock objects
         *
         *  In the case of more than 1 group of independent CDatatFlow objects
         *  this method terminates all related threads by wating for the current
         *  execution sample to finish.
         */
        void Stop() throw();
        
        

        /*!
         *  \brief returns the running flag
         *
         *  \return true, if is executing
         */
        bool IsRunning() const throw();
        
        

        /*!
         *  \brief returns true, if a CFunctionBlock objects is active in an EVC state
         *
         *  \param[in] pFunctionBlock pointer to a function block object to be testetd
         *  \return active state flag
         */
        bool IsActiveFunctionBlock(oETCS::DF::CFunctionBlock * const pFunctionBlock) const throw();
        
        

        /*!
         *  \brief returns true, if a CFlowobjects is active in an EVC state
         *
         *  \param[in] pFlow pointer to the concrete CFlow object to be testetd
         *  \return active state flag
         */
        bool IsActiveFlow(oETCS::DF::CAbstractFlow * const pFlow) const throw();
        
        

        /*!
         *  \brief gets all transisiton objects in this state
         *
         *  \return vector with pointers to transition objects
         */
        ::std::vector< oETCS::DF::CTransition* > GetTransitions() const throw();
        
        

        /*!
         *  \brief gets the current data flow
         *
         *  \return vector with pointers to all independent data flow objects
         */
        ::std::vector< CDataFlow* > GetCurrentDataFlow() const throw();
        
        

        /*!
         *  \brief register a new data flow object
         *
         *  \param[in] ApplicationLevel literal name of the related application level
         *  \param[in] pDataFlow pointer to the data flow object to be registered
         */
        void AddDataFlow(const std::string& ApplicationLevel, CDataFlow * const pDataFlow) throw();
        
        

        /*!
         *  \brief register a new transition object
         *
         *  \param[in] pTransition pointer to the transition object to be registered
         */
        void AddTransition(oETCS::DF::CTransition * const pTransition) throw();
        
        


      private:
        /*!
         *  \brief thread method/function for executing one data flow
         *
         *  \param[in] iIndex index corresponding to the vector referenced by m_pCurrentDataFlow
         */
        void DataFlowThread(const unsigned int & iIndex) throw();
        
        

        /*!
         *  \brief flag for a state and/or level switch within the EVC state machine
         */
        bool m_bStateLevelSwitch;
        
        

        /*!
         *  \brief number of currently locked threads.
         *
         *  Used in combination of m_Barrier to syncronise all data flow threads.
         */
        unsigned int m_iLockedThreads;
        
        


      public:
        /*!
         *  \brief pointer to the parent EVC state machine
         */
        CEVCStateMachine* const m_pParent;
        
        


      private:
        /*!
         *  \brief map of vectors of data flows in a certain EVC state indexed by the related application level
         *
         *  Each vector holds a set of CDataFlow objects for a certain application level, 
         *  which are independent from each other and therefore can be executed in parallel.
         */
        ::std::map< std::string, ::std::vector< CDataFlow* > > m_DataFlows;
        
        

        /*!
         *  \brief vector with pointers to all state transition within the current data flow
         */
        ::std::vector< oETCS::DF::CTransition* > m_Transitions;
        
        

        /*!
         *  \brief vector of pointers to the currently executed data flows
         */
        ::std::vector< CDataFlow* > m_CurrentDataFlow;
        
        

        /*!
         *  \brief condition variable as barrier for data flow syncronisation
         */
        ::std::condition_variable m_Barrier;
        
        

        /*!
         *  \brief vector of thread objects for data flow execution
         */
        ::std::vector< ::std::thread* > m_Threads;
        
        

        /*!
         *  \brief vector of exception thrown by data flow exections within threads
         */
        ::std::vector< ::oETCS::DF::Error::CException > m_DataFlowExceptions;
        
        

        /*!
         *  \brief vector with pointers to EVC transition objects, which were activated
         */
        ::std::vector< const oETCS::DF::CEVCTransition* > m_TransitionStack;
        
        

  friend class oETCS::DF::CEVCCondition;
  friend class oETCS::DF::CLevelCondition;

    }; // class CEVCState
    
    
    

    /*!
     *  \brief general constructor
     */
    CEVCStateMachine() throw();
    
    

    /*!
     *  \brief destructor
     */
    virtual ~CEVCStateMachine() throw();
    
    

    /*!
     *  \brief registers a function block object with thids state machine
     *
     *  \param[in] pFunctionBlock pointer to function block object to be registered
     *
     */
    void AddFunctionBlock(oETCS::DF::CFunctionBlock * const pFunctionBlock) throw();
    
    

    /*!
     *  \brief registers an EVC state object with thids state machine
     *
     *  \param[in] pState pointer to EVC state object to be registered
     *
     */
    void AddState(CEVCState * const pState) throw();
    
    

    /*!
     *  \brief registers an EVC transition object with thids state machine
     *
     *  \param[in] pTransition pointer to EVC transition object to be registered
     *
     */
    void AddTransition(oETCS::DF::CEVCTransition * const pTransition) throw();
    
    

    /*!
     *  \brief registers a language object with this state machine
     *
     *  \param[in] pLanguage pointer to the language object to be registered
     *
     */
    void AddLanguage(oETCS::DF::CLanguage * const pLanguage) throw();
    
    

    /*!
     *  \brief registers a flow object with this state machine
     *
     *  \param[in] pFlow pointer to the flow object to be registered
     *
     */
    void AddFlow(oETCS::DF::CAbstractFlow * const pFlow) throw();
    
    

    /*!
     *  \brief attaches a new DMI observer
     *
     *  \param[in] pDMIObserver pointer to the observer
     */
    void AttachObserver(oETCS::DF::CDMIObserver * const pDMIObserver) throw();
    
    

    /*!
     *  \brief detaches a new DMI observer
     *
     *  \param[in] pDMIObserver pointer to the observer
     */
    void DetachObserver(oETCS::DF::CDMIObserver * const pDMIObserver) throw();
    
    

    /*!
     *  \brief gets the pointer to the active EVC state
     *
     *  \return pointer to active EVC state object
     */
    CEVCState* const GetActiveState() const throw();
    
    

    /*!
     *  \brief gets a vector with pointers to all EVC transitions
     *
     *  \return vector with pointers to all EVC transition objects
     */
    ::std::vector< oETCS::DF::CEVCTransition* > GetTransitions() const throw();
    
    

    /*!
     *  \brief gets a vector with pointers to all EVC states
     *
     *  \return vector with pointers to all EVC state objects
     */
    ::std::vector< CEVCState* > GetStates() const throw();
    
    

    /*!
     *  \brief gets a pointer to the current DMI subject
     *
     *  \return pointer to the DMI subject
     */
    oETCS::DF::CDMISubject* GetCurrentDMI() throw();
    
    

    /*!
     *  \brief starts the execution of the EVC state machine
     *
     *  Starts the the EVC state machine in a non-blocking manner.
     *  
     *  \param[in] pStartState pointer to EVC state object to start with (must be local vector)
     *  \param[in] ApplicationLevel literal name of the start application level (must be available in start state)
     */
    void Start(CEVCState * const pStartState, const std::string & ApplicationLevel) throw(::oETCS::DF::Error::CException);
    
    

    /*!
     *  \brief stops the execution of the EVC state machine
     */
    void Stop() throw(::oETCS::DF::Error::CException);
    
    

    /*!
     *  \brief notifies the state machine about a changed DMI subject
     *
     *  Updates all registerd observers.
     *
     *  \remark Should only be called by CDMIInput and CDMIOutput objects.
     */
    void Notify() throw();
    
    


  private:
    /*!
     *  \brief thread method/function for executing the current EVC state object
     */
    void StateThread() throw();
    
    

    /*!
     *  \brief flag for started EVC state machine
     */
    bool m_bStarted;
    
    

    /*!
     *  \brief vector with pointers all available EVC state objects
     */
    ::std::vector< CEVCState* > m_AvailableStates;
    
    

    /*!
     *  \brief vector with pointers to all transitions between EVC states
     */
    ::std::vector< oETCS::DF::CEVCTransition* > m_Transitions;
    
    

    /*!
     *  \brief vector of all CFunctionBlock objects used in the EVC state machine 
     */
    ::std::vector< oETCS::DF::CFunctionBlock* > m_FunctionBlocks;
    
    

    /*!
     *  \brief literal name of the current active application level
     */
    ::std::string m_CurrentApplicationLevel;
    
    

    /*!
     *  \brief pointer to the active state
     */
    CEVCState* m_pCurrentState;
    
    

    /*!
     *  \brief pointer to thread object for EVC state object execution
     */
    ::std::thread* m_pThread;
    
    

    /*!
     *  \brief vector with pointers to all available language objects
     */
    ::std::vector< oETCS::DF::CLanguage* > m_Language;
    
    

    /*!
     *  \brief vector of pointers to registered observers
     */
    ::std::vector< oETCS::DF::CDMIObserver* > m_Observers;
    
    

    /*!
     *  \brief vector with all CFlow objects available in EVC state machine
     */
    ::std::vector< oETCS::DF::CAbstractFlow* > m_Flows;
    
    

  friend class oETCS::DF::CLevelCondition;

// only include the following, if unit test framework is available
#ifdef __HAS_UNIT_TEST__

  friend class ::oETCS::UT::CEVCStateMachine;

#endif // #ifdef __HAS_UNIT_TEST__

}; // class CEVCStateMachine



/*!
 *  \brief transition class for EVC states
 */
class CEVCTransition 
{
  public:
    /*!
     *  \brief general constructor
     *
     *  Parameterises the EVC state transition with all constant members.
     *
     *  \param[in] pConditon pointer to the related condition object
     *  \param[in] pStartState pointer to the start EVC state object of the transtion
     *  \param[in] pTargetState pointer to the target EVC state object of the transtion
     *  \param[in] iPriority numerical priority of the transition
     */
    explicit CEVCTransition(oETCS::DF::CEVCCondition * const pCondition, oETCS::DF::CEVCStateMachine::CEVCState * const pStartState, oETCS::DF::CEVCStateMachine::CEVCState * const pTargetState, const unsigned int & iPriority = 0) throw();
    
    

    /*!
     *  \brief destructor
     */
    virtual ~CEVCTransition() throw();
    
    

    /*!
     *  \brief gets the pointer to the related EVC condition
     *
     *  \return pointer to the related EVC condition object
     */
    const oETCS::DF::CEVCCondition* GetCondition() const throw();
    
    

    /*!
     *  \brief gets the pointer to the related EVC start state
     *
     *  \return pointer to the related EVC start state object
     */
    oETCS::DF::CEVCStateMachine::CEVCState* const GetStartState() const throw();
    
    

    /*!
     *  \brief gets the pointer to the related EVC target state
     *
     *  \return pointer to the related EVC target state object
     */
    oETCS::DF::CEVCStateMachine::CEVCState* const GetTargetState() const throw();
    
    

    /*!
     *  \brief gets the nurmerial priority
     *
     *  \returns the numerical priority
     */
    unsigned int GetPriority() const throw();
    
    


  private:
    /*!
     *  \brief pointer to the related condition object
     */
    oETCS::DF::CEVCCondition* const m_pCondition;
    
    

    /*!
     *  \brief pointer to the EVC start state object of the transition
     */
    oETCS::DF::CEVCStateMachine::CEVCState* const m_pStartState;
    
    

    /*!
     *  \brief pointer to the target state of the transition
     */
    oETCS::DF::CEVCStateMachine::CEVCState* const m_pTargetState;
    
    

    /*!
     *  \brief numerical priority of a transition
     */
    const int m_iPriority;
    
    


}; // class CEVCTransition



/*!
 *  \brief base class for all function block elements in a data flow
 */
class CFunctionBlock 
{
  public:
    /*!
     *  \brief container template class for input value storages of the type VALUE_T
     *
     *  \tparam INPUT_TYPE_T:      type of container value
     */
    template<class INPUT_TYPE_T>
    class CInput 
    {
      public:
        /*!
         *  \brief default constructor
         *
         *  Initialises m_Value by the default constructor of VALUE_T
         */
        explicit CInput() throw();
        
        

        /*!
         *  \brief general constructor
         *
         *  \param[in] Value initial value of the container of template type
         */
        explicit CInput(const INPUT_TYPE_T& Value) throw();
        
        

        /*!
         *  \brief assigns a new value to the container
         *
         *  \param[in] NewValue the new value
         */
        INPUT_TYPE_T& operator=(const INPUT_TYPE_T& NewValue) throw();
        
        

        /*!
         *  \brief gets the modified flag
         *
         *  Returns true if the value mas modified by any operator/method.
         *  This methods reset the modified flag.
         *
         *  \return modified flag
         */
        bool IsModified() throw();
        
        

        /*!
         *  \brief functor operator
         *
         *  Returns the value.
         *
         *  \return the value
         */
        INPUT_TYPE_T operator()() throw();
        
        

        /*!
         *  \brief functor operator
         *
         *  Returns value.
         *
         *  \remark This is the const version of the operator.
         *
         *  \return value
         */
        const INPUT_TYPE_T operator()() const throw();
        
        


      private:
        /*!
         *  \brief real storage of the value type
         */
        INPUT_TYPE_T m_Value;
        
        

        /*!
         *  \brief modified flag for the container value
         */
        bool m_bModified;
        
        

        /*!
         *  \brief mutex for I/O accesses to the value of the input
         */
        mutable ::std::mutex m_ValueMutex;
        
        

  friend class oETCS::DF::CStorage;

    }; // CInput
    
    
    

    /*!
     *  \brief general constructor
     *
     *  \param[in] pStateMachine pointer to the contenting state machine
     */
    CFunctionBlock(oETCS::DF::CEVCStateMachine * const pStateMachine) throw();
    
    

    /*!
     *  \brief deleted copy constructor to avoid copying
     */
    CFunctionBlock(const CFunctionBlock& Source) = delete;
    
    

    /*!
     *  \brief destructor
     */
    virtual ~CFunctionBlock() throw();
    
    

    /*!
     *  \brief virtual method for computing all outputs and setting the all referenced outputs
     *
     *  \remark must be implemented by any inheriting class
     */
    virtual void Calculate() throw(::oETCS::DF::Error::CException) = 0;
    
    


  private:
    /*!
     *  \brief private assignment operator to avoid assignment
     */
    CFunctionBlock& operator=(CFunctionBlock& Source) throw();
    
    


  public:
    /*!
     *  \brief pointer to the all contenting EVC state machine
     */
    oETCS::DF::CEVCStateMachine* const m_pStateMachine;
    
    


}; // class CFunctionBlock

template<class INPUT_TYPE_T>
CFunctionBlock::CInput<INPUT_TYPE_T>::CInput()  throw()  
:m_bModified(false)
{
  // Bouml preserved body begin 0008E682
        // empty constructor
  // Bouml preserved body end 0008E682

} //  CFunctionBlock::CInput<INPUT_TYPE_T>::CInput()  throw() 




template<class INPUT_TYPE_T>
CFunctionBlock::CInput<INPUT_TYPE_T>::CInput(const INPUT_TYPE_T& Value)  throw()  
:m_Value(Value),
 m_bModified(false)
{
  // Bouml preserved body begin 00082A82
        // empty constructor
  // Bouml preserved body end 00082A82

} //  CFunctionBlock::CInput<INPUT_TYPE_T>::CInput()  throw() 




template<class INPUT_TYPE_T>
INPUT_TYPE_T& CFunctionBlock::CInput<INPUT_TYPE_T>::operator=(const INPUT_TYPE_T& NewValue)  throw()  
{
  // Bouml preserved body begin 00082B82
        // lock mutex
        m_ValueMutex.lock();
        
        // set modified flag
        m_bModified = true;
        
        // assign new value
        m_Value = NewValue;

        // unlock mutex
        m_ValueMutex.unlock();

        // return reference to local value
        return (m_Value);
  // Bouml preserved body end 00082B82

} // INPUT_TYPE_T CFunctionBlock::CInput<INPUT_TYPE_T>::operator=()  throw() 




template<class INPUT_TYPE_T>
bool CFunctionBlock::CInput<INPUT_TYPE_T>::IsModified()  throw()  
{
  // Bouml preserved body begin 00082C02
        bool            bModified(m_bModified);
        
        
        
        // lock mutex
        m_ValueMutex.lock();
        
        // reset modified flag
        m_bModified = false;
        
        // unlock mutex
        m_ValueMutex.unlock();
        
                
        // return flag
        return (bModified);
  // Bouml preserved body end 00082C02

} // bool CFunctionBlock::CInput<INPUT_TYPE_T>::IsModified()  throw() 




template<class INPUT_TYPE_T>
INPUT_TYPE_T CFunctionBlock::CInput<INPUT_TYPE_T>::operator()()  throw()  
{
  // Bouml preserved body begin 00082C82
        INPUT_TYPE_T        Value;
        
        
        
        // lock mutex
        m_ValueMutex.lock();
        
        // get value from member
        Value = m_Value;
        
        // unlock mutex
        m_ValueMutex.unlock();
        
        
        // return reference to local value
        return (Value);
  // Bouml preserved body end 00082C82

} // INPUT_TYPE_T CFunctionBlock::CInput<INPUT_TYPE_T>::operator()()  throw() 




template<class INPUT_TYPE_T>
const INPUT_TYPE_T CFunctionBlock::CInput<INPUT_TYPE_T>::operator()()  const throw()  
{
  // Bouml preserved body begin 000AD602
        INPUT_TYPE_T        Value;



        // lock mutex
        m_ValueMutex.lock();

        // get value from member
        Value = m_Value;

        // unlock mutex
        m_ValueMutex.unlock();


        // return reference to local value
        return (Value);
  // Bouml preserved body end 000AD602

} // INPUT_TYPE_T CFunctionBlock::CInput<INPUT_TYPE_T>::operator()()  const throw() 






/*!
 *  \brief flow base class
 *
 *  Used for addressing all template flows by one base pointer type.
 */
class CAbstractFlow 
{
  public:
    /*!
     *  \brief general constructor
     *
     *  \param[in] pStateMachine pointer to the parent state machine
     */
    CAbstractFlow(oETCS::DF::CEVCStateMachine * const pStateMachine) throw();
    
    

    /*!
     *  \brief destructor
     */
    virtual ~CAbstractFlow() throw();
    
    


  protected:
    /*!
     *  \brief pointer to the all contenting EVC state machine
     */
    oETCS::DF::CEVCStateMachine* const m_pStateMachine;
    
    


}; // class CAbstractFlow



/*!
 *  \brief flow template class
 *
 *  Builds the connection of one input with one output for a certain data flow.
 *
 *  \tparam INPUT_TYPE_T is the type of the input
 *  \tparam FLOW_TYPE_T is the type of the data flow
 */
template<class INPUT_TYPE_T, class FLOW_TYPE_T = ::oETCS::DF::CFunctionBlock::CInput< INPUT_TYPE_T > >
class CFlow : public oETCS::DF::CAbstractFlow 
{
  public:
    /*!
     *  \brief general constructor
     *
     *  \param[in] pInput pointer to the related input object
     *  \param[in] pStateMachine pointer to the parent state machine
     */
     CFlow(FLOW_TYPE_T * const pInput, oETCS::DF::CEVCStateMachine * const pStateMachine) throw();
    
    

    /*!
     *  \brief assignment operator
     *
     *  \param[in] Value concrete value of this data flow
     */
    void operator=(const INPUT_TYPE_T& Value) throw();
    
    


  private:
    /*!
     *  \brief pointer to the related input of an function block object
     */
    FLOW_TYPE_T* const m_pInput;
    
    


}; // class CFlow : public oETCS::DF::CAbstractFlow

template<class INPUT_TYPE_T, class FLOW_TYPE_T>
CFlow<INPUT_TYPE_T, FLOW_TYPE_T>::CFlow(FLOW_TYPE_T * const pInput, oETCS::DF::CEVCStateMachine * const pStateMachine)  throw()  
:CAbstractFlow(pStateMachine),
 m_pInput(pInput)
{
  // Bouml preserved body begin 000C5602
        // empty constructor
  // Bouml preserved body end 000C5602

} //  CFlow<INPUT_TYPE_T, FLOW_TYPE_T>::CFlow()  throw() 




template<class INPUT_TYPE_T, class FLOW_TYPE_T>
void CFlow<INPUT_TYPE_T, FLOW_TYPE_T>::operator=(const INPUT_TYPE_T& Value)  throw()  
{
  // Bouml preserved body begin 000C5582
        // 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))
        {
            // set value in input value
            *m_pInput = Value;
            
            
#ifdef __DEBUG_OUTPUT__
            // DEBUG
            ::std::cerr << std::this_thread::get_id() << " " << "CFlow::operator=() ----> value " << Value << " set in flow " << this << ::std::endl;
#endif
      
            
        } // if (m_pStateMachine->GetActiveState() == nullptr || m_pStateMachine->GetActiveState()->IsActiveFlow(this))
        
  // Bouml preserved body end 000C5582

} // void CFlow<INPUT_TYPE_T, FLOW_TYPE_T>::operator=()  throw() 






/*!
 *  \brief flow class for the meta model bit type
 *
 *  Builds the connection/flow between to CStrorage objects
 *
 */
class CBitFlow : public oETCS::DF::CAbstractFlow 
{
  public:
    /*!
     *  \brief general constructor
     *
     *  \param[in] pInput pointer to the related CStorage object
     *  \param[in] pStateMachine pointer to the parent state machine
     */
    explicit CBitFlow(oETCS::DF::CStorage * const pInput, oETCS::DF::CEVCStateMachine * const pStateMachine) throw();
    
    

    /*!
     *  \brief assignment operator
     *
     *  \param[in] Value concrete value of this bit data flow 
     */
    void operator=(const oETCS::DF::CStorage& Value) throw();
    
    

    /*!
     *  \brief pointer access operator for connected input storage
     *
     *  \return pointer to the underlying CStorage instance
     */
    oETCS::DF::CStorage* operator->() throw();
    
    


  private:
    /*!
     *  \brief pointer to CStorage instance as bit input
     */
    oETCS::DF::CStorage* const  m_pInput;
    
    


}; // class CBitFlow : public oETCS::DF::CAbstractFlow



/*!
 *  \brief typedef for easier access in this namespace
 */
typedef oETCS::DF::CEVCStateMachine::CEVCState CEVCState;


/*!
 *  \brief typedef for easier access in this namespace
 */
typedef oETCS::DF::CEVCStateMachine::CEVCState::CDataFlow CDataFlow;


/*!
 *  \brief typedef for a boolean flow type
 */
typedef oETCS::DF::CFlow< bool > BOOL_FLOW_T;


/*!
 *  \brief typedef for a double array flow type
 */
typedef oETCS::DF::CFlow< ::std::vector< double > > DOUBLE_ARRAY_FLOW_T;


/*!
 *  \brief typedef for a double flow type
 */
typedef oETCS::DF::CFlow< double > DOUBLE_FLOW_T;


/*!
 *  \brief typedef for a integer flow type
 */
typedef oETCS::DF::CFlow< signed int > INT_FLOW_T;


/*!
 *  \brief typedef for a string flow type
 */
typedef oETCS::DF::CFlow< ::std::string > STRING_FLOW_T;


/*!
 *  \brief typedef for a boolean container type
 */
typedef oETCS::DF::CFunctionBlock::CInput< bool > BOOL_CONTAINER_T;


/*!
 *  \brief typedef for the bool meta model input data type
 */
typedef oETCS::DF::BOOL_CONTAINER_T BOOL_INPUT_T;


/*!
 *  \brief typedef for the bool meta model output data type
 */
typedef oETCS::DF::BOOL_FLOW_T* BOOL_OUTPUT_T;


/*!
 *  \brief typedef for a double array container type
 */
typedef oETCS::DF::CFunctionBlock::CInput< ::std::vector< double > > DOUBLE_ARRAY_CONTAINER_T;


/*!
 *  \brief typedef for the double array meta model input data type
 */
typedef oETCS::DF::DOUBLE_ARRAY_CONTAINER_T DOUBLE_ARRAY_INPUT_T;


/*!
 *  \brief typedef for the double array meta model output data type
 */
typedef oETCS::DF::DOUBLE_ARRAY_FLOW_T* DOUBLE_ARRAY_OUTPUT_T;


/*!
 *  \brief typedef for a double container type
 */
typedef oETCS::DF::CFunctionBlock::CInput< double > DOUBLE_CONTAINER_T;


/*!
 *  \brief typedef for the double meta model input data type
 */
typedef oETCS::DF::DOUBLE_CONTAINER_T DOUBLE_INPUT_T;


/*!
 *  \brief typedef for the double meta model output data type
 */
typedef oETCS::DF::DOUBLE_FLOW_T* DOUBLE_OUTPUT_T;


/*!
 *  \brief typedef for a integer container type
 */
typedef oETCS::DF::CFunctionBlock::CInput< int > INT_CONTAINER_T;


/*!
 *  \brief typedef for the int meta model input data type
 */
typedef oETCS::DF::INT_CONTAINER_T INT_INPUT_T;


/*!
 *  \brief typedef for the int meta model output data type
 */
typedef oETCS::DF::INT_FLOW_T* INT_OUTPUT_T;


/*!
 *  \brief typedef for a boolean container type
 */
typedef oETCS::DF::CFunctionBlock::CInput< ::std::string > STRING_CONTAINER_T;


/*!
 *  \brief typedef for the string meta model input data type
 */
typedef oETCS::DF::STRING_CONTAINER_T STRING_INPUT_T;


/*!
 *  \brief typedef for the string meta model output data type
 */
typedef oETCS::DF::STRING_FLOW_T* STRING_OUTPUT_T;


/*!
 *  \brief typedef for the bit meta model output data type
 */
typedef oETCS::DF::VARIABLE_VALUE_VECTOR_T* BIT_OUTPUT_T;


/*!
 *  \brief condition class for changing the current application level
 */
class CLevelCondition : public oETCS::DF::CFunctionBlock 
{
  public:
    /*!
     *  \brief general constructor
     *
     *  \param[in] pStateMachine pointer to the parent EVC state machine object
     *  \param[in] ApplicationLevel literal name of the application level for which the condition object is used
     */
    explicit CLevelCondition(oETCS::DF::CEVCStateMachine * const pStateMachine, const std::string & ApplicationLevel) throw();
    
    

    /*!
     *  \brief destructor
     */
    virtual ~CLevelCondition() throw();
    
    

    /*!
     *  \brief virtual method for computing all outputs and setting the all referenced outputs
     *
     *  \remark must be implemented by any inheriting class
     */
    virtual void Calculate() throw(::oETCS::DF::Error::CException);
    
    

    /*!
     *  \brief input storage for activating a application level switch by a condition object
     */
    oETCS::DF::BOOL_INPUT_T m_bLevelSwitch;
    
    

    /*!
     *  \brief literal of the target application level of the condition
     */
    const ::std::string m_TargetApplicationLevel;
    
    


}; // class CLevelCondition : public oETCS::DF::CFunctionBlock



/*!
 *  \brief condition/guard class for starting/transitioning (to) a certain EVC state
 */
class CEVCCondition : public oETCS::DF::CFunctionBlock 
{
  public:
    /*!
     *  \brief general constructor
     *
     *  \param[in] pStateMachine pointer to the parent EVC state machine object
     */
    explicit CEVCCondition(oETCS::DF::CEVCStateMachine * const pStateMachine) throw();
    
    

    /*!
     *  \brief destructor
     */
    virtual ~CEVCCondition() throw();
    
    

    /*!
     *  \brief virtual method for computing all outputs and setting the all referenced outputs
     *
     *  \remark must be implemented by any inheriting class
     */
    virtual void Calculate() throw(::oETCS::DF::Error::CException);
    
    

    /*!
     *  \brief input storage of the guard of the condition
     */
    oETCS::DF::BOOL_INPUT_T m_bGuard;
    
    


}; // class CEVCCondition : public oETCS::DF::CFunctionBlock



/*!
 *  \brief subject of the DMI observer pattern
 *
 *  Combines used DMI inputs and outputs for a certain data flow.
 */
struct CDMISubject 
{
    /*!
     *  \brief general constructor
     *
     *  Parameterises the DMI widget with all constant members.
     *  The Telegram object takes over the posession of the input and output elements.
     *
     *  \param[in] Input vector with pointers to all DMI input objects used
     *  \param[in] Outputs vector with pointers to all DMI output objects used
     */
    explicit CDMISubject(const ::std::vector< oETCS::DF::CDMIInput * >& Inputs, const ::std::vector< oETCS::DF::CDMIOutput * >& Outputs) throw();
    
    

    /*!
     *  \brief destructor
     */
    virtual ~CDMISubject() throw();
    
    

    /*!
     *  \brief vector of pointers to input elements
     */
    ::std::vector< oETCS::DF::CDMIInput* > m_Inputs;
    
    

    /*!
     *  \brief vector of pointers to outputs
     */
    ::std::vector< oETCS::DF::CDMIOutput* > m_Outputs;
    
    


}; // struct CDMISubject



/*!
 *  \brief observer interface for the DMI
 *
 *  Must be reimplemented by any concrete observer.
 */
class CDMIObserver 
{
  public:
    /*!
     *  \brief general constructor
     *
     *  Attaches the concrete obsever to the EVC state machine.
     *
     *  \param[in] pStateMachine pointer to the related state machine
     */
    CDMIObserver(oETCS::DF::CEVCStateMachine * const pStateMachine) throw();
    
    

    /*!
     *  \brief updates the observer representation
     */
    virtual void Update() throw() = 0;
    
    

    /*!
     *  \brief notifies an observer about it was detached by the EVC state machine
     */
    virtual void Detached() throw() = 0;
    
    


  protected:
    /*!
     *  \brief pointer to the related state machine 
     */
    oETCS::DF::CEVCStateMachine* const  m_pStateMachine;
    
    


}; // class CDMIObserver



/*!
 *  \brief helper method for streaming a double vector
 *
 *  \param[in] OutStream stream object used for output
 *  \param[in] Vector output vector of double
 *
 *  \return reference to the outstream
 */
::std::ostream& operator<<(::std::ostream & OutStream, const ::std::vector< double >& Vector) throw();




} // namespace oETCS::DF

} // namespace oETCS

#endif // __ OETCS_DF_EVCSTATEMACHINE_H__