FunctionBlocks.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 all local function block classes
 */

#ifndef __OETCS_DF_FUNCTIONBLOCKS_H__
#define __OETCS_DF_FUNCTIONBLOCKS_H__




#include "Error/ExceptionTypes.h"
#include "EVCStateMachine.h"
#include <vector>
#include "Configuration.h"
#include <string>




namespace oETCS { namespace DF { class CEVCStateMachine; }  } 
namespace oETCS { namespace DF { class CBaliseDeviceIn; }  } 
namespace oETCS { namespace DF { class CBaliseDeviceOut; }  } 


namespace oETCS {

namespace DF {


/*!
 *  \brief function block class for computing a boolean and
 */
class CAnd : public oETCS::DF::CFunctionBlock 
{
  public:
    /*!
     *  \brief general constructor
     *
     *  \param[in] pStateMachine pointer to the parent EVC state machine object
     */
    explicit CAnd(oETCS::DF::CEVCStateMachine * const pStateMachine) throw();
    
    

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

    /*!
     *  \brief method for computing all outputs
     */
    virtual void Calculate() throw(::oETCS::DF::Error::CException);
    
    

    /*!
     *  \brief storage for the first input
     */
    oETCS::DF::BOOL_INPUT_T m_bInput1;
    
    

    /*!
     *  \brief storage for the second input
     */
    oETCS::DF::BOOL_INPUT_T m_bInput2;
    
    

    /*!
     *  \brief pointers to storage of boolean result of calculation
     */
    ::std::vector< oETCS::DF::BOOL_OUTPUT_T > m_Result;
    
    


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



/*!
 *  \brief function block class for computing a boolean or
 */
class COr : public oETCS::DF::CFunctionBlock 
{
  public:
    /*!
     *  \brief general/default constructor
     *
     *  \param[in] pStateMachine pointer to the parent EVC state machine object
     */
    explicit COr(oETCS::DF::CEVCStateMachine * const pStateMachine) throw();
    
    

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

    /*!
     *  \brief method for computing all outputs
     */
    virtual void Calculate() throw(::oETCS::DF::Error::CException);
    
    

    /*!
     *  \brief storage for the first input
     */
    oETCS::DF::BOOL_INPUT_T m_bInput1;
    
    

    /*!
     *  \brief storage for the second input
     */
    oETCS::DF::BOOL_INPUT_T m_bInput2;
    
    

    /*!
     *  \brief pointers to storage of boolean result of calculation
     */
    ::std::vector< oETCS::DF::BOOL_OUTPUT_T > m_Result;
    
    


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



/*!
 *  \brief function block class for computing a double division
 */
class CDivision : public oETCS::DF::CFunctionBlock 
{
  public:
    /*!
     *  \brief default constructor
     *
     *  \param[in] pStateMachine pointer to the parent EVC state machine object
     */
    explicit CDivision(oETCS::DF::CEVCStateMachine * const pStateMachine) throw();
    
    

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

    /*!
     *  \brief method for computing all outputs
     */
    virtual void Calculate() throw(::oETCS::DF::Error::CException);
    
    

    /*!
     *  \brief storage of the dividend
     */
    oETCS::DF::DOUBLE_INPUT_T m_dDividend;
    
    

    /*!
     *  \brief storage of the divisor
     */
    oETCS::DF::DOUBLE_INPUT_T m_dDivisor;
    
    

    /*!
     *  \brief pointers to the storage of the quotient
     */
    ::std::vector< oETCS::DF::DOUBLE_OUTPUT_T > m_Quotient;
    
    


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



/*!
 *  \brief function block class for computing a double equal
 */
class CDoubleEqual : public oETCS::DF::CFunctionBlock 
{
  public:
    /*!
     *  \brief default/general constructor
     *
     *  \param[in] pStateMachine pointer to the parent EVC state machine object
     */
    explicit CDoubleEqual(oETCS::DF::CEVCStateMachine * const pStateMachine) throw();
    
    

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

    /*!
     *  \brief method for computing all outputs
     */
    virtual void Calculate() throw(::oETCS::DF::Error::CException);
    
    

    /*!
     *  \brief storage of the first input
     */
    oETCS::DF::DOUBLE_INPUT_T m_dInput1;
    
    

    /*!
     *  \brief storage of the second input
     */
    oETCS::DF::DOUBLE_INPUT_T m_dInput2;
    
    

    /*!
     *  \brief pointers to storage of the result
     */
    ::std::vector< oETCS::DF::BOOL_OUTPUT_T > m_Equal;
    
    


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



/*!
 *  \brief function block class for computing a double multiplication
 */
class CMultiplication : public oETCS::DF::CFunctionBlock 
{
  public:
    /*!
     *  \brief default constructor
     *
     *  \param[in] pStateMachine pointer to the parent EVC state machine object
     */
    CMultiplication(oETCS::DF::CEVCStateMachine * const pStateMachine) throw();
    
    

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

    /*!
     *  \brief method for computing all outputs
     */
    virtual void Calculate() throw(::oETCS::DF::Error::CException);
    
    

    /*!
     *  \brief storage of the first multiplicator
     */
    oETCS::DF::DOUBLE_INPUT_T m_dMultiplicator1;
    
    

    /*!
     *  \brief storage of the second multiplicator
     */
    oETCS::DF::DOUBLE_INPUT_T m_dMultiplicator2;
    
    

    /*!
     *  \brief storage of the third multiplicator
     */
    oETCS::DF::DOUBLE_INPUT_T m_dMultiplicator3;
    
    

    /*!
     *  \brief pointer to storage of the product
     */
    ::std::vector< oETCS::DF::DOUBLE_OUTPUT_T > m_Product;
    
    


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



/*!
 *  \brief function block class for computing a boolean negation
 */
class CNot : public oETCS::DF::CFunctionBlock 
{
  public:
    /*!
     *  \brief general constructor
     *
     *  \param[in] pStateMachine pointer to the parent EVC state machine object
     */
    explicit CNot(oETCS::DF::CEVCStateMachine * const pStateMachine) throw();
    
    

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

    /*!
     *  \brief method for computing all outputs
     */
    virtual void Calculate() throw(::oETCS::DF::Error::CException);
    
    

    /*!
     *  \brief storage for theinput
     */
    oETCS::DF::BOOL_INPUT_T m_bInput;
    
    

    /*!
     *  \brief pointers to storage of boolean result of calculation
     */
    ::std::vector< oETCS::DF::BOOL_OUTPUT_T > m_Result;
    
    


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



/*!
 *  \brief function block class for computing a double substraction
 */
class CSubstraction : public oETCS::DF::CFunctionBlock 
{
  public:
    /*!
     *  \brief general constructor
     *
     *  \param[in] pStateMachine pointer to the parent EVC state machine object
     */
    explicit CSubstraction(oETCS::DF::CEVCStateMachine * const pStateMachine) throw();
    
    

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

    /*!
     *  \brief method for computing all outputs
     */
    virtual void Calculate() throw(::oETCS::DF::Error::CException);
    
    

    /*!
     *  \brief storage of the minuend
     */
    oETCS::DF::DOUBLE_INPUT_T m_dMinuend;
    
    

    /*!
     *  \brief storage of the subtrahend
     */
    oETCS::DF::DOUBLE_INPUT_T m_dSubtrahend;
    
    

    /*!
     *  \brief vector with pointers to the storages of the difference
     */
    ::std::vector< oETCS::DF::DOUBLE_OUTPUT_T > m_Difference;
    
    


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



/*!
 *  \brief function block class for computing a double sum
 */
class CSum : public oETCS::DF::CFunctionBlock 
{
  public:
    /*!
     *  \brief general constructor
     *
     *  \param[in] pStateMachine pointer to the parent EVC state machine object
     */
    CSum(oETCS::DF::CEVCStateMachine * const pStateMachine) throw();
    
    

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

    /*!
     *  \brief method for computing all outputs
     */
    virtual void Calculate() throw(::oETCS::DF::Error::CException);
    
    

    /*!
     *  \brief storage of the first addend
     */
    oETCS::DF::DOUBLE_INPUT_T m_dAddend1;
    
    

    /*!
     *  \brief storage of the second addend
     */
    oETCS::DF::DOUBLE_INPUT_T m_dAddend2;
    
    

    /*!
     *  \brief storage of the third addend
     */
    oETCS::DF::DOUBLE_INPUT_T m_dAddend3;
    
    

    /*!
     *  \brief pointers to storage of the sum
     */
    ::std::vector< oETCS::DF::DOUBLE_OUTPUT_T > m_Sum;
    
    


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



/*!
 *  \brief function block class for computing a boolean exclusive or
 */
class CXor : public oETCS::DF::CFunctionBlock 
{
  public:
    /*!
     *  \brief general constructor
     *
     *  \param[in] pStateMachine pointer to the parent EVC state machine object
     */
    explicit CXor(oETCS::DF::CEVCStateMachine * const pStateMachine) throw();
    
    

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

    /*!
     *  \brief method for computing all outputs
     */
    virtual void Calculate() throw(::oETCS::DF::Error::CException);
    
    

    /*!
     *  \brief storage for the first input
     */
    oETCS::DF::BOOL_INPUT_T m_bInput1;
    
    

    /*!
     *  \brief storage for the second input
     */
    oETCS::DF::BOOL_INPUT_T m_bInput2;
    
    

    /*!
     *  \brief pointers to storage of boolean result of calculation
     */
    ::std::vector< oETCS::DF::BOOL_OUTPUT_T > m_Result;
    
    


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



/*!
 *  \brief function block class for accessing a element of a double array
 */
class CDoubleArrayAccessor : public oETCS::DF::CFunctionBlock 
{
  public:
    /*!
     *  \brief default/genral constructor
     *
     *  \param[in] pStateMachine pointer to the parent EVC state machine object
     */
    explicit CDoubleArrayAccessor(oETCS::DF::CEVCStateMachine * const pStateMachine) throw();
    
    

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

    /*!
     *  \brief method for computing all outputs
     */
    virtual void Calculate() throw(::oETCS::DF::Error::CException);
    
    

    /*!
     *  \brief storage of the double array
     */
    oETCS::DF::DOUBLE_ARRAY_INPUT_T m_Array;
    
    

    /*!
     *  \brief storage of the index
     */
    oETCS::DF::INT_INPUT_T m_iIndex;
    
    

    /*!
     *  \brief storage of the indexed value
     */
    ::std::vector< oETCS::DF::DOUBLE_OUTPUT_T > m_Value;
    
    


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



/*!
 *  \brief function block class for computing a double equal or greater
 */
class CDoubleEqualOrGreater : public oETCS::DF::CFunctionBlock 
{
  public:
    /*!
     *  \brief general constructor
     *
     *  \param[in] pStateMachine pointer to the parent EVC state machine object
     */
    explicit CDoubleEqualOrGreater(oETCS::DF::CEVCStateMachine * const pStateMachine) throw();
    
    

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

    /*!
     *  \brief method for computing all outputs
     */
    virtual void Calculate() throw(::oETCS::DF::Error::CException);
    
    

    /*!
     *  \brief storage of the first input
     */
    oETCS::DF::DOUBLE_INPUT_T m_dInput1;
    
    

    /*!
     *  \brief storage of the second input
     */
    oETCS::DF::DOUBLE_INPUT_T m_dInput2;
    
    

    /*!
     *  \brief pointers to storage of the result
     */
    ::std::vector< oETCS::DF::BOOL_OUTPUT_T > m_EqualOrGreater;
    
    


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



/*!
 *  \brief function block class for computing a double greater
 */
class CDoubleGreater : public oETCS::DF::CFunctionBlock 
{
  public:
    /*!
     *  \brief default/general constructor
     *
     *  \param[in] pStateMachine pointer to the parent EVC state machine object
     */
    explicit CDoubleGreater(oETCS::DF::CEVCStateMachine * const pStateMachine) throw();
    
    

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

    /*!
     *  \brief method for computing all outputs
     */
    virtual void Calculate() throw(::oETCS::DF::Error::CException);
    
    

    /*!
     *  \brief storage of the first input
     */
    oETCS::DF::DOUBLE_INPUT_T m_dInput1;
    
    

    /*!
     *  \brief storage of the second input
     */
    oETCS::DF::DOUBLE_INPUT_T m_dInput2;
    
    

    /*!
     *  \brief pointers to storage of the result
     */
    ::std::vector< oETCS::DF::BOOL_OUTPUT_T > m_Greater;
    
    


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



/*!
 *  \brief function block class for computing an integer greater
 */
class CIntGreater : public oETCS::DF::CFunctionBlock 
{
  public:
    /*!
     *  \brief general constructor
     *
     *  \param[in] pStateMachine pointer to the parent EVC state machine object
     */
    explicit CIntGreater(oETCS::DF::CEVCStateMachine * const pStateMachine) throw();
    
    

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

    /*!
     *  \brief method for computing all outputs
     */
    virtual void Calculate() throw(::oETCS::DF::Error::CException);
    
    

    /*!
     *  \brief storage of the first input
     */
    oETCS::DF::INT_INPUT_T m_iInput1;
    
    

    /*!
     *  \brief storage of the second input
     */
    oETCS::DF::INT_INPUT_T m_iInput2;
    
    

    /*!
     *  \brief pointers to storage of the result
     */
    ::std::vector< oETCS::DF::BOOL_OUTPUT_T > m_Greater;
    
    


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



/*!
 *  \brief function block class for computing a string equal
 */
class CStringEqual : public oETCS::DF::CFunctionBlock 
{
  public:
    /*!
     *  \brief general constructor
     *
     *  \param[in] pStateMachine pointer to the parent EVC state machine object
     */
    explicit CStringEqual(oETCS::DF::CEVCStateMachine * const pStateMachine) throw();
    
    

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

    /*!
     *  \brief method for computing all outputs
     */
    virtual void Calculate() throw(::oETCS::DF::Error::CException);
    
    

    /*!
     *  \brief storage of the first input
     */
    oETCS::DF::STRING_INPUT_T m_Input1;
    
    

    /*!
     *  \brief storage of the second input
     */
    oETCS::DF::STRING_INPUT_T m_Input2;
    
    

    /*!
     *  \brief pointers to storage of the result
     */
    ::std::vector< oETCS::DF::BOOL_OUTPUT_T > m_Equal;
    
    


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



/*!
 *  \brief function block class for providing a boolean gate
 */
class CBoolGate : public oETCS::DF::CFunctionBlock 
{
  public:
    /*!
     *  \brief default/general constructor
     *
     *  \param[in] pStateMachine pointer to the parent EVC state machine object
     */
    explicit CBoolGate(oETCS::DF::CEVCStateMachine * const pStateMachine) throw();
    
    

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

    /*!
     *  \brief method for computing all outputs
     */
    virtual void Calculate() throw(::oETCS::DF::Error::CException);
    
    

    /*!
     *  \brief storage for the input
     */
    oETCS::DF::BOOL_INPUT_T m_bGateInput;
    
    

    /*!
     *  \brief storage for the open flag
     */
    oETCS::DF::BOOL_INPUT_T m_bOpen;
    
    

    /*!
     *  \brief pointers to boolean results of calculation
     */
    ::std::vector< oETCS::DF::BOOL_OUTPUT_T > m_GateOutput;
    
    


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



/*!
 *  \brief function block class for providing a boolean switch
 */
class CBoolSwitch : public oETCS::DF::CFunctionBlock 
{
  public:
    /*!
     *  \brief general constructor
     *
     *  \param[in] pStateMachine pointer to the parent EVC state machine object
     */
    explicit CBoolSwitch(oETCS::DF::CEVCStateMachine * const pStateMachine) throw();
    
    

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

    /*!
     *  \brief method for computing all outputs
     */
    virtual void Calculate() throw(::oETCS::DF::Error::CException);
    
    

    /*!
     *  \brief storage for the first input
     */
    oETCS::DF::BOOL_INPUT_T m_bInput1;
    
    

    /*!
     *  \brief storage for the second input
     */
    oETCS::DF::BOOL_INPUT_T m_bInput2;
    
    

    /*!
     *  \brief storage for the usage flag for the first input
     */
    oETCS::DF::BOOL_INPUT_T m_bUseInput1;
    
    

    /*!
     *  \brief pointers to boolean results of calculation
     */
    ::std::vector< oETCS::DF::BOOL_OUTPUT_T > m_SwitchOutput;
    
    


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



/*!
 *  \brief function block class for providing a double gate
 */
class CDoubleGate : public oETCS::DF::CFunctionBlock 
{
  public:
    /*!
     *  \brief general constructor
     *
     *  \param[in] pStateMachine pointer to the parent EVC state machine object
     */
    explicit CDoubleGate(oETCS::DF::CEVCStateMachine * const pStateMachine) throw();
    
    

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

    /*!
     *  \brief method for computing all outputs
     */
    virtual void Calculate() throw(::oETCS::DF::Error::CException);
    
    

    /*!
     *  \brief storage for the input
     */
    oETCS::DF::DOUBLE_INPUT_T m_dGateInput;
    
    

    /*!
     *  \brief storage for the open flag
     */
    oETCS::DF::BOOL_INPUT_T m_bOpen;
    
    

    /*!
     *  \brief pointers to double results of calculation
     */
    ::std::vector< oETCS::DF::DOUBLE_OUTPUT_T > m_GateOutput;
    
    


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



/*!
 *  \brief function block class for providing a double switch
 */
class CDoubleSwitch : public oETCS::DF::CFunctionBlock 
{
  public:
    /*!
     *  \brief general constructor
     *
     *  \param[in] pStateMachine pointer to the parent EVC state machine object
     */
    explicit CDoubleSwitch(oETCS::DF::CEVCStateMachine * const pStateMachine) throw();
    
    

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

    /*!
     *  \brief method for computing all outputs
     */
    virtual void Calculate() throw(::oETCS::DF::Error::CException);
    
    

    /*!
     *  \brief storage for the first input
     */
    oETCS::DF::DOUBLE_INPUT_T m_dInput1;
    
    

    /*!
     *  \brief storage for the second input
     */
    oETCS::DF::DOUBLE_INPUT_T m_dInput2;
    
    

    /*!
     *  \brief storage for the usage flag for the first input
     */
    oETCS::DF::BOOL_INPUT_T m_bUseInput1;
    
    

    /*!
     *  \brief pointers to boolean results of calculation
     */
    ::std::vector< oETCS::DF::DOUBLE_OUTPUT_T > m_SwitchOutput;
    
    


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



/*!
 *  \brief function block class for providing a string gate
 */
class CStringGate : public oETCS::DF::CFunctionBlock 
{
  public:
    /*!
     *  \brief default constructor
     *
     *  \param[in] pStateMachine pointer to the parent EVC state machine object
     */
    explicit CStringGate(oETCS::DF::CEVCStateMachine * const pStateMachine) throw();
    
    

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

    /*!
     *  \brief method for computing all outputs
     */
    virtual void Calculate() throw(::oETCS::DF::Error::CException);
    
    

    /*!
     *  \brief storage for the input
     */
    oETCS::DF::STRING_INPUT_T m_GateInput;
    
    

    /*!
     *  \brief storage for the open flag
     */
    oETCS::DF::BOOL_INPUT_T m_bOpen;
    
    

    /*!
     *  \brief pointers to string results of calculation
     */
    ::std::vector< oETCS::DF::STRING_OUTPUT_T > m_GateOutput;
    
    


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



/*!
 *  \brief function block class for controling a brake curve to a certain target speed
 */
class CBrakingToTargetSpeed : public oETCS::DF::CFunctionBlock 
{
  public:
    /*!
     *  \brief default/general constructor
     *
     *  \param[in] pStateMachine pointer to the parent EVC state machine object
     */
    CBrakingToTargetSpeed(oETCS::DF::CEVCStateMachine * const pStateMachine) throw();
    
    

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

    /*!
     *  \brief method for computing all outputs
     */
    virtual void Calculate() throw(::oETCS::DF::Error::CException);
    
    

    /*!
     *  \brief storage of the gradient distances
     */
    oETCS::DF::DOUBLE_ARRAY_INPUT_T m_GradientDistances;
    
    

    /*!
     *  \brief storage of gradient values
     */
    oETCS::DF::DOUBLE_ARRAY_INPUT_T m_GradientValues;
    
    

    /*!
     *  \brief storage of the current absolute distance
     */
    oETCS::DF::DOUBLE_INPUT_T m_dCurrentAbsoluteDistance;
    
    

    /*!
     *  \brief storage of the current absolute distance
     */
    oETCS::DF::DOUBLE_INPUT_T m_dCurrentVelocity;
    
    

    /*!
     *  \brief storage of the distance of the permitted velocity
     */
    oETCS::DF::DOUBLE_INPUT_T m_dDistanceOfPermittedVelocity;
    
    

    /*!
     *  \brief storage of the permitted velocity
     */
    oETCS::DF::DOUBLE_INPUT_T m_dPermittedVelocity;
    
    

    /*!
     *  \brief storage of the adhesion factor
     */
    oETCS::DF::DOUBLE_INPUT_T m_dAdhesionFactor;
    
    

    /*!
     *  \brief pointers to storage of the speed warning
     */
    ::std::vector< oETCS::DF::BOOL_OUTPUT_T > m_SpeedWarning;
    
    

    /*!
     *  \brief pointers to storage of the flag for applied service brake
     */
    ::std::vector< oETCS::DF::BOOL_OUTPUT_T > m_ServiceBrakeApplied;
    
    

    /*!
     *  \brief pointers storage of the flag for applied emegerncy brake
     */
    ::std::vector< oETCS::DF::BOOL_OUTPUT_T > m_EmergencyBrakeApplied;
    
    

    /*!
     *  \brief pointers to storage of emergency brake value
     */
    ::std::vector< oETCS::DF::BOOL_OUTPUT_T > m_EmergencyBrakeValue;
    
    

    /*!
     *  \brief pointers to storage of service brake value
     */
    ::std::vector< oETCS::DF::DOUBLE_OUTPUT_T > m_ServiceBrakeValue;
    
    


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



/*!
 *  \brief function block class for controling the speed in respect to a ceeling speed value
 */
class CCeelingSpeedControl : public oETCS::DF::CFunctionBlock 
{
  public:
    /*!
     *  \brief default/general constructor
     *
     *  \param[in] pStateMachine pointer to the parent EVC state machine object
     */
    CCeelingSpeedControl(oETCS::DF::CEVCStateMachine * const pStateMachine) throw();
    
    

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

    /*!
     *  \brief method for computing all outputs
     */
    virtual void Calculate() throw(::oETCS::DF::Error::CException);
    
    

    /*!
     *  \brief storage of the gradient distances
     */
    oETCS::DF::DOUBLE_ARRAY_INPUT_T m_GradientDistances;
    
    

    /*!
     *  \brief storage of gradient values
     */
    oETCS::DF::DOUBLE_ARRAY_INPUT_T m_GradientValues;
    
    

    /*!
     *  \brief storage of the current absolute distance
     */
    oETCS::DF::DOUBLE_INPUT_T m_dCurrentAbsoluteDistance;
    
    

    /*!
     *  \brief storage of the current absolute distance
     */
    oETCS::DF::DOUBLE_INPUT_T m_dCurrentVelocity;
    
    

    /*!
     *  \brief storage of the permitted velocity
     */
    oETCS::DF::DOUBLE_INPUT_T m_dPermittedVelocity;
    
    

    /*!
     *  \brief storage of the adhesion factor
     */
    oETCS::DF::DOUBLE_INPUT_T m_dAdhesionFactor;
    
    

    /*!
     *  \brief pointers to storage of the speed warning
     */
    ::std::vector< oETCS::DF::BOOL_OUTPUT_T > m_SpeedWarning;
    
    

    /*!
     *  \brief pointers to storage of the flag for applied service brake
     */
    ::std::vector< oETCS::DF::BOOL_OUTPUT_T > m_ServiceBrakeApplied;
    
    

    /*!
     *  \brief pointers storage of the flag for applied emegerncy brake
     */
    ::std::vector< oETCS::DF::BOOL_OUTPUT_T > m_EmergencyBrakeApplied;
    
    

    /*!
     *  \brief pointers to storage of emergency brake value
     */
    ::std::vector< oETCS::DF::BOOL_OUTPUT_T > m_EmergencyBrakeValue;
    
    

    /*!
     *  \brief pointers to storage of service brake value
     */
    ::std::vector< oETCS::DF::DOUBLE_OUTPUT_T > m_ServiceBrakeValue;
    
    


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



/*!
 *  \brief function block class for a bolean output on an entered data flow event
 */
class CEnteredTrigger : public oETCS::DF::CFunctionBlock 
{
  public:
    /*!
     *  \brief general constructor
     *
     *  \param[in] pStateMachine pointer to the parent EVC state machine object
     */
    explicit CEnteredTrigger(oETCS::DF::CEVCStateMachine * const pStateMachine) throw();
    
    

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

    /*!
     *  \brief method for computing all outputs
     */
    virtual void Calculate() throw(::oETCS::DF::Error::CException);
    
    

    /*!
     *  \brief class global flag for a newly entered data flow
     */
    static bool m_bEnteredState;
    
    

    /*!
     *  \brief pointers to boolean results of calculation
     */
    ::std::vector< oETCS::DF::BOOL_OUTPUT_T > m_Entered;
    
    


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



/*!
 *  \brief function block class for providing a string switch
 */
class CStringSwitch : public oETCS::DF::CFunctionBlock 
{
  public:
    /*!
     *  \brief general constructor
     *
     *  \param[in] pStateMachine pointer to the parent EVC state machine object
     */
    explicit CStringSwitch(oETCS::DF::CEVCStateMachine * const pStateMachine) throw();
    
    

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

    /*!
     *  \brief method for computing all outputs
     */
    virtual void Calculate() throw(::oETCS::DF::Error::CException);
    
    

    /*!
     *  \brief storage for the first input
     */
    oETCS::DF::STRING_INPUT_T m_Input1;
    
    

    /*!
     *  \brief storage for the second input
     */
    oETCS::DF::STRING_INPUT_T m_Input2;
    
    

    /*!
     *  \brief storage for the usage flag for the first input
     */
    oETCS::DF::BOOL_INPUT_T m_bUseInput1;
    
    

    /*!
     *  \brief pointers to string results of calculation
     */
    ::std::vector< oETCS::DF::STRING_OUTPUT_T > m_SwitchOutput;
    
    


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



/*!
 *  \brief function block class for computing an integer equal
 */
class CIntEqual : public oETCS::DF::CFunctionBlock 
{
  public:
    /*!
     *  \brief default/general constructor
     *
     *  \param[in] pStateMachine pointer to the parent EVC state machine object
     */
    explicit CIntEqual(oETCS::DF::CEVCStateMachine * const pStateMachine) throw();
    
    

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

    /*!
     *  \brief method for computing all outputs
     */
    virtual void Calculate() throw(::oETCS::DF::Error::CException);
    
    

    /*!
     *  \brief storage of the first input
     */
    oETCS::DF::INT_INPUT_T m_iInput1;
    
    

    /*!
     *  \brief storage of the second input
     */
    oETCS::DF::INT_INPUT_T m_iInput2;
    
    

    /*!
     *  \brief pointers to storage of the result
     */
    ::std::vector< oETCS::DF::BOOL_OUTPUT_T > m_Equal;
    
    


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



/*!
 *  \brief communication class for incomming messages in a data flow
 */
class CComBlockIn : public oETCS::DF::CFunctionBlock 
{
  public:
    /*!
     *  \brief general constructor
     *
     *  \param[in] pStateMachine   pointer to the parent EVC state machine object
     *  \param[in] InDevices       vector with pointers to all in devices (takes over posession)
     *  \param[in] PacketIDs       optinal vector with Packet IDs valid for activating boolean output for new IDs
     */
    explicit CComBlockIn(oETCS::DF::CEVCStateMachine * const pStateMachine, const ::std::vector< oETCS::DF::CBaliseDeviceIn * >& InDevices, const ::std::vector<  unsigned char > & PacketIDs = ::std::vector< unsigned char >()) throw();
    
    

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

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

    /*!
     *  \brief clears all telegrams from all connected in devices
     */
    void Clear() throw();
    
    

    /*!
     *  \brief pointers to storage of the flag for a received telegram
     */
    ::std::vector< oETCS::DF::BOOL_OUTPUT_T > m_Received;
    
    

    /*!
     *  \brief vector of Packet IDs, which are valid for new telegrams
     */
    const ::std::vector< unsigned char > m_PacketIDs;
    
    


  private:
    /*!
     *  \brief vector with pointers to all communication in devices in this com block
     */
    const ::std::vector< oETCS::DF::CBaliseDeviceIn* > m_InDevices;
    
    


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



/*!
 *  \brief communication class for outgoing messages in a data flow
 */
class CComBlockOut : public oETCS::DF::CFunctionBlock 
{
  public:
    /*!
     *  \brief general constructor
     *
     *  \param[in] pStateMachine pointer to the parent EVC state machine object
     *  \param[in] OutDevices vector with pointers to all out devices (takes over posession)
     */
    explicit CComBlockOut(oETCS::DF::CEVCStateMachine * const pStateMachine, const ::std::vector< oETCS::DF::CBaliseDeviceOut * >& OutDevices) throw();
    
    

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

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

    /*!
     *  \brief storage of the flag for sending a telegram
     */
    oETCS::DF::BOOL_INPUT_T m_bSendTelegram;
    
    


  private:
    /*!
     *  \brief vector with pointers to all communication out devices in this com block
     */
    const ::std::vector< oETCS::DF::CBaliseDeviceOut* > m_OutDevices;
    
    


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



/*!
 *  \brief class for inputs from the driver via the DMI
 */
class CDMIInput : public oETCS::DF::CFunctionBlock 
{
  public:
    /*!
     *  \brief general constructor
     *
     *  \param[in] pStateMachine pointer to the parent EVC state machine object
     *  \param[in] eType data type of the input
     *  \param[in] pParent optional pointer to parent widget
     *  \param[in] Label optional label string 
     *  \param[in] bInitialVisible optional flag for initial visibility
     */
    explicit CDMIInput(oETCS::DF::CEVCStateMachine * const pStateMachine, const oETCS::DF::DATA_T & eType, const ::std::string & Label = "", const bool & bInitialVisible = true) throw();
    
    

    virtual ~CDMIInput() throw();
    
    

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

    /*!
     *  \brief storage of an entered boolean message
     */
    oETCS::DF::BOOL_INPUT_T m_bBool;
    
    

    /*!
     *  \brief storage of an entered double message
     */
    oETCS::DF::DOUBLE_INPUT_T m_dDouble;
    
    

    /*!
     *  \brief storage of an entered integer message
     */
    oETCS::DF::INT_INPUT_T m_iInt;
    
    

    /*!
     *  \brief storage of a predefined string message
     */
    oETCS::DF::STRING_INPUT_T m_String;
    
    

    /*!
     *  \brief storage of the visible flag input
     */
    oETCS::DF::BOOL_INPUT_T m_bVisible;
    
    

    /*!
     *  \brief optional label 
     */
    const ::std::string m_Label;
    
    

    /*!
     *  \brief set of allowed boolean inputs by DMI
     */
    ::std::vector< bool > m_AllowedBoolInputs;
    
    

    /*!
     *  \brief set of allowed double inputs by DMI
     */
    ::std::vector< double > m_AllowedDoubleInputs;
    
    

    /*!
     *  \brief set of allowed integer inputs by DMI
     */
    ::std::vector< int > m_AllowedIntInputs;
    
    

    /*!
     *  \brief set of allowed string inputs by DMI
     */
    ::std::vector< ::std::string > m_AllowedStringInputs;
    
    

    /*!
     *  \brief pointers to boolean results of input
     */
    ::std::vector< oETCS::DF::BOOL_OUTPUT_T > m_BoolMessage;
    
    

    /*!
     *  \brief pointers to double results of input
     */
    ::std::vector< oETCS::DF::DOUBLE_OUTPUT_T > m_DoubleMessage;
    
    

    /*!
     *  \brief pointers to integer results of input
     */
    ::std::vector< oETCS::DF::INT_OUTPUT_T > m_IntMessage;
    
    

    /*!
     *  \brief pointers to string results of input
     */
    ::std::vector< oETCS::DF::STRING_OUTPUT_T > m_StringMessage;
    
    

    /*!
     *  \brief vevtor with pointers to boolean inputs for entered data
     */
    ::std::vector< oETCS::DF::BOOL_OUTPUT_T > m_EnteredData;
    
    

    /*!
     *  \brief data type of input
     */
    const oETCS::DF::DATA_T m_eType;
    
    


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



/*!
 *  \brief class for outputs to the driver via the DMI
 *
 */
class CDMIOutput : public oETCS::DF::CFunctionBlock 
{
  public:
    /*!
     *  \brief general constructor
     *
     *  \param[in] pStateMachine pointer to the parent EVC state machine object
     *  \param[in] eType data type of the DMI input object
     *  \param[in] Label optional label string 
     *  \param[in] bInitialVisible optional flag for initial visibility
     */
    explicit CDMIOutput(oETCS::DF::CEVCStateMachine * const pStateMachine, const oETCS::DF::DATA_T & eType, const ::std::string& Label = "", const bool & bInitialVisible = true) throw();
    
    

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

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

    /*!
     *  \brief storage of a boolean message
     */
    oETCS::DF::BOOL_INPUT_T m_bBoolMessage;
    
    

    /*!
     *  \brief storage of a double message
     */
    oETCS::DF::DOUBLE_INPUT_T m_dDoubleMessage;
    
    

    /*!
     *  \brief storage of a double array message
     */
    oETCS::DF::DOUBLE_ARRAY_INPUT_T m_DoubleArrayMessage;
    
    

    /*!
     *  \brief storage of an integer message
     */
    oETCS::DF::INT_INPUT_T m_iIntMessage;
    
    

    /*!
     *  \brief storage of a string message
     */
    oETCS::DF::STRING_INPUT_T m_StringMessage;
    
    

    /*!
     *  \brief storage of the visible flag input
     */
    oETCS::DF::BOOL_INPUT_T m_bVisible;
    
    

    /*!
     *  \brief optional label 
     */
    const ::std::string m_Label;
    
    

    /*!
     *  \brief data type of input
     */
    const oETCS::DF::DATA_T m_eType;
    
    


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





} // namespace oETCS::DF

} // namespace oETCS

#endif // __ OETCS_DF_FUNCTIONBLOCKS_H__