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

#include "FunctionBlocks.h"
#include "EVCStateMachine.h"
#include "PlatformSpecificClientsMOC.h"




namespace oETCS {

namespace DF {


CAnd::CAnd(oETCS::DF::CEVCStateMachine * const pStateMachine)  throw()  
:CFunctionBlock(pStateMachine),
 m_bInput1(false),
 m_bInput2(false)
{
  // Bouml preserved body begin 0004C582
    // empty constructor
  // Bouml preserved body end 0004C582

} //  CAnd::CAnd()  throw() 




CAnd::~CAnd()  throw()  
{
  // Bouml preserved body begin 0004C602
    // empty destructor
  // Bouml preserved body end 0004C602

} // CAnd::~CAnd()  throw() 




void CAnd::Calculate()  throw(::oETCS::DF::Error::CException)  
{
  // Bouml preserved body begin 0004E082
    const unsigned int      NUMBER_RESULTS(m_Result.size());
    unsigned int            x(0);
    bool                    bOutput(false);
    
    
    // compute calculation result
    bOutput = m_bInput1() && m_bInput2();
    
    // set result in all connected outputs
    for (x = 0; x < NUMBER_RESULTS; x++)
    {
        // set result in current output
        *m_Result[x] = bOutput;
        
    } // for (x = 0; x < NUMBER_RESULTS; x++)
  // Bouml preserved body end 0004E082

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




COr::COr(oETCS::DF::CEVCStateMachine * const pStateMachine)  throw()  
:CFunctionBlock(pStateMachine),
 m_bInput1(false),
 m_bInput2(false)
{
  // Bouml preserved body begin 00050402
    // empty constructor
  // Bouml preserved body end 00050402

} //  COr::COr()  throw() 




COr::~COr()  throw()  
{
  // Bouml preserved body begin 00050482
    // empty destructor
  // Bouml preserved body end 00050482

} // COr::~COr()  throw() 




void COr::Calculate()  throw(::oETCS::DF::Error::CException)  
{
  // Bouml preserved body begin 00050682
    const unsigned int      NUMBER_RESULTS(m_Result.size());
    unsigned int            x(0);
    bool                    bOutput(false);


    // compute calculation result
    bOutput = m_bInput1() || m_bInput2();

    // set result in all connected outputs
    for (x = 0; x < NUMBER_RESULTS; x++)
    {
        // set result in current output
        *m_Result[x] = bOutput;

    } // for (x = 0; x < NUMBER_RESULTS; x++)
  // Bouml preserved body end 00050682

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




CDivision::CDivision(oETCS::DF::CEVCStateMachine * const pStateMachine)  throw()  
:CFunctionBlock(pStateMachine),
 m_dDividend(0.0),
 m_dDivisor(1.0)
{
  // Bouml preserved body begin 00054802
    // empty constructor
  // Bouml preserved body end 00054802

} //  CDivision::CDivision()  throw() 




CDivision::~CDivision()  throw()  
{
  // Bouml preserved body begin 00054882
    // empty destructor
  // Bouml preserved body end 00054882

} // CDivision::~CDivision()  throw() 




void CDivision::Calculate()  throw(::oETCS::DF::Error::CException)  
{
  // Bouml preserved body begin 00054A82
    const unsigned int      NUMBER_RESULTS(m_Quotient.size());
    unsigned int            x(0);
    double                  dQuotient(0.0);

    
    // check, if divisor is not 0
    if (m_dDivisor() == 0.0)
    {
        // throw exception
        ::oETCS::DF::Error::CMath("division by zero not defined");
        
    } // if (m_dDivisor() == 0.0)
    

    // compute calculation result
    dQuotient = m_dDividend() / m_dDivisor();

    // set result in all connected outputs
    for (x = 0; x < NUMBER_RESULTS; x++)
    {
        // set result in current output
        *m_Quotient[x] = dQuotient;

    } // for (x = 0; x < NUMBER_RESULTS; x++)
  // Bouml preserved body end 00054A82

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




CDoubleEqual::CDoubleEqual(oETCS::DF::CEVCStateMachine * const pStateMachine)  throw()  
:CFunctionBlock(pStateMachine),
 m_dInput1(1.0),
 m_dInput2(1.0)
{
  // Bouml preserved body begin 00054F02
    // empty constructor
  // Bouml preserved body end 00054F02

} //  CDoubleEqual::CDoubleEqual()  throw() 




CDoubleEqual::~CDoubleEqual()  throw()  
{
  // Bouml preserved body begin 00054F82
    // empty destructor
  // Bouml preserved body end 00054F82

} // CDoubleEqual::~CDoubleEqual()  throw() 




void CDoubleEqual::Calculate()  throw(::oETCS::DF::Error::CException)  
{
  // Bouml preserved body begin 00055182
    const unsigned int      NUMBER_RESULTS(m_Equal.size());
    unsigned int            x(0);
    bool                    bEqual(false);


    // compute calculation result
    bEqual = (m_dInput1() == m_dInput2());

    // set result in all connected outputs
    for (x = 0; x < NUMBER_RESULTS; x++)
    {
        // set result in current output
        *m_Equal[x] = bEqual;

    } // for (x = 0; x < NUMBER_RESULTS; x++)
  // Bouml preserved body end 00055182

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




CMultiplication::CMultiplication(oETCS::DF::CEVCStateMachine * const pStateMachine)  throw()  
:CFunctionBlock(pStateMachine),
 m_dMultiplicator1(1.0),
 m_dMultiplicator2(1.0),
 m_dMultiplicator3(1.0)
{
  // Bouml preserved body begin 00054B02
    // empty constructor
  // Bouml preserved body end 00054B02

} //  CMultiplication::CMultiplication()  throw() 




CMultiplication::~CMultiplication()  throw()  
{
  // Bouml preserved body begin 00054B82
    // empty destructor
  // Bouml preserved body end 00054B82

} // CMultiplication::~CMultiplication()  throw() 




void CMultiplication::Calculate()  throw(::oETCS::DF::Error::CException)  
{
  // Bouml preserved body begin 00054D82
    const unsigned int      NUMBER_RESULTS(m_Product.size());
    unsigned int            x(0);
    double                  dProduct(0.0);


    // compute calculation result
    dProduct = m_dMultiplicator1() * m_dMultiplicator2() * m_dMultiplicator3();

    // set result in all connected outputs
    for (x = 0; x < NUMBER_RESULTS; x++)
    {
        // set result in current output
        *m_Product[x] = dProduct;

    } // for (x = 0; x < NUMBER_RESULTS; x++)
  // Bouml preserved body end 00054D82

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




CNot::CNot(oETCS::DF::CEVCStateMachine * const pStateMachine)  throw()  
:CFunctionBlock(pStateMachine),
 m_bInput(false)
{
  // Bouml preserved body begin 00052302
    // empty constructor    
  // Bouml preserved body end 00052302

} //  CNot::CNot()  throw() 




CNot::~CNot()  throw()  
{
  // Bouml preserved body begin 00052382
    // empty destructor
  // Bouml preserved body end 00052382

} // CNot::~CNot()  throw() 




void CNot::Calculate()  throw(::oETCS::DF::Error::CException)  
{
  // Bouml preserved body begin 00052582
    const unsigned int      NUMBER_RESULTS(m_Result.size());
    unsigned int            x(0);
    bool                    bOutput(false);


    // compute calculation result
    bOutput = !m_bInput();

    // set result in all connected outputs
    for (x = 0; x < NUMBER_RESULTS; x++)
    {
        // set result in current output
        *m_Result[x] = bOutput;

    } // for (x = 0; x < NUMBER_RESULTS; x++)
  // Bouml preserved body end 00052582

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




CSubstraction::CSubstraction(oETCS::DF::CEVCStateMachine * const pStateMachine)  throw()  
:CFunctionBlock(pStateMachine),
 m_dMinuend(0.0),
 m_dSubtrahend(0.0)
{
  // Bouml preserved body begin 00052B82
    // empty constructor
  // Bouml preserved body end 00052B82

} //  CSubstraction::CSubstraction()  throw() 




CSubstraction::~CSubstraction()  throw()  
{
  // Bouml preserved body begin 00052C02
    // empty destructor
  // Bouml preserved body end 00052C02

} // CSubstraction::~CSubstraction()  throw() 




void CSubstraction::Calculate()  throw(::oETCS::DF::Error::CException)  
{
  // Bouml preserved body begin 00052E82
    const unsigned int      NUMBER_RESULTS(m_Difference.size());
    unsigned int            x(0);
    double                  dDifference(0.0);


    // compute calculation result
    dDifference = m_dMinuend() - m_dSubtrahend();

    // set result in all connected outputs
    for (x = 0; x < NUMBER_RESULTS; x++)
    {
        // set result in current output
        *m_Difference[x] = dDifference;

    } // for (x = 0; x < NUMBER_RESULTS; x++)
  // Bouml preserved body end 00052E82

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




CSum::CSum(oETCS::DF::CEVCStateMachine * const pStateMachine)  throw()  
:CFunctionBlock(pStateMachine),
 m_dAddend1(0.0),
 m_dAddend2(0.0),
 m_dAddend3(0.0)
{
  // Bouml preserved body begin 00052602
    // empty constructor
  // Bouml preserved body end 00052602

} //  CSum::CSum()  throw() 




CSum::~CSum()  throw()  
{
  // Bouml preserved body begin 00052682
    // empty destructor
  // Bouml preserved body end 00052682

} // CSum::~CSum()  throw() 




void CSum::Calculate()  throw(::oETCS::DF::Error::CException)  
{
  // Bouml preserved body begin 00052882
    const unsigned int      NUMBER_RESULTS(m_Sum.size());
    unsigned int            x(0);
    double                  dSum(0.0);


    // compute calculation result
    dSum = m_dAddend1() + m_dAddend2() + m_dAddend3();

    // set result in all connected outputs
    for (x = 0; x < NUMBER_RESULTS; x++)
    {
        // set result in current output
        *m_Sum[x] = dSum;

    } // for (x = 0; x < NUMBER_RESULTS; x++)
  // Bouml preserved body end 00052882

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




CXor::CXor(oETCS::DF::CEVCStateMachine * const pStateMachine)  throw()  
:CFunctionBlock(pStateMachine),
 m_bInput1(false),
 m_bInput2(false)
{
  // Bouml preserved body begin 00052002
    // empty constructor
  // Bouml preserved body end 00052002

} //  CXor::CXor()  throw() 




CXor::~CXor()  throw()  
{
  // Bouml preserved body begin 00052082
    // empty destructor
  // Bouml preserved body end 00052082

} // CXor::~CXor()  throw() 




void CXor::Calculate()  throw(::oETCS::DF::Error::CException)  
{
  // Bouml preserved body begin 00052282
    const unsigned int      NUMBER_RESULTS(m_Result.size());
    unsigned int            x(0);
    bool                    bOutput(false);


    // compute calculation result
    bOutput = (m_bInput1() ^ m_bInput2());

    // set result in all connected outputs
    for (x = 0; x < NUMBER_RESULTS; x++)
    {
        // set result in current output
        *m_Result[x] = bOutput;

    } // for (x = 0; x < NUMBER_RESULTS; x++)
  // Bouml preserved body end 00052282

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




CDoubleArrayAccessor::CDoubleArrayAccessor(oETCS::DF::CEVCStateMachine * const pStateMachine)  throw()  
:CFunctionBlock(pStateMachine),
 m_Array(::std::vector< double >(0)),
 m_iIndex(0)
{
  // Bouml preserved body begin 00057A02
    // empty constructor
  // Bouml preserved body end 00057A02

} //  CDoubleArrayAccessor::CDoubleArrayAccessor()  throw() 




CDoubleArrayAccessor::~CDoubleArrayAccessor()  throw()  
{
  // Bouml preserved body begin 00057A82
    // empty destructor
  // Bouml preserved body end 00057A82

} // CDoubleArrayAccessor::~CDoubleArrayAccessor()  throw() 




void CDoubleArrayAccessor::Calculate()  throw(::oETCS::DF::Error::CException)  
{
  // Bouml preserved body begin 00057C82
    const unsigned int      NUMBER_RESULTS(m_Value.size());
    const int               SIZE_ARRAY(m_Array().size());
    unsigned int            x(0);
    double                  dValue(0.0);

    // check, if index input value is valid
    if (m_iIndex() >= SIZE_ARRAY)
    {
        // throw exception
        throw (::oETCS::DF::Error::CInput("index value exceeds double array's size"));
        
    } // if (m_iIndex() >= SIZE_ARRAY)

    // compute calculation result
    dValue = m_Array()[m_iIndex()];

    // set result in all connected outputs
    for (x = 0; x < NUMBER_RESULTS; x++)
    {
        // set result in current output
        *m_Value[x] = dValue;

    } // for (x = 0; x < NUMBER_RESULTS; x++)
  // Bouml preserved body end 00057C82

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




CDoubleEqualOrGreater::CDoubleEqualOrGreater(oETCS::DF::CEVCStateMachine * const pStateMachine)  throw()  
:CFunctionBlock(pStateMachine),
 m_dInput1(0.0),
 m_dInput2(0.0)
{
  // Bouml preserved body begin 00055802
    // empty constructor
  // Bouml preserved body end 00055802

} //  CDoubleEqualOrGreater::CDoubleEqualOrGreater()  throw() 




CDoubleEqualOrGreater::~CDoubleEqualOrGreater()  throw()  
{
  // Bouml preserved body begin 00055882
    // empty destructor
  // Bouml preserved body end 00055882

} // CDoubleEqualOrGreater::~CDoubleEqualOrGreater()  throw() 




void CDoubleEqualOrGreater::Calculate()  throw(::oETCS::DF::Error::CException)  
{
  // Bouml preserved body begin 00055A82
    const unsigned int      NUMBER_RESULTS(m_EqualOrGreater.size());
    unsigned int            x(0);
    bool                    bEqualOrGreater(false);


    // compute calculation result
    bEqualOrGreater = (m_dInput1() >= m_dInput2());

    // set result in all connected outputs
    for (x = 0; x < NUMBER_RESULTS; x++)
    {
        // set result in current output
        *m_EqualOrGreater[x] = bEqualOrGreater;

    } // for (x = 0; x < NUMBER_RESULTS; x++)
  // Bouml preserved body end 00055A82

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




CDoubleGreater::CDoubleGreater(oETCS::DF::CEVCStateMachine * const pStateMachine)  throw()  
:CFunctionBlock(pStateMachine),
 m_dInput1(0.0),
 m_dInput2(0.0)
{
  // Bouml preserved body begin 00055B02
    // empty constructor
  // Bouml preserved body end 00055B02

} //  CDoubleGreater::CDoubleGreater()  throw() 




CDoubleGreater::~CDoubleGreater()  throw()  
{
  // Bouml preserved body begin 00055B82
    // empty destructor
  // Bouml preserved body end 00055B82

} // CDoubleGreater::~CDoubleGreater()  throw() 




void CDoubleGreater::Calculate()  throw(::oETCS::DF::Error::CException)  
{
  // Bouml preserved body begin 00055D82
    const unsigned int      NUMBER_RESULTS(m_Greater.size());
    unsigned int            x(0);
    bool                    bGreater(false);


    // compute calculation result
    bGreater = (m_dInput1() > m_dInput2());

    // set result in all connected outputs
    for (x = 0; x < NUMBER_RESULTS; x++)
    {
        // set result in current output
        *m_Greater[x] = bGreater;

    } // for (x = 0; x < NUMBER_RESULTS; x++)
  // Bouml preserved body end 00055D82

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




CIntGreater::CIntGreater(oETCS::DF::CEVCStateMachine * const pStateMachine)  throw()  
:CFunctionBlock(pStateMachine),
 m_iInput1(0),
 m_iInput2(0)
{
  // Bouml preserved body begin 00055E02
    // empty constructor
  // Bouml preserved body end 00055E02

} //  CIntGreater::CIntGreater()  throw() 




CIntGreater::~CIntGreater()  throw()  
{
  // Bouml preserved body begin 00055E82
    // empty constructor
  // Bouml preserved body end 00055E82

} // CIntGreater::~CIntGreater()  throw() 




void CIntGreater::Calculate()  throw(::oETCS::DF::Error::CException)  
{
  // Bouml preserved body begin 00056082
    const unsigned int      NUMBER_RESULTS(m_Greater.size());
    unsigned int            x(0);
    bool                    bGreater(false);


    // compute calculation result
    bGreater = (m_iInput1() > m_iInput2());

    // set result in all connected outputs
    for (x = 0; x < NUMBER_RESULTS; x++)
    {
        // set result in current output
        *m_Greater[x] = bGreater;

    } // for (x = 0; x < NUMBER_RESULTS; x++)
  // Bouml preserved body end 00056082

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




CStringEqual::CStringEqual(oETCS::DF::CEVCStateMachine * const pStateMachine)  throw()  
:CFunctionBlock(pStateMachine),
 m_Input1(""),
 m_Input2("")
{
  // Bouml preserved body begin 00055502
    // empty constructor
  // Bouml preserved body end 00055502

} //  CStringEqual::CStringEqual()  throw() 




CStringEqual::~CStringEqual()  throw()  
{
  // Bouml preserved body begin 00055582
    // empty constructor
  // Bouml preserved body end 00055582

} // CStringEqual::~CStringEqual()  throw() 




void CStringEqual::Calculate()  throw(::oETCS::DF::Error::CException)  
{
  // Bouml preserved body begin 00055782
    const unsigned int      NUMBER_RESULTS(m_Equal.size());
    unsigned int            x(0);
    bool                    bEqual(false);


    // compute calculation result
    bEqual = (m_Input1() == m_Input2());

    // set result in all connected outputs
    for (x = 0; x < NUMBER_RESULTS; x++)
    {
        // set result in current output
        *m_Equal[x] = bEqual;

    } // for (x = 0; x < NUMBER_RESULTS; x++)
  // Bouml preserved body end 00055782

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




CBoolGate::CBoolGate(oETCS::DF::CEVCStateMachine * const pStateMachine)  throw()  
:CFunctionBlock(pStateMachine),
 m_bGateInput(false),
 m_bOpen(false)
{
  // Bouml preserved body begin 0005A282
    // empty constructor
  // Bouml preserved body end 0005A282

} //  CBoolGate::CBoolGate()  throw() 




CBoolGate::~CBoolGate()  throw()  
{
  // Bouml preserved body begin 0005A302
    // empty destructor
  // Bouml preserved body end 0005A302

} // CBoolGate::~CBoolGate()  throw() 




void CBoolGate::Calculate()  throw(::oETCS::DF::Error::CException)  
{
  // Bouml preserved body begin 0005A502
    const unsigned int      NUMBER_RESULTS(m_GateOutput.size());
    unsigned int            x(0);


    // check, if gate is opened
    if (m_bOpen())
    {
        // set result in all connected outputs
        for (x = 0; x < NUMBER_RESULTS; x++)
        {
            // set result in current output
            *m_GateOutput[x] = m_bGateInput();

        } // for (x = 0; x < NUMBER_RESULTS; x++)
        
    } // if (m_bOpen())
  // Bouml preserved body end 0005A502

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




CBoolSwitch::CBoolSwitch(oETCS::DF::CEVCStateMachine * const pStateMachine)  throw()  
:CFunctionBlock(pStateMachine),
 m_bInput1(false),
 m_bInput2(false),
 m_bUseInput1(false)
{
  // Bouml preserved body begin 0005AB82
    // empty constructor
  // Bouml preserved body end 0005AB82

} //  CBoolSwitch::CBoolSwitch()  throw() 




CBoolSwitch::~CBoolSwitch()  throw()  
{
  // Bouml preserved body begin 0005AC02
    // empty constructor
  // Bouml preserved body end 0005AC02

} // CBoolSwitch::~CBoolSwitch()  throw() 




void CBoolSwitch::Calculate()  throw(::oETCS::DF::Error::CException)  
{
  // Bouml preserved body begin 0005AE02
    const unsigned int      NUMBER_RESULTS(m_SwitchOutput.size());
    unsigned int            x(0);
    bool                    bOutput(false);

    
    // set first or second input depending on input
    bOutput = (m_bUseInput1() ? m_bInput1(): m_bInput2());

    // set result in all connected outputs
    for (x = 0; x < NUMBER_RESULTS; x++)
    {
        // set result in current output
        *m_SwitchOutput[x] = bOutput;

    } // for (x = 0; x < NUMBER_RESULTS; x++)
  // Bouml preserved body end 0005AE02

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




CDoubleGate::CDoubleGate(oETCS::DF::CEVCStateMachine * const pStateMachine)  throw()  
:CFunctionBlock(pStateMachine),
 m_dGateInput(0.0),
 m_bOpen(false)
{
  // Bouml preserved body begin 0005A582
    // empty constructor
  // Bouml preserved body end 0005A582

} //  CDoubleGate::CDoubleGate()  throw() 




CDoubleGate::~CDoubleGate()  throw()  
{
  // Bouml preserved body begin 0005A602
    // empty destructor
  // Bouml preserved body end 0005A602

} // CDoubleGate::~CDoubleGate()  throw() 




void CDoubleGate::Calculate()  throw(::oETCS::DF::Error::CException)  
{
  // Bouml preserved body begin 0005A802
    const unsigned int      NUMBER_RESULTS(m_GateOutput.size());
    unsigned int            x(0);


    // check, if gate is opened
    if (m_bOpen())
    {
        // set result in all connected outputs
        for (x = 0; x < NUMBER_RESULTS; x++)
        {
            // set result in current output
            *m_GateOutput[x] = m_dGateInput();

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

    } // if (m_bOpen())
  // Bouml preserved body end 0005A802

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




CDoubleSwitch::CDoubleSwitch(oETCS::DF::CEVCStateMachine * const pStateMachine)  throw()  
:CFunctionBlock(pStateMachine),
 m_dInput1(0.0),
 m_dInput2(0.0),
 m_bUseInput1(false)
{
  // Bouml preserved body begin 0005AF02
    // empty constructor
  // Bouml preserved body end 0005AF02

} //  CDoubleSwitch::CDoubleSwitch()  throw() 




CDoubleSwitch::~CDoubleSwitch()  throw()  
{
  // Bouml preserved body begin 0005AF82
   // empty constructor
  // Bouml preserved body end 0005AF82

} // CDoubleSwitch::~CDoubleSwitch()  throw() 




void CDoubleSwitch::Calculate()  throw(::oETCS::DF::Error::CException)  
{
  // Bouml preserved body begin 0005B202
    const unsigned int      NUMBER_RESULTS(m_SwitchOutput.size());
    unsigned int            x(0);
    double                  dOutput(0.0);


    // set first or second input depending on input
    dOutput = (m_bUseInput1() ? m_dInput1() : m_dInput2());

    // set result in all connected outputs
    for (x = 0; x < NUMBER_RESULTS; x++)
    {
        // set result in current output
        *m_SwitchOutput[x] = dOutput;

    } // for (x = 0; x < NUMBER_RESULTS; x++)
  // Bouml preserved body end 0005B202

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




CStringGate::CStringGate(oETCS::DF::CEVCStateMachine * const pStateMachine)  throw()  
:CFunctionBlock(pStateMachine),
 m_GateInput(""),
 m_bOpen(false)
{
  // Bouml preserved body begin 0005A882
    // empty constructor
  // Bouml preserved body end 0005A882

} //  CStringGate::CStringGate()  throw() 




CStringGate::~CStringGate()  throw()  
{
  // Bouml preserved body begin 0005A902
    // empty destructor
  // Bouml preserved body end 0005A902

} // CStringGate::~CStringGate()  throw() 




void CStringGate::Calculate()  throw(::oETCS::DF::Error::CException)  
{
  // Bouml preserved body begin 0005AB02
    const unsigned int      NUMBER_RESULTS(m_GateOutput.size());
    unsigned int            x(0);


    // check, if gate is opened
    if (m_bOpen())
    {
        // set result in all connected outputs
        for (x = 0; x < NUMBER_RESULTS; x++)
        {
            // set result in current output
            *m_GateOutput[x] = m_GateInput();

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

    } // if (m_bOpen())
  // Bouml preserved body end 0005AB02

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




CBrakingToTargetSpeed::CBrakingToTargetSpeed(oETCS::DF::CEVCStateMachine * const pStateMachine)  throw()  
:CFunctionBlock(pStateMachine),
 m_GradientDistances(::std::vector< double >(0)),
 m_GradientValues(::std::vector< double >(0)),
 m_dCurrentAbsoluteDistance(0.0),
 m_dCurrentVelocity(0.0),
 m_dDistanceOfPermittedVelocity(0.0),
 m_dPermittedVelocity(0.0),
 m_dAdhesionFactor(1.0)
{
  // Bouml preserved body begin 00059602
    // empty constructor
  // Bouml preserved body end 00059602

} //  CBrakingToTargetSpeed::CBrakingToTargetSpeed()  throw() 




CBrakingToTargetSpeed::~CBrakingToTargetSpeed()  throw()  
{
  // Bouml preserved body begin 00059682
    // empty destructor
  // Bouml preserved body end 00059682

} // CBrakingToTargetSpeed::~CBrakingToTargetSpeed()  throw() 




void CBrakingToTargetSpeed::Calculate()  throw(::oETCS::DF::Error::CException)  
{
  // Bouml preserved body begin 00059882
    double                                      dAccelration(0.0);
    double                                      dBrakeIntensity(0.0);
    const double                                HARD_LIMIT(1.05 * m_dPermittedVelocity() * m_dAdhesionFactor());
    const double                                SOFT_LIMIT(m_dPermittedVelocity() * m_dAdhesionFactor());
    const long double                           FRICTION_COEFICIENT(0.25);
    const long double                           GRAVITATION_ACCELERATION(9.81);
    const double                                V0(m_dCurrentVelocity());
    const double                                V1(m_dPermittedVelocity());
    const double                                S1(m_dDistanceOfPermittedVelocity() - m_dCurrentAbsoluteDistance());
    const double                                MAXIMAL_ACCELRATION(FRICTION_COEFICIENT * GRAVITATION_ACCELERATION * m_dAdhesionFactor());
    decltype (m_ServiceBrakeValue.begin())      sv;    
    decltype (m_ServiceBrakeApplied.begin())    sa;
    decltype (m_EmergencyBrakeValue.begin())    ev;
    decltype (m_EmergencyBrakeApplied.begin())  ea;
    decltype (m_SpeedWarning.begin())           sw;
    bool                                        bSpeedWarning(false);
    bool                                        bServiceApplied(false);
    bool                                        bEmergencyApplied(false);
    
    
    
    // check, if current speed is over hard limit
    if (m_dCurrentVelocity() > HARD_LIMIT)
    {
        // calculate negative acceleration for this time point
        dAccelration = (V0 - V1) * (3 * V0 - V1) / (2 * S1);
        
        // calculate brake intensity in [%] by acceleration ratio
        dBrakeIntensity = dAccelration / MAXIMAL_ACCELRATION * 100.0;
        
        // check, if brake intensity is greater than 100%
        if (dBrakeIntensity > 100.0)
        {
            // reset brake intensity to 100%, more are not allowed
            dBrakeIntensity = 100.0;
            
            // set service brake activation flag to true
            bServiceApplied = true;
            
            // also activate emergency brake, because target speed cannot be met
            bEmergencyApplied = true;
            
            // set speed warning flag to true
            bSpeedWarning = true;
            
        } // if (dBrakeIntensity > 100.0)
        else if (dBrakeIntensity < 1.0)
        {
            // small brake intensities are ignored due to granularity of control
            dBrakeIntensity = 0.0;
            
        } // else if (dBrakeIntensity < 1.0)
        else
        {
            // set service brake activation flag to true
            bServiceApplied = true;
            
            // set speed warning flag to true
            bSpeedWarning = true;
            
        } // else 
        
    } // if (m_dCurrentVelocity() > HARD_LIMIT)
    else if (m_dCurrentVelocity() <= HARD_LIMIT && m_dCurrentVelocity() > SOFT_LIMIT)
    {
        // set speed warning flag to true
        bSpeedWarning = true;
        
    } // else if (m_dCurrentVelocity() <= HARD_LIMIT && m_dCurrentVelocity() > SOFT_LIMIT)
    
    
    
    // copy brake intensity to all service brakes
    for (sv = m_ServiceBrakeValue.begin(); sv != m_ServiceBrakeValue.end(); sv++)
    {
        // copy value to current element
        **sv = dBrakeIntensity;

    } // for (sv = m_ServiceBrakeValue.begin(); sv != m_ServiceBrakeValue.end(); sv++)  
    
    // copy brake activation to all service emergency brakes
    for (ev = m_EmergencyBrakeValue.begin(); ev != m_EmergencyBrakeValue.end(); ev++)
    {
        // copy value to current element
        **ev = bEmergencyApplied;

    } // for (ev = m_EmergencyBrakeValue.begin(); ev != m_EmergencyBrakeValue.end(); ev++)
    
    // copy speed warning to all outputs
    for (sw = m_SpeedWarning.begin(); sw != m_SpeedWarning.end(); sw++)
    {
        // copy value to current output
        **sw = bSpeedWarning;
        
    } // for (sw = m_SpeedWarning.begin(); sw != m_SpeedWarning.end(); sw++)
    
    // copy service brake applied flag to all outputs
    for (sa = m_ServiceBrakeApplied.begin(); sa != m_ServiceBrakeApplied.end(); sa++)
    {
        // copy value to current output
        **sa = bServiceApplied;
        
    } // for (sa = m_ServiceBrakeApplied.begin(); sa != m_ServiceBrakeApplied.end(); sa++)
    
    // copy emergency brake applied flag to all outputs
    for (ea = m_EmergencyBrakeApplied.begin(); ea != m_EmergencyBrakeApplied.end(); ea++)
    {
        // copy value to current output
        **ea = bEmergencyApplied;
        
    } // for (ea = m_EmergencyBrakeApplied.begin(); ea != m_EmergencyBrakeApplied.end(); ea++)
  // Bouml preserved body end 00059882

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




CCeelingSpeedControl::CCeelingSpeedControl(oETCS::DF::CEVCStateMachine * const pStateMachine)  throw()  
:CFunctionBlock(pStateMachine),
 m_GradientDistances(::std::vector< double >(0)),
 m_GradientValues(::std::vector< double >(0)),
 m_dCurrentAbsoluteDistance(0.0),
 m_dCurrentVelocity(0.0),
 m_dPermittedVelocity(0.0),
 m_dAdhesionFactor(1.0)
{
  // Bouml preserved body begin 000BB282
    // empty constructor
  // Bouml preserved body end 000BB282

} //  CCeelingSpeedControl::CCeelingSpeedControl()  throw() 




CCeelingSpeedControl::~CCeelingSpeedControl()  throw()  
{
  // Bouml preserved body begin 000BB302
    // empty destructor
  // Bouml preserved body end 000BB302

} // CCeelingSpeedControl::~CCeelingSpeedControl()  throw() 




void CCeelingSpeedControl::Calculate()  throw(::oETCS::DF::Error::CException)  
{
  // Bouml preserved body begin 000BB382
    double                                      dBrakeIntensity(0.0);
    const double                                HARD_LIMIT(1.05 * m_dPermittedVelocity() * m_dAdhesionFactor());
    const double                                SOFT_LIMIT(m_dPermittedVelocity() * m_dAdhesionFactor());
    decltype (m_ServiceBrakeValue.begin())      sv;    
    decltype (m_ServiceBrakeApplied.begin())    sa;
    decltype (m_EmergencyBrakeValue.begin())    ev;
    decltype (m_EmergencyBrakeApplied.begin())  ea;
    decltype (m_SpeedWarning.begin())           sw;
    bool                                        bSpeedWarning(false);
    bool                                        bServiceApplied(false);
    bool                                        bEmergencyApplied(false);
    
    
    
    // compare current speed with ceeling speed with limits
    if (m_dCurrentVelocity() > HARD_LIMIT)
    {
        // check, if any service brake is connected
        if (not m_ServiceBrakeValue.empty())
        {
            // calculate brake intensity
            dBrakeIntensity = (m_dCurrentVelocity() - SOFT_LIMIT) / SOFT_LIMIT * 2.0 * 100.0;
            
            // check, if brake intensity is greater than 100%
            if (dBrakeIntensity > 100.0)
            {
                // reset brake intensity to 100%, more are not allowed
                dBrakeIntensity = 100.0;

                // also activate emergency brake, because target speed cannot be met
                bEmergencyApplied = true;

            } // if (dBrakeIntensity > 100.0)
            else if (dBrakeIntensity < 0.1)
            {
                // small brake intensities are ignored due to granularity of control
                dBrakeIntensity = 0.0;

            } // else if (dBrakeIntensity < 0.1)
            
            // set service brake applied flag to true
            bServiceApplied = true;
            
        } // if (not m_ServiceBrakeValue.empty())
        else
        {
            // set emergency applied flag to true;
            bEmergencyApplied = true;
            
        } // else
        
        // set speed warning to true
        bSpeedWarning = true;
        
    } // if (m_dCurrentVelocity() > HARD_LIMIT)
    else if (m_dCurrentVelocity() <= HARD_LIMIT && m_dCurrentVelocity() > SOFT_LIMIT)
    {
        // only set speed warning to true
        bSpeedWarning = true;
        
    } // else if (m_dCurrentVelocity() <= HARD_LIMIT && m_dCurrentVelocity() > SOFT_LIMIT)
    
    
    
    
    // copy brake intensity to all service brakes
    for (sv = m_ServiceBrakeValue.begin(); sv != m_ServiceBrakeValue.end(); sv++)
    {
        // copy value to current element
        **sv = dBrakeIntensity;

    } // for (sv = m_ServiceBrakeValue.begin(); sv != m_ServiceBrakeValue.end(); sv++)  
    
    // copy brake activation to all service emergency brakes
    for (ev = m_EmergencyBrakeValue.begin(); ev != m_EmergencyBrakeValue.end(); ev++)
    {
        // copy value to current element
        **ev = bEmergencyApplied;

    } // for (ev = m_EmergencyBrakeValue.begin(); ev != m_EmergencyBrakeValue.end(); ev++)
    
    // copy speed warning to all outputs
    for (sw = m_SpeedWarning.begin(); sw != m_SpeedWarning.end(); sw++)
    {
        // copy value to current output
        **sw = bSpeedWarning;
        
    } // for (sw = m_SpeedWarning.begin(); sw != m_SpeedWarning.end(); sw++)
    
    // copy service brake applied flag to all outputs
    for (sa = m_ServiceBrakeApplied.begin(); sa != m_ServiceBrakeApplied.end(); sa++)
    {
        // copy value to current output
        **sa = bServiceApplied;
        
    } // for (sa = m_ServiceBrakeApplied.begin(); sa != m_ServiceBrakeApplied.end(); sa++)
    
    // copy emergency brake applied flag to all outputs
    for (ea = m_EmergencyBrakeApplied.begin(); ea != m_EmergencyBrakeApplied.end(); ea++)
    {
        // copy value to current output
        **ea = bEmergencyApplied;
        
    } // for (ea = m_EmergencyBrakeApplied.begin(); ea != m_EmergencyBrakeApplied.end(); ea++)
  // Bouml preserved body end 000BB382

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




CEnteredTrigger::CEnteredTrigger(oETCS::DF::CEVCStateMachine * const pStateMachine)  throw()  
:CFunctionBlock(pStateMachine)
{
  // Bouml preserved body begin 0005B602
    // empty constructor
  // Bouml preserved body end 0005B602

} //  CEnteredTrigger::CEnteredTrigger()  throw() 




CEnteredTrigger::~CEnteredTrigger()  throw()  
{
  // Bouml preserved body begin 0005B682
    // empty destructor
  // Bouml preserved body end 0005B682

} // CEnteredTrigger::~CEnteredTrigger()  throw() 




void CEnteredTrigger::Calculate()  throw(::oETCS::DF::Error::CException)  
{
  // Bouml preserved body begin 0005B902
    const unsigned int      NUMBER_RESULTS(m_Entered.size());
    unsigned int            x(0);

    
    // set result in all connected outputs
    for (x = 0; x < NUMBER_RESULTS; x++)
    {
        // set result in current output
        *m_Entered[x] = ::oETCS::DF::CEnteredTrigger::m_bEnteredState;

    } // for (x = 0; x < NUMBER_RESULTS; x++)
  // Bouml preserved body end 0005B902

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




/*!
 *  \brief class global flag for a newly entered data flow
 */
bool CEnteredTrigger::m_bEnteredState = false;



CStringSwitch::CStringSwitch(oETCS::DF::CEVCStateMachine * const pStateMachine)  throw()  
:CFunctionBlock(pStateMachine),
 m_Input1(""),
 m_Input2(""),
 m_bUseInput1(false)
{
  // Bouml preserved body begin 0005B282
    // empty constructor
  // Bouml preserved body end 0005B282

} //  CStringSwitch::CStringSwitch()  throw() 




CStringSwitch::~CStringSwitch()  throw()  
{
  // Bouml preserved body begin 0005B302
    // empty destructor
  // Bouml preserved body end 0005B302

} // CStringSwitch::~CStringSwitch()  throw() 




void CStringSwitch::Calculate()  throw(::oETCS::DF::Error::CException)  
{
  // Bouml preserved body begin 0005B582
    const unsigned int      NUMBER_RESULTS(m_SwitchOutput.size());
    unsigned int            x(0);
    ::std::string           Output;


    // set first or second input depending on input
    Output = (m_bUseInput1() ? m_Input1() : m_Input2());

    // set result in all connected outputs
    for (x = 0; x < NUMBER_RESULTS; x++)
    {
        // set result in current output
        *m_SwitchOutput[x] = Output;

    } // for (x = 0; x < NUMBER_RESULTS; x++)
  // Bouml preserved body end 0005B582

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




CIntEqual::CIntEqual(oETCS::DF::CEVCStateMachine * const pStateMachine)  throw()  
:CFunctionBlock(pStateMachine),
 m_iInput1(0),
 m_iInput2(0)
{
  // Bouml preserved body begin 00055202
    // empty constructor
  // Bouml preserved body end 00055202

} //  CIntEqual::CIntEqual()  throw() 




CIntEqual::~CIntEqual()  throw()  
{
  // Bouml preserved body begin 00055282
    // empty constructor
  // Bouml preserved body end 00055282

} // CIntEqual::~CIntEqual()  throw() 




void CIntEqual::Calculate()  throw(::oETCS::DF::Error::CException)  
{
  // Bouml preserved body begin 00055482
    const unsigned int      NUMBER_RESULTS(m_Equal.size());
    unsigned int            x(0);
    bool                    bEqual(false);


    // compute calculation result
    bEqual = (m_iInput1() == m_iInput2());

    // set result in all connected outputs
    for (x = 0; x < NUMBER_RESULTS; x++)
    {
        // set result in current output
        *m_Equal[x] = bEqual;

    } // for (x = 0; x < NUMBER_RESULTS; x++)
  // Bouml preserved body end 00055482

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




CComBlockIn::CComBlockIn(oETCS::DF::CEVCStateMachine * const pStateMachine, const ::std::vector< oETCS::DF::CBaliseDeviceIn * >& InDevices, const ::std::vector<  unsigned char > & PacketIDs)  throw()  
:CFunctionBlock(pStateMachine),
 m_PacketIDs(PacketIDs),
 m_InDevices(InDevices)
{
  // Bouml preserved body begin 00059E82
    // empty constructor
  // Bouml preserved body end 00059E82

} //  CComBlockIn::CComBlockIn()  throw() 




CComBlockIn::~CComBlockIn()  throw()  
{
  // Bouml preserved body begin 00059F02
    unsigned int        x(0);
    
    
    // delete all in devices
    for (x = 0; x < m_InDevices.size(); x++)
    {
        // delete current device
        delete m_InDevices[x];
        
    } // for (x = 0; x < m_InDevices.size(); x++)
  // Bouml preserved body end 00059F02

} // CComBlockIn::~CComBlockIn()  throw() 




void CComBlockIn::Calculate()  throw(::oETCS::DF::Error::CException)  
{
  // Bouml preserved body begin 00059F82
    const unsigned int                  NUMBER_RESULTS(m_Received.size());
    const unsigned int                  NUMBER_DEVICES(m_InDevices.size());
    unsigned int                        x(0);
    bool                                bTelegramReceived(false);
    ::std::vector< unsigned char >      IDs;
    decltype (m_PacketIDs.begin())      vid;
    decltype (IDs.begin())              id;

    
    // get result from all included devices
    for (x = 0; x < NUMBER_DEVICES; x++)
    { 
        // get received flag from current device
        IDs = m_InDevices[x]->HasNewTelegram();

        // check, if any ID in current telegram is valid
        for (id = IDs.begin(); id != IDs.end() && not bTelegramReceived; id++)
        {
            // check all valid packet IDs
            for (vid = m_PacketIDs.begin(); vid != m_PacketIDs.end(); vid++)
            {
                // compare current packet IDs
                bTelegramReceived |= (*id == *vid);

            } // for (vid = m_PacketIDs.begin(); vid != m_PacketIDs.end(); vid++)

        } // for (id = IDs.begin(); id != IDs.end() && not bTelegramReceived; id++)



    } // for (x = 0; x < NUMBER_DEVICES; x++)
    
    // set result in all connected outputs
    for (x = 0; x < NUMBER_RESULTS; x++)
    {
        // set result in current output
        *m_Received[x] = bTelegramReceived;

    } // for (x = 0; x < NUMBER_RESULTS; x++)
  // Bouml preserved body end 00059F82

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




void CComBlockIn::Clear()  throw()  
{
  // Bouml preserved body begin 000FE282
    decltype (m_InDevices.begin())      id;

    // process all connected in devices
    for (id = m_InDevices.begin(); id != m_InDevices.end(); id++)
    {
        // clear all bit arrays from balise in device
        (*id)->Clear();

    } // for (id = m_InDevices.begin(); id != m_InDevices.end(); id++)
  // Bouml preserved body end 000FE282

} // void CComBlockIn::Clear()  throw() 




CComBlockOut::CComBlockOut(oETCS::DF::CEVCStateMachine * const pStateMachine, const ::std::vector< oETCS::DF::CBaliseDeviceOut * >& OutDevices)  throw()  
:CFunctionBlock(pStateMachine),
 m_bSendTelegram(false),
 m_OutDevices(OutDevices)
{
  // Bouml preserved body begin 0005A082
    // empty constructor
  // Bouml preserved body end 0005A082

} //  CComBlockOut::CComBlockOut()  throw() 




CComBlockOut::~CComBlockOut()  throw()  
{
  // Bouml preserved body begin 0005A102
    unsigned int            x(0);
    
    
    
    // delete all out devices
    for (x = 0; x < m_OutDevices.size(); x++)
    {
        // delete current device
        delete m_OutDevices[x];
        
    } // for (x = 0; x < m_OutDevices.size(); x++)
  // Bouml preserved body end 0005A102

} // CComBlockOut::~CComBlockOut()  throw() 




void CComBlockOut::Calculate()  throw(::oETCS::DF::Error::CException)  
{
  // Bouml preserved body begin 0005A182
    const unsigned int          NUMBER_DEVICES(m_OutDevices.size());
    unsigned int                x(0);
    
    
    // check, if send input is true
    if (m_bSendTelegram())
    {
        // process all out devices
        for (x = 0; x < NUMBER_DEVICES; x++)
        {
            // execute sending via current device
            m_OutDevices[x]->SendTelegram();
            
        } // for (x = 0; x < NUMBER_DEVICES; x++)
        
    } // if (m_bSendTelegram())
  // Bouml preserved body end 0005A182

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




CDMIInput::CDMIInput(oETCS::DF::CEVCStateMachine * const pStateMachine, const oETCS::DF::DATA_T & eType, const ::std::string & Label, const bool & bInitialVisible)  throw()  
:CFunctionBlock(pStateMachine),
 m_bBool(false),
 m_dDouble(0.0),
 m_iInt(0),
 m_String(""),
 m_bVisible(bInitialVisible),
 m_Label(Label),
 m_eType(eType)
{
  // Bouml preserved body begin 0005D702
    // empty constructor
  // Bouml preserved body end 0005D702

} //  CDMIInput::CDMIInput()  throw() 




CDMIInput::~CDMIInput()  throw()  
{
  // Bouml preserved body begin 0005D782
    // empty destructor
  // Bouml preserved body end 0005D782

} // CDMIInput::~CDMIInput()  throw() 




void CDMIInput::Calculate()  throw(::oETCS::DF::Error::CException)  
{
  // Bouml preserved body begin 0005D682
    decltype (m_BoolMessage.begin())            b(0);
    decltype (m_IntMessage.begin())             i(0);
    decltype (m_DoubleMessage.begin())          d(0);
    decltype (m_StringMessage.begin())          s(0);
    decltype (m_EnteredData.begin())            e(0);
    bool                                        bDataEntered(false);
    
    
    
    // check data type used for this instance
    switch (m_eType)
    {
        case ::oETCS::DF::BOOL:
            
            // copy input value to all outputs
            for (b = m_BoolMessage.begin(); b != m_BoolMessage.end(); b++)
            {
                // copy value to current output
                **b = m_bBool();
                
            } // for (b = m_BoolMessage.begin(); b != m_BoolMessage.end(); b++)
            
            // set data entered flag from input
            bDataEntered = m_bBool.IsModified();

            break;


        case ::oETCS::DF::INT:
            
            // copy input value to all outputs
            for (i = m_IntMessage.begin(); i != m_IntMessage.end(); i++)
            {
                // copy value to current output
                **i = m_iInt();
                
            } // for (i = m_IntMessage.begin(); i != m_IntMessage.end(); i++)
            
            // set data entered flag from input
            bDataEntered = m_iInt.IsModified();
           
            break;


        case ::oETCS::DF::DOUBLE:

            // copy input value to all outputs
            for (d = m_DoubleMessage.begin(); d != m_DoubleMessage.end(); d++)
            {
                // copy value to current output
                **d = m_dDouble();
                
            } // for (d = m_DoubleMessage.begin(); d != m_DoubleMessage.end(); d++)
            
            // set data entered flag from input
            bDataEntered = m_dDouble.IsModified();

            break;


        case ::oETCS::DF::STRING:
            
            // copy input value to all outputs
            for (s = m_StringMessage.begin(); s != m_StringMessage.end(); s++)
            {
                // copy value to current output
                **s = m_String();
                
            } // for (s = m_StringMessage.begin(); s != m_StringMessage.end(); s++)
           
            // set data entered flag from input
            bDataEntered = m_String.IsModified();

            break;


        case ::oETCS::DF::DOUBLE_ARRAY:

            // not (yet) implemented

            break;

    } // switch (m_eType)
    
    
    // copy all data entered flag to all outputs
    for (e = m_EnteredData.begin(); e != m_EnteredData.end(); e++)
    {
        // copy value to current output
        **e = bDataEntered;
        
    } // for (e = m_EnteredData.begin(); e != m_EnteredData.end(); e++)
    
  // Bouml preserved body end 0005D682

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




CDMIOutput::CDMIOutput(oETCS::DF::CEVCStateMachine * const pStateMachine, const oETCS::DF::DATA_T & eType, const ::std::string& Label, const bool & bInitialVisible)  throw()  
:CFunctionBlock(pStateMachine),
 m_bBoolMessage(false),
 m_dDoubleMessage(0.0),
 m_DoubleArrayMessage(::std::vector< double >(0)),
 m_iIntMessage(0),
 m_StringMessage(""),
 m_bVisible(bInitialVisible),
 m_Label(Label),
 m_eType(eType)
{
  // Bouml preserved body begin 0005D282
    // empty constructor
  // Bouml preserved body end 0005D282

} //  CDMIOutput::CDMIOutput()  throw() 




CDMIOutput::~CDMIOutput()  throw()  
{
  // Bouml preserved body begin 0005D302
    // empty destructor
  // Bouml preserved body end 0005D302

} //  CDMIOutput::~CDMIOutput()  throw() 




void CDMIOutput::Calculate()  throw(::oETCS::DF::Error::CException)  
{
  // Bouml preserved body begin 0005D602
    bool                bModified(false);
    
    
    
    // check data type used for this instance
    switch (m_eType)
    {
        case ::oETCS::DF::BOOL:
            
            // check, if input was changed
            bModified = m_bBoolMessage.IsModified();
            
            break;
            
            
        case ::oETCS::DF::INT:
            
            // check, if input was changed
            bModified = m_iIntMessage.IsModified();
            
            break;
            
            
        case ::oETCS::DF::DOUBLE:
            
            // check, if input was changed
            bModified = m_dDoubleMessage.IsModified();
            
            break;
            
            
        case ::oETCS::DF::STRING:
            
            // check, if input was changed
            bModified = m_StringMessage.IsModified();
            
            break;
            
            
        case ::oETCS::DF::DOUBLE_ARRAY:
            
            // check, if input was changed
            bModified = m_DoubleArrayMessage.IsModified();
            
            break;
        
    } // switch (m_eType)
    
    
    // check, if the relevant input was modified
    if (bModified)
    {
        // notify all observers via the parent EVC state object
        m_pStateMachine->Notify();
        
    } // if (bModified)
  // Bouml preserved body end 0005D602

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






} // namespace oETCS::DF

} // namespace oETCS