PlatformSpecificClientsMOC.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 classes (for HW devices) for accessing HW elements through D-Bus interfaces needing the meta object compiler (moc)
 */

#include "PlatformSpecificClientsMOC.h"
#include "Language.h"
#include <QByteArray>
#include <QString>
#include "EVCStateMachine.h"




namespace oETCS {

namespace DF {


CBaliseDeviceIn::CBaliseDeviceIn(const ::std::vector< oETCS::DF::CTelegram * >& Telegrams, const bool& bUsePS)  throw()  
:m_bUsePlatformSpecific(bUsePS),
 m_ErrorStack(0),
 m_BitArrays(0),
 m_Telegrams(Telegrams),
 m_pProxy(0)
{
  // Bouml preserved body begin 00068982
    bool        bConnected(true);
    
    
    
    // check, if platform specific implementation should be used
    if (m_bUsePlatformSpecific)
    {
        try
        {
            // create new interface proxy
            m_pProxy = new ::oETCS::DF::IBaliseDeviceIn(::oETCS::DF::IBaliseDeviceIn::staticInterfaceName(), "/oETCS/BaliseDeviceIn", QDBusConnection::sessionBus());

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

                // delete proxy
                delete m_pProxy;

                // reset proxy pointer 
                m_pProxy = nullptr;

            } // if (not m_pProxy->isValid())
            else
            {
                // connect signals with local slots
                bConnected &= QObject::connect(m_pProxy, SIGNAL(NewTelegram(const QByteArray &, int)), this, SLOT(NewTelegramReceived(const QByteArray &, int)));
                bConnected &= QObject::connect(m_pProxy, SIGNAL(Error(const QString &)), this, SLOT(Error(const QString&)));

                // check, if all signals and slots were connected successfully
                if (! bConnected)
                {
                    // print error to stderr
                    ::std::cerr << "::oETCS::DF::CBaliseDeviceIn could not connect all signal and slots" << ::std::endl;
                    
                } // if (! bConnected)
            
            } // else

        } // try
        catch (const ::std::bad_alloc& Exception)
        {
            // no error handling possible in constructor

        } // catch (const ::std::bad_alloc& Exception)
        
    } // if (m_bUsePlatformSpecific)
  // Bouml preserved body end 00068982

} //  CBaliseDeviceIn::CBaliseDeviceIn()  throw() 




CBaliseDeviceIn::~CBaliseDeviceIn()  throw()  
{
  // Bouml preserved body begin 00068A02
    // check, if platform specific implementation was used
     if (m_bUsePlatformSpecific && m_pProxy != 0)
     {
         // delete proxy
         delete m_pProxy;

     } // if (m_bUsePlatformSpecific && m_pProxy != 0)
  // Bouml preserved body end 00068A02

} // CBaliseDeviceIn::~CBaliseDeviceIn()  throw() 




::std::vector< unsigned char > CBaliseDeviceIn::HasNewTelegram()  throw(::oETCS::DF::Error::CException)  
{
  // Bouml preserved body begin 000D0C82
    decltype (m_BitArrays.begin())      ba;
    decltype (m_Telegrams.begin())      t;
    ::std::vector< bool >               BitVector;
    ::std::string                       ErrorMessage;
    bool                                bNewTelegram(false);
    unsigned int                        iSize(0);
    unsigned int                        x(0);
    ::std::vector< unsigned char >      UsedIDs(0);


    
    // lock mutex
     m_Mutex.lock();
    
    // process all stored bit arrays and remove all processed ones
    for (ba = m_BitArrays.begin(); ba != m_BitArrays.end() && not bNewTelegram; ba = m_BitArrays.erase(ba))
    {
        // get size from current bit arrays
        iSize = (*ba).size();
        
        // resize target bit vector
        BitVector.resize(iSize);
        
        // copy current bit array to bit vector (bit-wise)
        for (x = 0; x < iSize; x++)
        {
            // copy current bit
            BitVector[x] = (*ba)[x];
            
        } // for (x = 0; x < iSize; x++)


        // try to stream current bit vector to all connected telegram
        for (t = m_Telegrams.begin(); t != m_Telegrams.end(); t++)
        {
            #ifdef __OETCS_DF_LANGUAGE_DEBUG_OUTPUT__
            // DEBUG
            ::std::cout << "CBaliseDeviceIn::HasNewTelegram() bits in balise reader: ";
            for (decltype (BitVector.begin()) lb = BitVector.begin(); lb != BitVector.end(); lb++)
            {
                ::std::cout << *lb << "," << ::std::flush;

            } // for (decltype (BitVector.begin()) lb = BitVector.begin(); lb != BitVector.end(); lb++)
            ::std::cout << ::std::endl;
            ::std::cout << "# bits: "<< BitVector.size() << ::std::endl;
            #endif // __OETCS_DF_LANGUAGE_DEBUG_OUTPUT__
             
            
            try
            {
                // try to stream to current telegram
                UsedIDs = *(*t) << BitVector;

                // telegram was accepted, set flag
                bNewTelegram = true;

            } // try
            catch (::oETCS::DF::Error::CInput& Exception)
            {
                // just ignore exception here (are not an error, only telegram does not fit)

            } // catch (::oETCS::DF::Error::CInput& Exception)

        } // for (t = m_Telegrams.begin(); t != m_Telegrams.end(); t++)
        
    } // for (ba = m_BitArrays.begin(); ba != m_BitArrays.end() && not bNewTelegram; ba++)
    
    // unlock mutex
    m_Mutex.unlock();
    
    // return list of IDs
    return (UsedIDs);
  // Bouml preserved body end 000D0C82

} // unsigned char CBaliseDeviceIn::HasNewTelegram()  throw(::oETCS::DF::Error::CException) 




void CBaliseDeviceIn::Clear()  throw()  
{
  // Bouml preserved body begin 000FE302
    // lock mutex
    m_Mutex.lock();

    // clear bit arrays
    m_BitArrays.clear();

    // unlock mutex
    m_Mutex.unlock();
  // Bouml preserved body end 000FE302

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




void CBaliseDeviceIn::NewTelegramReceived(const QByteArray & Bytes, int iBits)   
{
  // Bouml preserved body begin 000ABA02
    ::QBitArray         Bits;
    int                 by(0);
    int                 bi(0);
    const int           BYTES_TO_COPY(iBits / 8 + (iBits % 8 == 0 ? 0 : 1));
    

    
    // check,  if number of bits is not bigger than possibly stored in bytes
    if (BYTES_TO_COPY <= Bytes.size())
    {
        // rezize bits array
        Bits.resize(iBits);
        
        // copy telegram byte-wise
        for (by = 0; by < BYTES_TO_COPY; by++)
        {
            // copy current byte bit-wise
            for (bi = 0; bi < 8 && bi + by * 8 < iBits; bi++)
            {
                // copy current bit
                Bits[bi + by * 8] = (Bytes[by] & (1 << bi)) == 0 ? false : true;
                
            } // for (bi = 0; bi < 8 && bi + by * 8 < iBits; bi++
            
        } // for (by = 0; by < BYTES_TO_COPY; by++)
        
        // lock mutex
        m_Mutex.lock();

        // store new telegram 
        m_BitArrays.push_back(Bits);

        // unlock mutex
        m_Mutex.unlock();

    } // if (BYTES_TO_COPY <= Bytes.size())
  // Bouml preserved body end 000ABA02

} // void CBaliseDeviceIn::NewTelegramReceived()  




void CBaliseDeviceIn::Error(const ::QString& ErrorMessage)   
{
  // Bouml preserved body begin 000D6682
    
    // lock mutex
    m_Mutex.lock();
    
    // store error message on stack
    m_ErrorStack.push_back(ErrorMessage.toStdString());
    
    // unlock mutex
    m_Mutex.unlock();
  // Bouml preserved body end 000D6682

} // void CBaliseDeviceIn::Error()  




CBaliseDeviceOut::CBaliseDeviceOut(const ::std::vector< oETCS::DF::CTelegram * >& Telegrams, const bool& bUsePS)  throw()  
:m_bUsePlatformSpecific(bUsePS),
 m_ErrorStack(0),
 m_Telegrams(Telegrams),
 m_pProxy(0)
{
  // Bouml preserved body begin 0006A502
    // check, if platform specific implementation should be used
    if (m_bUsePlatformSpecific)
    {
        try
        {
            // create new interface proxy
            m_pProxy = new ::oETCS::DF::IBaliseDeviceOut(::oETCS::DF::IBaliseDeviceOut::staticInterfaceName(), "/oETCS/BaliseDeviceOut", QDBusConnection::sessionBus());

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

                // delete proxy
                delete m_pProxy;

                // reset proxy pointer 
                m_pProxy = 0;

            } // if (not m_pProxy->isValid())
            else
            {
                // connect signals with local slots
                QObject::connect(m_pProxy, SIGNAL(Error(const QString &)), this, SLOT(Error(const QString&)));
                
                // set timeout for all calls on interface
                //m_pProxy->setTimeout(10);
                
            } // else

        } // try
        catch (const ::std::bad_alloc& Exception)
        {
            // no error handling possible in constructor

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

    } // if (m_bUsePlatformSpecific)
  // Bouml preserved body end 0006A502

} //  CBaliseDeviceOut::CBaliseDeviceOut()  throw() 




CBaliseDeviceOut::~CBaliseDeviceOut()  throw()  
{
  // Bouml preserved body begin 0006A582
    // check, if platform specific implementation was used
    if (m_bUsePlatformSpecific && m_pProxy != 0)
    {
        // delete proxy
        delete m_pProxy;

    } // if (m_bUsePlatformSpecific && m_pProxy != 0)
  // Bouml preserved body end 0006A582

} // CBaliseDeviceOut::~CBaliseDeviceOut()  throw() 




void CBaliseDeviceOut::SendTelegram()  throw(::oETCS::DF::Error::CException)  
{
  // Bouml preserved body begin 000ABA82
    decltype (m_Telegrams.begin())  t;
    QBitArray                       BitArray;
    QDBusPendingReply<>             AsyncReply;
    ::std::vector< bool >           BitVector;
    ::std::string                   ErrorMessage;
    unsigned int                    iSize(0);
    unsigned int                    x(0);
    
        
        

    // any platform independent implementation can be added below here
    // ...
        
        

    // check, if platform specific implementations should be used
    if (m_bUsePlatformSpecific)
    {
        // lock mutex
        m_Mutex.lock();
        
        // check, if error stack is non-empty
        if (not m_ErrorStack.empty())
        {
            // get error first error message on stack
            ErrorMessage = m_ErrorStack[0];
            
            // remove this message from stack
            m_ErrorStack.erase(m_ErrorStack.begin());
            
            // throw exception
            throw (::oETCS::DF::Error::CInternal(::std::string("error in PS implementation: ") + ErrorMessage));

        } // if (not m_ErrorStack.empty())
        
        // unlock mutex
        m_Mutex.unlock();
        
        // check, if proxy was created and still is valid
        if (m_pProxy != 0 && m_pProxy->isValid())
        {
            // throw exception
            throw (::oETCS::DF::Error::CInternal("no proxy available"));

        } // if (m_pProxy != 0 && m_pProxy->isValid())

        // process all connected telegrams
        for (t = m_Telegrams.begin(); t != m_Telegrams.end(); t++)
        {
            // get bit vector from current telegram
            (**t) >> BitVector;

            // get size of bit vector
            iSize = BitVector.size();

            // resize bit array
            BitArray.resize(iSize);

            // copy bit vector in array (bit-wise)
            for (x = 0; x < iSize; x++)
            {
                // copy current bit
                BitArray[x] = BitVector[x];

            } // for (x = 0; x < iSize; x++)
            
            // send bit array via proxy
            AsyncReply = m_pProxy->SendTelegram(BitArray);

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

            // check, if replay was valid
            if (not AsyncReply.isValid())
            {
                // throw exception
                throw (::oETCS::DF::Error::CInternal("error while calling remote method SendTelegram() -> " + AsyncReply.error().message().toStdString()));

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

        } // for (t = m_Telegrams.begin(); t != m_Telegrams.end(); t++)

    } // if (m_bUsePlatformSpecific)
  // Bouml preserved body end 000ABA82

} // void CBaliseDeviceOut::SendTelegram()  throw(::oETCS::DF::Error::CException) 




void CBaliseDeviceOut::Error(const ::QString& ErrorMessage)   
{
  // Bouml preserved body begin 000D6702
    
    // lock mutex
    m_Mutex.lock();
    
    // store error message on stack
    m_ErrorStack.push_back(ErrorMessage.toStdString());
    
    // unlock mutex
    m_Mutex.unlock();
  // Bouml preserved body end 000D6702

} // void CBaliseDeviceOut::Error()  




CEmergencyBrake::CEmergencyBrake(oETCS::DF::CEVCStateMachine * pStateMachine, const bool& bUsePS)  throw()  
:CFunctionBlock(pStateMachine),
 m_bActivation(false),
 m_bUsePlatformSpecific(bUsePS),
 m_ErrorStack(0),
 m_pProxy(0)
{
  // Bouml preserved body begin 0004E802
    // check, if platform specific implementation should be used
    if (m_bUsePlatformSpecific)
    {
        try
        {
            // create new interface proxy
            m_pProxy = new ::oETCS::DF::IEmergencyBrake(::oETCS::DF::IEmergencyBrake::staticInterfaceName(), "/oETCS/EmergencyBrake", QDBusConnection::sessionBus());

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

                // delete proxy
                delete m_pProxy;

                // reset proxy pointer 
                m_pProxy = 0;

            } // if (not m_pProxy->isValid())
            else
            {
                // connect signals with local slots
                QObject::connect(m_pProxy, SIGNAL(Error(const QString&)), this, SLOT(Error(const QString&)));
                
                // set timeout for all calls on interface
                //m_pProxy->setTimeout(10);
                
            } // else

        } // try
        catch (const ::std::bad_alloc& Exception)
        {
            // no error handling possible in constructor

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

    } // if (m_bUsePlatformSpecific)
  // Bouml preserved body end 0004E802

} //  CEmergencyBrake::CEmergencyBrake()  throw() 




CEmergencyBrake::~CEmergencyBrake()  throw()  
{
  // Bouml preserved body begin 0004E882
    // check, if platform specific implementation was used
    if (m_bUsePlatformSpecific && m_pProxy != 0)
    {
        // delete proxy
        delete m_pProxy;

    } // if (m_bUsePlatformSpecific && m_pProxy != 0)
  // Bouml preserved body end 0004E882

} // CEmergencyBrake::~CEmergencyBrake()  throw() 




void CEmergencyBrake::Calculate()  throw(::oETCS::DF::Error::CException)  
{
  // Bouml preserved body begin 0004E782
    QDBusPendingReply<>                 AsyncReply;
    ::std::string                       ErrorMessage;



    // any platform independent implementation can be added below here
    // ...


    // check, if platform specific implementations should be used
    if (m_bUsePlatformSpecific)
    {
        // lock mutex
        m_Mutex.lock();

        // check, if error stack is non-empty
        if (not m_ErrorStack.empty())
        {
            // get error first error message on stack
            ErrorMessage = m_ErrorStack[0];

            // remove this message from stack
            m_ErrorStack.erase(m_ErrorStack.begin());

            // throw exception
            throw (::oETCS::DF::Error::CInternal(::std::string("error in PS implementation: ") + ErrorMessage));

        } // if (not m_ErrorStack.empty())
        
        // unlock mutex
        m_Mutex.unlock();
        
        // check, if proxy was created and still is valid
        if (m_pProxy == nullptr || not m_pProxy->isValid())
        {
            // throw exception
            throw (::oETCS::DF::Error::CInternal("no proxy available"));

        } // if (m_pProxy == nullptr || not m_pProxy->isValid())

        // set brake intensity via proxy
        AsyncReply = m_pProxy->SetActivation(m_bActivation());

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

        // check, if replay was valid
        if (not AsyncReply.isValid())
        {
            // throw exception
            throw (::oETCS::DF::Error::CInternal("error while calling remote method SetActivation() -> " + AsyncReply.error().message().toStdString()));

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

    } // if (m_bUsePlatformSpecific)
  // Bouml preserved body end 0004E782

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




void CEmergencyBrake::Error(const ::QString& ErrorMessage)   
{
  // Bouml preserved body begin 000D6782
    
    // lock mutex
    m_Mutex.lock();
    
    // store error message on stack
    m_ErrorStack.push_back(ErrorMessage.toStdString());
    
    // unlock mutex
    m_Mutex.unlock();
  // Bouml preserved body end 000D6782

} // void CEmergencyBrake::Error()  




COdometer::COdometer(oETCS::DF::CEVCStateMachine * const pStateMachine, const bool& bUsePS)  throw()  
:CFunctionBlock(pStateMachine),
 m_AbsolutePosition(0),
 m_Velocity(0),
 m_bUsePlatformSpecific(bUsePS),
 m_ErrorStack(0),
 m_pProxy(0)
{
  // Bouml preserved body begin 0004E582
    // check, if platform specific implementation should be used
    if (m_bUsePlatformSpecific)
    {
        try
        {
            // create new interface proxy
            m_pProxy = new ::oETCS::DF::IOdometer(::oETCS::DF::IOdometer::staticInterfaceName(), "/oETCS/Odometer", QDBusConnection::sessionBus());

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

                // delete proxy
                delete m_pProxy;

                // reset proxy pointer 
                m_pProxy = 0;

            } // if (not m_pProxy->isValid())
            else
            {
                // connect signals with local slots
                QObject::connect(m_pProxy, SIGNAL(Error(const QString&)), this, SLOT(Error(const QString&)));

                // set timeout for all calls on interface
                //m_pProxy->setTimeout(10);

            } // else

        } // try
        catch (const ::std::bad_alloc& Exception)
        {
            // no error handling possible in constructor

        } // catch (const ::std::bad_alloc& Exception)
        
    } // if (m_bUsePlatformSpecific)
  // Bouml preserved body end 0004E582

} //  COdometer::COdometer()  throw() 




COdometer::~COdometer()  throw()  
{
  // Bouml preserved body begin 0004E602
    // check, if platform specific implementation was used
    if (m_bUsePlatformSpecific && m_pProxy != 0)
    {
        // delete proxy
        delete m_pProxy;
        
    } // if (m_bUsePlatformSpecific && m_pProxy != 0)
  // Bouml preserved body end 0004E602

} // COdometer::~COdometer()  throw() 




void COdometer::Calculate()  throw(::oETCS::DF::Error::CException)  
{
  // Bouml preserved body begin 0004E502
    double                                      dVelocity(0.0);
    double                                      dAbsolutePosition(0.0);
    QDBusPendingReply<double>                   AsyncReply;
    ::std::string                               ErrorMessage;
    decltype (m_Velocity.begin())               v;
    decltype (m_AbsolutePosition.begin())       p;
    
    
    
    // any platform independent implementation can be added below here
    // ...
    
    
    // check, if platform specific implementations should be used
    if (m_bUsePlatformSpecific)
    {
        // lock mutex
        m_Mutex.lock();

        // check, if error stack is non-empty
        if (not m_ErrorStack.empty())
        {
            // get error first error message on stack
            ErrorMessage = m_ErrorStack[0];

            // remove this message from stack
            m_ErrorStack.erase(m_ErrorStack.begin());

            // throw exception
            throw (::oETCS::DF::Error::CInternal(::std::string("error in PS implementation: ") + ErrorMessage));

        } // if (not m_ErrorStack.empty())
        
        // unlock mutex
        m_Mutex.unlock();
        
        // check, if proxy was created and still is valid
        if (m_pProxy == nullptr || not m_pProxy->isValid())
        {
            // throw exception
            throw (::oETCS::DF::Error::CInternal("no proxy available"));
            
        } // if (m_pProxy == nullptr || not m_pProxy->isValid())
        
        // get velocity via proxy
        AsyncReply = m_pProxy->GetVelocity();
        
        // wait for asynchronous call to be finished
        AsyncReply.waitForFinished();
        
        // check, if replay was valid
        if (not AsyncReply.isValid())
        {
            // throw exception
            throw (::oETCS::DF::Error::CInternal("error while calling remote method GetVelocity() -> " + AsyncReply.error().message().toStdString()));
            
        } // if (not AsyncReply.isValid())
        
        // get velocity from reply
        dVelocity = AsyncReply.value();
        
        
        // get position via proxy
        AsyncReply = m_pProxy->GetAbsolutePosition();

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

        // check, if replay was valid
        if (not AsyncReply.isValid())
        {
            // throw exception
            throw (::oETCS::DF::Error::CInternal("error while calling remote method GetAbsolutePosition()"));

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

        // get position from reply
        dAbsolutePosition = AsyncReply.value();
        
        
        // copy velocity to all outputs
        for (v = m_Velocity.begin(); v != m_Velocity.end(); v++)
        {
            // copy value to current output
            **v = dVelocity;
            
        } // for (v = m_Velocity.begin(); v != m_Velocity.end(); v++)
        
        // copy position to all outputs
        for (p = m_AbsolutePosition.begin(); p != m_AbsolutePosition.end(); p++)
        {
            // copy value to current output
            **p = dAbsolutePosition;

        } // for (p = m_AbsolutePosition.begin(); p != m_AbsolutePosition.end(); p++)
        
    } // if (m_bUsePlatformSpecific)
  // Bouml preserved body end 0004E502

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




void COdometer::Error(const ::QString& ErrorMessage)   
{
  // Bouml preserved body begin 000D6882
    
    // lock mutex
    m_Mutex.lock();
    
    // store error message on stack
    m_ErrorStack.push_back(ErrorMessage.toStdString());
    
    // unlock mutex
    m_Mutex.unlock();
  // Bouml preserved body end 000D6882

} // void COdometer::Error()  




CServiceBrake::CServiceBrake(oETCS::DF::CEVCStateMachine * const pStateMachine, const bool& bUsePS)  throw()  
:CFunctionBlock(pStateMachine),
 m_dBrakeIntensity(0.0),
 m_bUsePlatformSpecific(bUsePS),
 m_ErrorStack(0),
 m_pProxy(0)
{
  // Bouml preserved body begin 0004EA02
    // check, if platform specific implementation should be used
    if (m_bUsePlatformSpecific)
    {
        try
        {
            // create new interface proxy
            m_pProxy = new ::oETCS::DF::IServiceBrake(::oETCS::DF::IServiceBrake::staticInterfaceName(), "/oETCS/ServiceBrake", QDBusConnection::sessionBus());

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

                // delete proxy
                delete m_pProxy;

                // reset proxy pointer 
                m_pProxy = 0;

            } // if (not m_pProxy->isValid())
            else
            {
                // connect signals with local slots
                QObject::connect(m_pProxy, SIGNAL(Error(const QString&)), this, SLOT(Error(const QString&)));


                // set timeout for all calls on interface
                //m_pProxy->setTimeout(10);

            } // else

        } // try
        catch (const ::std::bad_alloc& Exception)
        {
            // no error handling possible in constructor

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

    } // if (m_bUsePlatformSpecific)
  // Bouml preserved body end 0004EA02

} //  CServiceBrake::CServiceBrake()  throw() 




CServiceBrake::~CServiceBrake()  throw()  
{
  // Bouml preserved body begin 0004EA82
    // check, if platform specific implementation was used
    if (m_bUsePlatformSpecific && m_pProxy != 0)
    {
        // delete proxy
        delete m_pProxy;

    } // if (m_bUsePlatformSpecific && m_pProxy != 0)
  // Bouml preserved body end 0004EA82

} // CServiceBrake::~CServiceBrake()  throw() 




void CServiceBrake::Calculate()  throw(::oETCS::DF::Error::CException)  
{
  // Bouml preserved body begin 0004E982
    QDBusPendingReply<>                 AsyncReply;
    ::std::string                       ErrorMessage;
    
    
    
    // any platform independent implementation can be added below here
    // ...
    
    
    // check, if platform specific implementations should be used
    if (m_bUsePlatformSpecific)
    {
        // lock mutex
        m_Mutex.lock();
        
        // check, if error stack is non-empty
        if (not m_ErrorStack.empty())
        {
            // get error first error message on stack
            ErrorMessage = m_ErrorStack[0];

            // remove this message from stack
            m_ErrorStack.erase(m_ErrorStack.begin());

            // throw exception
            throw (::oETCS::DF::Error::CInternal(::std::string("error in PS implementation: ") + ErrorMessage));

        } // if (not m_ErrorStack.empty())
        
        // unlock mutex
        m_Mutex.unlock();
        
        // check, if proxy was created and still is valid
        if (m_pProxy == nullptr || not m_pProxy->isValid())
        {
            // throw exception
            throw (::oETCS::DF::Error::CInternal("no proxy available"));
            
        } // if (m_pProxy == nullptr || not m_pProxy->isValid())
        
        // set brake intensity via proxy
        AsyncReply = m_pProxy->SetIntensity(m_dBrakeIntensity());
        
        // wait for asynchronous call to be finished
        AsyncReply.waitForFinished();

        // check, if replay was valid
        if (not AsyncReply.isValid())
        {
            // throw exception
            throw (::oETCS::DF::Error::CInternal("error while calling remote method SetIntensity() -> " + AsyncReply.error().message().toStdString()));

        } // if (not AsyncReply.isValid())
        
    } // if (m_bUsePlatformSpecific)
  // Bouml preserved body end 0004E982

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




void CServiceBrake::Error(const ::QString& ErrorMessage)   
{
  // Bouml preserved body begin 000D6802
    
    // lock mutex
    m_Mutex.lock();
    
    // store error message on stack
    m_ErrorStack.push_back(ErrorMessage.toStdString());
    
    // unlock mutex
    m_Mutex.unlock();
  // Bouml preserved body end 000D6802

} // void CServiceBrake::Error()  






} // namespace oETCS::DF

} // namespace oETCS