PlatformSpecificClientsMOC.h

Go to the documentation of this file.

/*
    Copyright (C) 2010-2012
    Johannes Feuser <feuser@uni-bremen.de>
    This file is part of the openETCS library.

    The openETCS library is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    any later version.

    The openETCS library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with the openETCS library.  If not, see <http://www.gnu.org/licenses/>.
*/

/*!
 *  \author Johannes Feuser <feuser@uni-bremen.de>
 *  \brief classes (for HW devices) for accessing HW elements through D-Bus interfaces needing the meta object compiler (moc)
 */

#ifndef __OETCS_DF_PLATFORMSPECIFICCLIENTSMOC_H__
#define __OETCS_DF_PLATFORMSPECIFICCLIENTSMOC_H__


#include <iostream>

#include <vector>
#include "Error/ExceptionTypes.h"
#include <string>
#include <QBitArray>
#include "oETCS/DF/BaliseDeviceInInterface.h"
#include <mutex>
#include <QObject>
#include "oETCS/DF/BaliseDeviceOutInterface.h"
#include "EVCStateMachine.h"
#include "oETCS/DF/EmergencyBrakeInterface.h"
#include "oETCS/DF/OdometerInterface.h"
#include "oETCS/DF/ServiceBrakeInterface.h"




namespace oETCS { namespace DF { class CTelegram; }  } 
namespace oETCS { namespace DF { class CEVCStateMachine; }  } 


namespace oETCS {

namespace DF {


/*!
 *  \brief base class for all balise devices for incomming messages
 */
class CBaliseDeviceIn : public ::QObject 
{
  Q_OBJECT
  public:
    /*!
     *  \brief general constructor
     * 
     *  Parameterises the the communication incoming device with all constant members.
     *
     *  \param[in] Telegrams vector with pointers to all telegrams supported
     *  \param[in] bUsePS optional flag for the usage of the platform specifc implementation via D-Bus
     */
    explicit CBaliseDeviceIn(const ::std::vector< oETCS::DF::CTelegram * >& Telegrams, const bool& bUsePS = false) throw();
    
    

    /*!
     *  \brief deleted copy constructor
     */
    CBaliseDeviceIn(const CBaliseDeviceIn& Source) = delete;
    
    

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

    /*!
     *  \brief deleted assignment operator
     */
    CBaliseDeviceIn& operator=(const CBaliseDeviceIn & Source) = delete;
    
    

    /*!
     *  \brief gets flag for a new telegram
     *
     *  Starts the evaluation of a new telegram, if a new teleragm is available.
     *  
     *  \return non empty vector of received packet IDs, in case of a new telegram
     */
    ::std::vector< unsigned char > HasNewTelegram() throw(::oETCS::DF::Error::CException);
    
    

    /*!
     *  \brief clears all bit arrays
     */
    void Clear() throw();
    
    


  public slots:
    /*!
     *  \brief informs the stub about a new telegram available
     *
     *  \remark this method should be called by a platform specific implementation
     *
     *  \param[in] Bytes   array of bytes of the new telegram
     *  \param[in] iBits   number of bits only used from the beginning in the byte array
     */
    void NewTelegramReceived(const QByteArray & Bytes, int iBits);
    
    

    /*!
     *  \brief informs the stub about an error ocurred in the PS part
     *
     *  \remark this method should be called by a platform specific implementation
     *
     *  \param[in] ErrorMessage textual description of the error
     */
    void Error(const QString& ErrorMessage);
    
    


  public:
    /*!
     *  \brief flag for the usage of a platform specific implmentation via D-Bus
     */
    const bool m_bUsePlatformSpecific;
    
    


  private:
    /*!
     *  \brief stack with error messages from the platform specific adaptor implementation
     */
    ::std::vector< ::std::string > m_ErrorStack;
    
    

    /*!
     *  \brief locally stored bit arrays
     */
    ::std::vector< ::QBitArray > m_BitArrays;
    
    

    /*!
     *  \brief vector with pointers of all connected telegrams
     */
    const ::std::vector< oETCS::DF::CTelegram* > m_Telegrams;
    
    

    /*!
     *  \brief pointer to the proxy object
     */
    oETCS::DF::IBaliseDeviceIn* m_pProxy;
    
    

    /*!
     *  \brief muteable exclusion object
     */
    ::std::recursive_mutex m_Mutex;
    
    


}; // class CBaliseDeviceIn : public ::QObject



/*!
 *  \brief base class for all balise devices for outgoing messages
 */
class CBaliseDeviceOut : public ::QObject 
{
  Q_OBJECT
  public:
    /*!
     *  \brief general constructor
     * 
     *  Parameterises the the communication incoming device with all constant members.
     *
     *  \param[in] Telegrams vector with pointers to all telegrams supported
     *  \param[in] bUsePS optional flag for the usage of the platform specifc implementation via D-Bus
     */
    explicit CBaliseDeviceOut(const ::std::vector< oETCS::DF::CTelegram * >& Telegrams, const bool& bUsePS = false) throw();
    
    

    /*!
     *  \brief deleted copy constructor
     */
    CBaliseDeviceOut(const CBaliseDeviceOut& Source) = delete;
    
    

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

    /*!
     *  \brief executes the sending of corresponding telegram
     *
     *  \remark this method should be reimplemented by any inheriting class
     */
    virtual void SendTelegram() throw(::oETCS::DF::Error::CException);
    
    

    /*!
     *  \brief deleted assigment operator
     */
    CBaliseDeviceOut& operator=(const CBaliseDeviceOut& Source) = delete;
    
    


  public slots:
    /*!
     *  \brief informs the stub about an error ocurred in the PS part
     *
     *  \remark this method should be called by a platform specific implementation
     *
     *  \param[in] ErrorMessage textual description of the error
     */
    void Error(const QString& ErrorMessage);
    
    


  public:
    /*!
     *  \brief flag for the usage of a platform specific implmentation via D-Bus
     */
    const bool m_bUsePlatformSpecific;
    
    


  private:
    /*!
     *  \brief stack with error messages from the platform specific adaptor implementation
     */
    ::std::vector< ::std::string > m_ErrorStack;
    
    

    /*!
     *  \brief vector with pointers to all connected telegrams
     */
    const ::std::vector< oETCS::DF::CTelegram* > m_Telegrams;
    
    

    /*!
     *  \brief pointer to the proxy object
     */
    oETCS::DF::IBaliseDeviceOut* m_pProxy;
    
    

    /*!
     *  \brief muteable exclusion object
     */
    ::std::recursive_mutex m_Mutex;
    
    


}; // class CBaliseDeviceOut : public ::QObject



/*!
 *  \brief super class for ememgerncy brake implementations
 */
class CEmergencyBrake : public ::QObject, public oETCS::DF::CFunctionBlock 
{
  Q_OBJECT
  public:
    /*!
     *  \brief general constructor
     *
     *  \param[in] pStateMachine pointer to the parent EVC state machine object
     *  \param[in] bUsePS optional flag for the usage of the platform specifc implementation via D-Bus
     */
    explicit CEmergencyBrake(oETCS::DF::CEVCStateMachine * pStateMachine, const bool & bUsePS = false) throw();
    
    

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

    /*!
     *  \brief method for computing all outputs
     *
     *  \remark must be (re)implemented for all emergency brake implementations
     */
    virtual void Calculate() throw(::oETCS::DF::Error::CException);
    
    


  public slots:
    /*!
     *  \brief informs the stub about an error ocurred in the PS part
     *
     *  \remark this method should be called by a platform specific implementation
     *
     *  \param[in] ErrorMessage textual description of the error
     */
    void Error(const QString& ErrorMessage);
    
    


  public:
    /*!
     *  \brief storage of the activation flag
     */
    oETCS::DF::BOOL_INPUT_T m_bActivation;
    
    

    /*!
     *  \brief flag for the usage of a platform specific implmentation via D-Bus
     */
    const bool m_bUsePlatformSpecific;
    
    


  private:
    /*!
     *  \brief stack with error messages from the platform specific adaptor implementation
     */
    ::std::vector< ::std::string > m_ErrorStack;
    
    

    oETCS::DF::IEmergencyBrake* m_pProxy;
    
    

    /*!
     *  \brief muteable exclusion object
     */
    ::std::recursive_mutex m_Mutex;
    
    


}; // class CEmergencyBrake : public ::QObject, public oETCS::DF::CFunctionBlock



/*!
 *  \brief super class for odometer implementations
 */
class COdometer : public ::QObject, public oETCS::DF::CFunctionBlock 
{
  Q_OBJECT
  public:
    /*!
     *  \brief default/general constructor
     *
     *  \param[in] pStateMachine pointer to the parent EVC state machine object
     *  \param[in] bUsePS optional flag for the usage of the platform specifc implementation via D-Bus
     */
    COdometer(oETCS::DF::CEVCStateMachine * const pStateMachine, const bool& bUsePS = false) throw();
    
    

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

    /*!
     *  \brief method for computing all outputs
     *
     *  \remark must be implemented for all odometer implementations
     */
    virtual void Calculate() throw(::oETCS::DF::Error::CException);
    
    


  public slots:
    /*!
     *  \brief informs the stub about an error ocurred in the PS part
     *
     *  \remark this method should be called by a platform specific implementation
     *
     *  \param[in] ErrorMessage textual description of the error
     */
    void Error(const QString& ErrorMessage);
    
    


  public:
    /*!
     *  \brief pointers to storage of the absolute position
     */
    ::std::vector< oETCS::DF::DOUBLE_OUTPUT_T > m_AbsolutePosition;
    
    

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

    /*!
     *  \brief flag for the usage of a platform specific implmentation via D-Bus
     */
    const bool m_bUsePlatformSpecific;
    
    


  private:
    /*!
     *  \brief stack with error messages from the platform specific adaptor implementation
     */
    ::std::vector< ::std::string > m_ErrorStack;
    
    

    /*!
     *  \brief pointer to the proxy object
     */
    oETCS::DF::IOdometer* m_pProxy;
    
    

    /*!
     *  \brief muteable exclusion object
     */
    ::std::recursive_mutex m_Mutex;
    
    


}; // class COdometer : public ::QObject, public oETCS::DF::CFunctionBlock



/*!
 *  \brief super class for service brake implementations
 */
class CServiceBrake : public ::QObject, public oETCS::DF::CFunctionBlock 
{
  Q_OBJECT
  public:
    /*!
     *  \brief general constructor
     *
     *  \param[in] pStateMachine pointer to the parent EVC state machine object
     *  \param[in] bUsePS optional flag for the usage of the platform specifc implementation via D-Bus
     */
    explicit CServiceBrake(oETCS::DF::CEVCStateMachine * const pStateMachine, const bool& bUsePS = false) throw();
    
    

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

    /*!
     *  \brief method for computing all outputs
     *
     *  \remark must be implemented for all service brake implementations
     */
    virtual void Calculate() throw(::oETCS::DF::Error::CException);
    
    


  public slots:
    /*!
     *  \brief informs the stub about an error ocurred in the PS part
     *
     *  \remark this method should be called by a platform specific implementation
     *
     *  \param[in] ErrorMessage textual description of the error
     */
    void Error(const QString& ErrorMessage);
    
    


  public:
    /*!
     *  \brief storage of the brake intensity value
     */
    oETCS::DF::DOUBLE_INPUT_T m_dBrakeIntensity;
    
    

    /*!
     *  \brief flag for the usage of a platform specific implmentation via D-Bus
     */
    const bool m_bUsePlatformSpecific;
    
    


  private:
    /*!
     *  \brief stack with error messages from the platform specific adaptor implementation
     */
    ::std::vector< ::std::string > m_ErrorStack;
    
    

    /*!
     *  \brief pointer to the proxy object
     */
    oETCS::DF::IServiceBrake* m_pProxy;
    
    

    /*!
     *  \brief muteable exclusion object
     */
    ::std::recursive_mutex m_Mutex;
    
    


}; // class CServiceBrake : public ::QObject, public oETCS::DF::CFunctionBlock





} // namespace oETCS::DF

} // namespace oETCS

#endif // __ OETCS_DF_PLATFORMSPECIFICCLIENTSMOC_H__