DriverMachineInterfaceMOC.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 driver machine classes for observer usage
 */

#ifndef __OETCS_DF_DRIVERMACHINEINTERFACEMOC_H__
#define __OETCS_DF_DRIVERMACHINEINTERFACEMOC_H__



#include <QtGui>
#include <iostream>
#include "oETCS/DF/PS/SIM/DMIAdaptor.h"

#include <QWidget>
#include <vector>
#include <QString>
#include <QStringList>
#include <QGridLayout>
#include <QLabel>
#include <QPushButton>
#include <QMutex>
#include "EVCStateMachine.h"
#include "FunctionBlocks.h"




namespace oETCS { namespace DF { class CEVCStateMachine; }  } 
namespace oETCS { namespace DF { struct CDMISubject; }  } 


namespace oETCS {

namespace DF {


/*!
 *  \brief Driver Machine Interface Qt4 class
 *
 *  Observer implementation as Qt4 QWidget.
 */
class CDMIQWidget : public ::QWidget, public oETCS::DF::CDMIObserver 
{
  Q_OBJECT
  public:
    /*!
     *  \brief general constructor
     *
     *  Attaches the concrete Qt4 observer to a EVC state machine object.
     *
     *  \param[in] pStateMachine pointer to the related state machine
     *  \param[in] pWidgetParent optional pointer to the parent QWidget object
     *  \param[in] bSimAdaptor optional flag to actiavate instance as D-Bus adaptor for simulation
     */
    explicit CDMIQWidget(oETCS::DF::CEVCStateMachine * const pStateMachine, QWidget * pWidgetParent = 0, const bool & bSimAdaptor = false) throw();
    
    

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

    /*!
     *  \brief updates the observer representation
     */
    virtual void Update() throw();
    
    

    /*!
     *  \brief notifies an observer about it was detached by the EVC state machine
     * 
     *  In the implementation for the Qt observer this cause a closing of the QWidget.
     */
    virtual void Detached() throw();
    
    

    /*!
     *  \brief checks, if an element is part of an vector
     *
     *  \param[in] Element element to be searched in container
     *  \param[in] Container container to be searched in
     *
     *  \return true, if element is found
     */    
     template< class ELEMENT_T, class CONTAINER_T = ::std::vector< ELEMENT_T > >
     static inline bool IsPartOf(const ELEMENT_T& Element, const CONTAINER_T& Container) throw();
    
    


  Q_SIGNALS:
    /*!
     *  \brief signal emited, if a Update() message from the EVC state machine was received
     */
    void Updated();
    
    

    /*!
     *  \brief signal for sending an error
     *
     *  This signal should be emitted in the case that an error in the HW ocurres.
     *
     *  \param[in] ErrorMessage textual description of the error
     */
    void Error(const ::QString& ErrorMessage);
    
    


  public Q_SLOTS:
    /*!
     *  \brief slot for notification about entered data
     */
    void DataEntered() throw();
    
    

    /*!
     *  \brief slot after a Update() message from the EVC State Machine
     *
     *  \remark connected with the Updated() signal due to multi threading 
     */
    virtual void UpdateSlot() throw();
    
    

    /*!
     *  \brief gets all active inputs
     *
     *  \return list of active/enabled inputs
     */
    QStringList GetInputs();
    
    

    /*!
     *  \brief gets all available ouputs
     *
     *  \return list of all all outputs
     */
    ::QStringList GetOutputs();
    
    

    /*!
     *  \brief gets a value of a certain output
     *
     *  \param[in] OutputName name of the output field
     *
     *  \return output value
     */
    QString GetOutputValue(const QString & OutputName);
    
    

    /*!
     *  \brief gets the flag for the existence of any input field
     *
     *  \return true, if any input field exists
     */
    bool HasInput();
    
    

    /*!
     *  \brief sets a value of an boolean input field
     *
     *  \param[in] InputName name of the input field
     *  \param[in] bValue new value
     */
    void SetBooleanValue(const QString & InputName, bool bValue);
    
    

    /*!
     *  \brief sets a value of an double input field
     *
     *  \param[in] InputName name of the input field
     *  \param[in] dValue new value
     */
    void SetDoubleValue(const QString & InputName, double dValue);
    
    

    /*!
     *  \brief sets a value of an integer input field
     *
     *  \param[in] InputName name of the input field
     *  \param[in] iValue new value
     */
    void SetIntegerValue(const QString & InputName, int iValue);
    
    

    /*!
     *  \brief sets a value of an string input field
     *
     *  \param[in] InputName name of the input field
     *  \param[in] Value new value
     */
    void SetStringValue(const QString & InputName, const QString & Value);
    
    


  private:
    /*!
     *  \brief pointer to the DMI adaptor object (used for simulation only)
     */
    ::ADMI* m_pAdaptor;
    
    

    /*!
     *  \brief layout object of the Dialog
     */
    ::QGridLayout m_Layout;
    
    

    /*!
     *  \brief vector with pointers to labels used for inputs and outputs in grid layout
     */
    ::std::vector< ::QLabel* > m_Labels;
    
    

    /*!
     *  \brief vector with pointers to all input widgets
     */
    ::std::vector< ::QWidget* > m_InputWidgets;
    
    

    /*!
     *  \brief vector with pointers to all output widgets
     */
    ::std::vector< ::QWidget* > m_OutputWidgets;
    
    

    /*!
     *  \brief poniter to the last subject used in Update().
     */
    oETCS::DF::CDMISubject* m_pLastSubject;
    
    

    /*!
     *  \brief vector of pointer to all push buttons to submit entered data by the driver
     */
    ::std::vector< ::QPushButton* > m_InputButtons;
    
    

    /*!
     *  \brief mutable exclusion for setting DMI values while subject changes
     */
    ::QMutex m_Mutex;
    
    


}; // class CDMIQWidget : public ::QWidget, public oETCS::DF::CDMIObserver

template< class ELEMENT_T, class CONTAINER_T >
bool CDMIQWidget::IsPartOf(const ELEMENT_T& Element, const CONTAINER_T& Container)  throw()
{
  // Bouml preserved body begin 000CF302
        bool                                     bFound(false);
        decltype (Container.begin())             x;
                
        
        // check, if container is empty
        if (Container.empty())
        {
            // empty container means all values allowed
            bFound = true;
            
        } // if (Container.empty())
        else
        {
            // process all container elements
            for (x = Container.begin(); x != Container.end() && not bFound; x++)
            {
                // check, if current element is searched one
                bFound = (*x == Element);

            } // for (x = Container.begin(); x != Container.end() && not bFound; x++)

        } // else
        
        // return found flag
        return (bFound);
  // Bouml preserved body end 000CF302

} // bool CDMIQWidget::IsPartOf()  throw()









} // namespace oETCS::DF

} // namespace oETCS

#endif // __ OETCS_DF_DRIVERMACHINEINTERFACEMOC_H__