WrapperFunctions.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 C wrapper functions for the simulative PSM classes
 */

#include "WrapperFunctions.h"




/*!
 *  \brief module global odometer object
 */
static ::oETCS::DF::PS::SIM::COdometer* m_pOdometer = 0;



/*!
 *  \brief module global emergency brake object
 */
static ::oETCS::DF::PS::SIM::CEmergencyBrake* m_pEmergencyBrake = 0;



/*!
 *  \brief module global service brake object
 */
static ::oETCS::DF::PS::SIM::CServiceBrake* m_pServiceBrake = 0;



/*!
 *  \brief module global balise out device object
 */
static ::oETCS::DF::PS::SIM::CBaliseDeviceOut* m_pBaliseOutDevice = 0;



/*!
 *  \brief module global balise in device object
 */
static ::oETCS::DF::PS::SIM::CBaliseDeviceIn* m_pBaliseInDevice = 0;



/*!
 *  \brief module global DMI interface/proxy
 */
static ::oETCS::DF::IDMI* m_pDMI = 0;




const int            G_TELEGRAM_LEVEL_0_TO_1[] = {1,   0,0,1,0,1,1,1,   0,   0,0,0,   0,0,0,   0,0,   0,0,0,0,0,0,0,1,   0,0,0,0,0,0,0,0,1,1,   0,0,0,0,0,0,0,0,0,0,0,0,0,0,   0,
                                                  0,0,1,0,1,0,0,1,   1,0,   0,0,0,0,0,0,1,1,1,1,0,0,1,   0,1,   0,0,0,0,0,1,1,1,1,1,0,1,0,0,0,   0,1,0,   0,0,0,0,0,1,1,0,0,1,0,0,0,0,0,   0,0,0,0,0,
                                                  1,1,1,1,1,1,1,1
                                                 };






const int            G_SIZE_TELEGRAM_LEVEL_0_TO_1 = 50 + 63 + 8;






const int            G_TELEGRAM_LEVEL_STOP_IN_SR[] = {1,   0,0,1,0,1,1,1,   0,   0,0,0,   0,0,0,   0,0,   0,0,0,0,0,0,0,1,   0,0,0,0,0,0,0,0,1,1,   0,0,0,0,0,0,0,0,0,0,0,0,0,0,   0,
                                                      1,0,0,0,1,0,0,1,   1,0,   0,0,0,0,0,0,1,0,1,0,0,1,0,   0,
                                                      1,1,1,1,1,1,1,1
                                                     };






const int            G_SIZE_TELEGRAM_STOP_IN_SR = 50 + 24 + 8;





void QAppThread(bool * pInitialised) 
 
{
  // Bouml preserved body begin 000EFD82
    ::AOdometer*                                pOdometer(nullptr);
    ::AEmergencyBrake*                          pEmergencyBrake(nullptr);
    ::AServiceBrake*                            pServiceBrake(nullptr);
    ::ABaliseDeviceIn*                          pBaliseIn(nullptr);
    ::ABaliseDeviceOut*                         pBaliseOut(nullptr);
    bool                                        bConnected(true);
    int                                         argc(0);
    char**                                      argv(nullptr);
    QCoreApplication                            Application(argc, argv);
    QDBusConnection                             Connection = QDBusConnection::sessionBus();


    try
    {
        // create all simulation objects
        m_pOdometer             = new ::oETCS::DF::PS::SIM::COdometer;
        m_pEmergencyBrake       = new ::oETCS::DF::PS::SIM::CEmergencyBrake;
        m_pServiceBrake         = new ::oETCS::DF::PS::SIM::CServiceBrake(m_pOdometer, m_pEmergencyBrake);
        m_pBaliseOutDevice      = new ::oETCS::DF::PS::SIM::CBaliseDeviceOut;
        m_pBaliseInDevice       = new ::oETCS::DF::PS::SIM::CBaliseDeviceIn;


        // create all adaptors objects
        pOdometer               = new ::AOdometer(m_pOdometer);
        pEmergencyBrake         = new ::AEmergencyBrake(m_pEmergencyBrake);
        pServiceBrake           = new ::AServiceBrake(m_pServiceBrake);
        pBaliseOut              = new ::ABaliseDeviceOut(m_pBaliseOutDevice);
        pBaliseIn               = new ::ABaliseDeviceIn(m_pBaliseInDevice);
        
        
        // register all adaptors
        bConnected &= Connection.registerService("oETCS.DF.IOdometer");
        bConnected &= Connection.registerObject("/oETCS/Odometer", m_pOdometer);
        bConnected &= Connection.registerService("oETCS.DF.IEmergencyBrake");
        bConnected &= Connection.registerObject("/oETCS/EmergencyBrake", m_pEmergencyBrake);
        bConnected &= Connection.registerService("oETCS.DF.IServiceBrake");
        bConnected &= Connection.registerObject("/oETCS/ServiceBrake", m_pServiceBrake);
        bConnected &= Connection.registerService("oETCS.DF.IBaliseDeviceIn");
        bConnected &= Connection.registerObject("/oETCS/BaliseDeviceIn", m_pBaliseInDevice);
        bConnected &= Connection.registerService("oETCS.DF.IBaliseDeviceOut");
        bConnected &= Connection.registerObject("/oETCS/BaliseDeviceOut", m_pBaliseOutDevice);
        

        // check, if all adaptors where registered successfully
        if (not bConnected)
        {
            // print warning to stderr
            ::std::cerr << "QAppThread: Could not register all adaptors!" << ::std::endl;

        } // if (not bConnected)

        // set initialised flag to true
        *pInitialised = true;

        // print status to stdout
        ::std::cout << "QAppThread: Executing adaptor event loop ..." << ::std::endl;
        
        // execute core application
        QCoreApplication::exec();

    } // try
    catch (const ::std::bad_alloc& Exception)
    {
        // print error to stderr
        ::std::cerr << "Could not allocate all adaptor objects: " << Exception.what() << ::std::endl;

    } // catch (const ::std::bad_alloc& Exception)
    
    // delete all objects
    delete (pOdometer);
    delete (pEmergencyBrake);
    delete (pServiceBrake);
    delete (pBaliseIn);
    delete (pBaliseOut);
    delete (m_pOdometer);
    delete (m_pEmergencyBrake);
    delete (m_pServiceBrake);
    delete (m_pBaliseOutDevice);
    delete (m_pBaliseInDevice);
    delete (m_pDMI);
  // Bouml preserved body end 000EFD82

} // void QAppThread() 





void InitPSM()   
{
  // Bouml preserved body begin 000EAB02
    bool                bInitialised(false);
    ::std::thread*      pAppThread(nullptr);
    
    // call thread function for QCoreApplication instance
    pAppThread = new ::std::thread(QAppThread, &bInitialised);
    
    // check, if thread is joinable
    if (pAppThread->joinable())
    {
        // wait until PSM is initialised
        while (not bInitialised)
        {
            // yield this thread
            ::std::this_thread::yield();
            
        } // while (not bInitialised)
        
        // detach thread from object
        pAppThread->detach();
        
        // delete thread object
        delete (pAppThread);
        
    } // if (pAppThread->joinable())
  // Bouml preserved body end 000EAB02

} // void WrapperFunctions::InitPSM()  throw() 




int InitDMI()   
{
  // Bouml preserved body begin 000F5582
    bool            bInitialised(true);
    
    
    
    // check, if DMI proxy is not yet created
    if (m_pDMI == nullptr)
    {
        try
        {
            // create new interface proxy
            m_pDMI = new ::oETCS::DF::IDMI(::oETCS::DF::IDMI::staticInterfaceName(), "/oETCS/DMI", QDBusConnection::sessionBus());

            // check, if proxy could be connected
            if (not m_pDMI->isValid())
            {
                // print error from dbus to stderr
                ::std::cerr << "::oETCS::DF::IDDMI had a problem with D-Bus connection: " << m_pDMI->lastError().message().toStdString() << ::std::endl;

                // delete proxy
                delete m_pDMI;

                // reset proxy pointer 
                m_pDMI = 0;
                
                // set initialised flag to false
                bInitialised = false;

            } // if (not m_pDMI->isValid())
            else
            {
                // set timeout for all calls on interface
                //m_pDMI->setTimeout(10);

            } // else

        } // try
        catch (const ::std::bad_alloc& Exception)
        {
            // set initialised flag to false
            bInitialised = false;

        } // catch (const ::std::bad_alloc& Exception)

    } // if (m_pDMI == nullptr)
    
    
    // return init flag
    return (bInitialised);
  // Bouml preserved body end 000F5582

} // int InitDMI()  




int DMIHasInput()   
{
  // Bouml preserved body begin 000EAB82
    int                                         iHasInput(false);
    QDBusPendingReply< bool >                   AsyncReply;
    
    
    // call init DMI
    InitDMI();
    
    // check, if DMI proxy is available
    if (m_pDMI != nullptr)
    {
        // get HasInput via proxy
        AsyncReply = m_pDMI->HasInput();

        // wait for asynchronous call to be finished
        AsyncReply.waitForFinished();

        // check, if replay was valid
        if (not AsyncReply.isValid())
        {
            // print error
            ::std::cerr << "error while calling remote method IDMI::HasInput() -> " << AsyncReply.error().message().toStdString() << ::std::endl;

        } // if (not AsyncReply.isValid())

        // get velocity from reply
        iHasInput = AsyncReply.value() ? 1 : 0;
        
    } // if (m_pDMI != nullptr)
    else
    {
        // print error
        ::std::cerr << "could not establish connection to DMI adaptor" << ::std::endl;
        
    } // else
    
    // return input flag
    return (iHasInput);
  // Bouml preserved body end 000EAB82

} // intDMIHasInput()  




void GetDMIOutput(const char * const pName, char ** const ppValue)   
{
  // Bouml preserved body begin 000F6F02
    QDBusPendingReply< QString >    AsyncReply;
    const QString                   NAME(pName);


    

    // call init DMI
    InitDMI();

    // check, if DMI proxy is available
    if (m_pDMI != nullptr)
    {
        
        #ifdef __OETCS_DF_SIM_DEBUG_OUTPUT__
        // DEBUG
        ::std::cout << "DEBUG: in GetDMIOutput() -> calling IDMI::GetDMIOutput(\"" << pName << "\")..." << ::std::flush;
        #endif
        
        // call method via proxy
       AsyncReply = m_pDMI->GetOutputValue(NAME);

        // wait for asynchronous call to be finished
        AsyncReply.waitForFinished();
        
        #ifdef __OETCS_DF_SIM_DEBUG_OUTPUT__
        // DEBUG
        ::std::cout << "done" << ::std::endl;
        #endif

        // check, if reply was valid
        if (not AsyncReply.isValid())
        {
            // print error
            ::std::cerr << "error while calling remote method IDMI::GetOutputValue() -> " << AsyncReply.error().message().toStdString() << ::std::endl;

        } // if (not AsyncReply.isValid())
        else
        {
            // check, if pointer to pointer and pointer are valid
            if (ppValue != nullptr && *ppValue != nullptr)
            {
                // delete pointer
                delete (*ppValue);

            } // if (ppValue != nullptr && *ppValue != nullptr)

            // allocate memory for value pointer
            *ppValue = new (char[AsyncReply.value().size()]);

            // store reply in return value
            strcpy(*ppValue, AsyncReply.value().toStdString().c_str());

            #ifdef __OETCS_DF_SIM_DEBUG_OUTPUT__
            // DEBUG
            ::std::cout << "DEBUG: value of output filed \"" << pName << "\": \"" << *ppValue << "\"" << ::std::endl;
            #endif

        } // else

    } // if (m_pDMI != nullptr)
    else
    {
        // print error
        ::std::cerr << "could not establish connection to DMI adaptor" << ::std::endl;

    } // else
  // Bouml preserved body end 000F6F02

} // void WrapperFunctions::GetDMIOutput()  




void SetDMIBooleanValue(const char * const pInputName, int iValue)   
{
  // Bouml preserved body begin 000EE382
    QDBusPendingReply<>                   AsyncReply;
    
    
    
    // call init DMI
    InitDMI();
    
    // check, if DMI proxy is available
    if (m_pDMI != nullptr)
    {
        #ifdef __OETCS_DF_SIM_DEBUG_OUTPUT__
        // DEBUG
        ::std::cout << "DEBUG: calling IDMI::SetBooleanValue()..." << ::std::flush;
        #endif
        
        // call method via proxy
        AsyncReply = m_pDMI->SetBooleanValue(pInputName, iValue == 0 ? false : true);

        // wait for asynchronous call to be finished
        AsyncReply.waitForFinished();
        
        #ifdef __OETCS_DF_SIM_DEBUG_OUTPUT__
        // DEBUG
        ::std::cout << "done" << ::std::endl;
        #endif

        // check, if replay was valid
        if (not AsyncReply.isValid())
        {
            // print error
            ::std::cerr << "error while calling remote method IDMI::SetBooleanValue() -> " << AsyncReply.error().message().toStdString() << ::std::endl;

        } // if (not AsyncReply.isValid())

    } // if (m_pDMI != nullptr)
    else
    {
        // print error
        ::std::cerr << "could not establish connection to DMI adaptor" << ::std::endl;
        
    } // else
  // Bouml preserved body end 000EE382

} // void SetDMIBooleanValue()  




void SetDMIIntegerValue(const char * const pInputName, int iValue)   
{
  // Bouml preserved body begin 000EE402
    QDBusPendingReply<>                   AsyncReply;
    
    
    
    // call init DMI
    InitDMI();
    
    // check, if DMI proxy is available
    if (m_pDMI != nullptr)
    {
        // call method via proxy
        AsyncReply = m_pDMI->SetIntegerValue(pInputName, iValue);

        // wait for asynchronous call to be finished
        AsyncReply.waitForFinished();

        // check, if replay was valid
        if (not AsyncReply.isValid())
        {
            // print error
            ::std::cerr << "error while calling remote method IDMI::SetIntegerValue() -> " << AsyncReply.error().message().toStdString() << ::std::endl;

        } // if (not AsyncReply.isValid())

    } // if (m_pDMI != nullptr)
    else
    {
        // print error
        ::std::cerr << "could not establish connection to DMI adaptor" << ::std::endl;
        
    } // else
  // Bouml preserved body end 000EE402

} // void SetDMIIntegerValue()  




void SetDMIDoubleValue(const char * const pInputName, double dValue)   
{
  // Bouml preserved body begin 000F8902
    QDBusPendingReply<>                   AsyncReply;
    
    
    
    // call init DMI
    InitDMI();
    
    // check, if DMI proxy is available
    if (m_pDMI != nullptr)
    {
        // call method via proxy
        AsyncReply = m_pDMI->SetDoubleValue(pInputName, dValue);

        // wait for asynchronous call to be finished
        AsyncReply.waitForFinished();

        // check, if replay was valid
        if (not AsyncReply.isValid())
        {
            // print error
            ::std::cerr << "error while calling remote method IDMI::SetDoubleValue() -> " << AsyncReply.error().message().toStdString() << ::std::endl;

        } // if (not AsyncReply.isValid())

    } // if (m_pDMI != nullptr)
    else
    {
        // print error
        ::std::cerr << "could not establish connection to DMI adaptor" << ::std::endl;
        
    } // else
  // Bouml preserved body end 000F8902

} // void SetDMIDoubleValue()  




void SetDMIStringValue(const char * const pInputName, const char * const pValue)   
{
  // Bouml preserved body begin 000F8882
    QDBusPendingReply<>                   AsyncReply;
    
    

    
    // call init DMI
    InitDMI();
    
    // check, if DMI proxy is available
    if (m_pDMI != nullptr)
    {
        // call method via proxy
        AsyncReply = m_pDMI->SetStringValue(pInputName, pValue);

        // wait for asynchronous call to be finished
        AsyncReply.waitForFinished();

        // check, if replay was valid
        if (not AsyncReply.isValid())
        {
            // print error
            ::std::cerr << "error while calling remote method IDMI::SetStringValue() -> " << AsyncReply.error().message().toStdString() << ::std::endl;

        } // if (not AsyncReply.isValid())

    } // if (m_pDMI != nullptr)
    else
    {
        // print error
        ::std::cerr << "could not establish connection to DMI adaptor" << ::std::endl;
        
    } // else
  // Bouml preserved body end 000F8882

} // voidSetDMIStringValue()  




void SetNewInputTelegram(char * pTelegram, int iBits)   
{
  // Bouml preserved body begin 000EE302
   ::QBitArray      Telegram(iBits, false);
   int              x(0);
   char*            pByte(pTelegram);
   
   
   // copy telegram bit-wise
   for (x = 0; x < iBits; x++)
   {
       // set current bit from current byte
       Telegram[x] = ((*pByte) & (1 << (x - (pTelegram - pByte) * 8))) == 0 ? false : true;
       
       // check, if 8 bits were copied
       if (x - (pTelegram - pByte) * 8 == 7)
       {
           // increase byte pointer
           pByte++;
            
       } // if (x - (pTelegram - pByte) * 8 == 7)
       
   } // for (x = 0; x < iBits; x++)
   
   
   // set telegram in balise in device object
   m_pBaliseInDevice->SetNewInputTelegram(Telegram);
  // Bouml preserved body end 000EE302

} // void SetNewInputTelegram()  throw() 




void SetNewInputTelegramBinary(const int * const pTelegram, int iBits)   
{
  // Bouml preserved body begin 000FA282
   ::QBitArray      Telegram(iBits, false);
   int              x(0);
   
   
   // DEBUG
   //::std::cout << "SetNewInputTelegramBinary() started: " << ::std::flush;
   
   // copy telegram bit-wise
   for (x = 0; x < iBits; x++)
   {
       // set current bit from current byte
       Telegram[x] = pTelegram[x] == 0 ? false : true;
       
       // DEBUG
       //::std::cout << Telegram[x] << " " << ::std::flush;
       
   } // for (x = 0; x < iBits; x++)
   
   // DEBUG
   //::std::cout << ::std::endl;
   
   // set telegram in balise in device object
   m_pBaliseInDevice->SetNewInputTelegram(Telegram);
  // Bouml preserved body end 000FA282

} // void SetNewInputTelegramBinary()  




void EvaluateDMIInputs(int * pDMIType)   
{
  // Bouml preserved body begin 000EAC02
  const char* const           TRAIN_DATA_SUB_STRINGS[] = {"Driver ID"};
  const char* const           LEVEL_TRANSITION_SUB_STRINGS[] = {"Level Transition"};
  const char* const           MODE_TRANSITION_SUB_STRINGS[] = {"Mode Transition"};
  const char* const                       TRIP_ACKNOWLEDGE_SUB_STRINGS[] = {"Acknowledge Trip"};
    static ::QStringList                    LastInputs(0);
    static decltype (LastInputs.begin())    lp;
    ::QStringList                           CurrentInputs;
    ::QDBusPendingReply< ::QStringList >    AsyncReply;
    ::QString                               CurrentInput;
    unsigned int              x(0);


    #ifdef __OETCS_DF_SIM_DEBUG_OUTPUT__
    // DEBUG
    ::std::cerr << "DEBUG: started EvaluateDMIInputs() " << ::std::endl;
    #endif
    
    // call init DMI
    InitDMI();

    // check, if DMI proxy is available
    if (m_pDMI != nullptr)
    {
        // get HasInput via proxy
        AsyncReply = m_pDMI->GetInputs();

        // wait for asynchronous call to be finished
        AsyncReply.waitForFinished();

        // check, if replay was valid
        if (not AsyncReply.isValid())
        {
            // print error
            ::std::cerr << "error while calling remote method IDMI::GetInputs() ->" << AsyncReply.error().message().toStdString() << ::std::endl;
            
            // set DMI type to optional data
            *pDMIType = 4;

        } // if (not AsyncReply.isValid())
        else
        {
            // get new inputs from reply
            CurrentInputs = AsyncReply.value();
            
            #ifdef __OETCS_DF_SIM_DEBUG_OUTPUT__
            // DEBUG
            ::std::cerr << "DEBUG: EvaluateDMIInputs() Current Inputs: " << ::std::flush;
            for (decltype (CurrentInputs.begin()) y = CurrentInputs.begin(); y != CurrentInputs.end(); y++)
            {
                ::std::cerr << "\"" << (*y).toStdString() << "\", ";
                
            } // for (decltype (CurrentInputs.begin()) y = CurrentInputs.begin(); y != CurrentInputs.end(); y++)
            ::std::cerr << ::std::endl;
            #endif

            // compare current list with last
            if (not LastInputs.empty() && not CurrentInputs.empty() && CurrentInputs == LastInputs)
            {
                // check, if iterator already reached end of list
                if (lp != LastInputs.end())
                {
                    // get current input
                    CurrentInput = *lp;
                
                    // increase iterator
                    lp++;
                    
                } // if (lp != LastInputs.end())

            } // if if (not LastInputs.empty() && not CurrentInputs.empty() && CurrentInputs == LastInputs)
            else
            {
                // set last inputs to new list
                LastInputs = CurrentInputs;

                // check, if inputs are not empty
                if (not LastInputs.empty())
                {
                    // get current input
                    CurrentInput = LastInputs[0];
                    
                    // set iterator to next element
                    lp = LastInputs.begin() + 1;

                } // if (not LastInputs.empty()
                
            } // else
            
            
            // initialise DMI type
            *pDMIType = -1;
            
            // check, if current string is non-empty
            if (CurrentInput.size() != 0)
            {   
                #ifdef __OETCS_DF_SIM_DEBUG_OUTPUT__
                // DEBUG
                ::std::cout << "DEBUG: EvaluateDMIInputs() -> current evaluated input is \"" << CurrentInput.toStdString() << "\"" << ::std::endl;
                #endif


                // check, current input is train data
                for (x = 0; x < 1 && *pDMIType == -1; x++)
                {
                    // check, if current input matches current sub string
                    if (CurrentInput.toStdString().find(TRAIN_DATA_SUB_STRINGS[x]) != ::std::string::npos)
                    {
                        // set DMI type to 0
                        *pDMIType = 0;

                    } // if (CurrentInput.toStdString().find(*TRAIN_DATA_SUB_STRINGS[x]) != ::std::string::npos)

                } // for (x = 0; x < sizeof (TRAIN_DATA_SUB_STRINGS) && *pDMIType == -1; x++)


                // check, current input is level transition
                for (x = 0; x < 1 && *pDMIType == -1; x++)
                {
                    // check, if current input matches current sub string
                    if (CurrentInput.toStdString().find(LEVEL_TRANSITION_SUB_STRINGS[x]) != ::std::string::npos)
                    {
                        // set DMI type to 0
                        *pDMIType = 1;

                    } // if (CurrentInput.toStdString().find(*LEVEL_TRANSITION_SUB_STRINGS[x]) != ::std::string::npos)

                } // for (x = 0; x < sizeof (LEVEL_TRANSITION_SUB_STRINGS) && *pDMIType == -1; x++)


                // check, current input is mode transition
                for (x = 0; x < 1 && *pDMIType == -1; x++)
                {
                    // check, if current input matches current sub string
                    if (CurrentInput.toStdString().find(MODE_TRANSITION_SUB_STRINGS[x]) != ::std::string::npos)
                    {
                        // set DMI type to 0
                        *pDMIType = 2;

                    } // if (CurrentInput.toStdString().find(*MODE_TRANSITION_SUB_STRINGS[x]) != ::std::string::npos)

                } // for (x = 0; x < sizeof (MODE_TRANSITION_SUB_STRINGS) && *pDMIType == -1; x++)
                
                
                // check, current input is trip acknowledgement 
                for (x = 0; x < 1 && *pDMIType == -1; x++)
                {
                    // check, if current input matches current sub string
                    if (CurrentInput.toStdString().find(TRIP_ACKNOWLEDGE_SUB_STRINGS[x]) != ::std::string::npos)
                    {
                        // set DMI type to 0
                        *pDMIType = 3;

                    } // if (CurrentInput.toStdString().find(TRIP_ACKNOWLEDGE_SUB_STRINGS[x]) != ::std::string::npos)

                } // for (x = 0; x < sizeof (MODE_TRANSITION_SUB_STRINGS) && *pDMIType == -1; x++)

            } // if (CurrentInput.size() != 0)

            // set DMI type to other/optional if still is invalid
            *pDMIType = (*pDMIType == -1 ? 4 : *pDMIType);

        } // else

    } // if (m_pDMI != nullptr)
    else
    {
        // print error
        ::std::cerr << "could not establish connection to DMI adaptor" << ::std::endl;
        
        // set DMI type to optional data
        *pDMIType = 4;

    } // else
    
    #ifdef __OETCS_DF_SIM_DEBUG_OUTPUT__
    // DEBUG
    ::std::cout << "DEBUG: EvaluateDMIInputs() -> evaluated type is " << *pDMIType << ::std::endl;
    #endif
  // Bouml preserved body end 000EAC02

} // void WrapperFunctions::EvaluateDMIInputs()  throw() 




double GetVelocity()   
{
  // Bouml preserved body begin 000EC582
    // return velocity of odometer object
    return (m_pOdometer->GetVelocity());
  // Bouml preserved body end 000EC582

} // double WrapperFunctions::GetVelocity()  throw() 




void SetVelocity(double dVelocity)   
{
  // Bouml preserved body begin 000EC602
    // set velocity in odomezer object
    m_pOdometer->SetVelocity(dVelocity);
  // Bouml preserved body end 000EC602

} // void WrapperFunctions::SetVelocity()  throw() 




void ResetPosition(double dPosition)   
{
  // Bouml preserved body begin 000EC682
    // set position in odometer object
    m_pOdometer->ResetPosition((dPosition));
  // Bouml preserved body end 000EC682

} // void WrapperFunctions::ResetPosition()  throw() 




double GetPosition()   
{
  // Bouml preserved body begin 000FBC02
    // return position of odometer object
    return (m_pOdometer->GetAbsolutePosition());
  // Bouml preserved body end 000FBC02

} // double WrapperFunctions::GetPosition()  throw() 




void SetServiceIntensity(double dIntensity)   
{
  // Bouml preserved body begin 000EE002
    // set intensity in service brake object
    m_pServiceBrake->SetIntensity(dIntensity);
  // Bouml preserved body end 000EE002

} // void WrapperFunctions::SetServiceIntensity()  throw() 




double GetServiceIntensity()   
{
  // Bouml preserved body begin 000EE082
    // return service brake intensity from object
    return (m_pServiceBrake->GetIntensity());
  // Bouml preserved body end 000EE082

} // double WrapperFunctions::GetServiceIntensity()  throw() 




void SetMass(double dMass)   
{
  // Bouml preserved body begin 000EE102
    // set train mass in service brake object
    m_pServiceBrake->SetMass(dMass);
  // Bouml preserved body end 000EE102

} // void WrapperFunctions::SetMass()  throw() 




void SetAdhesion(double dAdhesion)   
{
  // Bouml preserved body begin 000EE182
    // set adhesion factor in service brake object
    m_pServiceBrake->SetAdhesion(dAdhesion);
  // Bouml preserved body end 000EE182

} // void WrapperFunctions::SetAdhesion()  throw() 




void SetEmergencyActivation(int iActication)   
{
  // Bouml preserved body begin 000EE202
    // set activation in emergency brake object
    m_pEmergencyBrake->SetActivation(iActication == 0 ? false : true);
  // Bouml preserved body end 000EE202

} // void SetEmergencyActivation()  




int GetEmergencyActivation()   
{
  // Bouml preserved body begin 000EE282
    // return activation from emergency brake object
    return (m_pEmergencyBrake->GetActivation() == 0 ? false : true);
  // Bouml preserved body end 000EE282

} // int GetEmergencyActivation()