DF/PS/SIM/Main.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/>.
*/


#include <QtCore>
#include <QtDBus>
#include <thread>
#include "Simulation.h"
#include "oETCS/DF/OdometerAdaptor.h"
#include "oETCS/DF/EmergencyBrakeAdaptor.h"
#include "oETCS/DF/ServiceBrakeAdaptor.h"
#include "oETCS/DF/BaliseDeviceInAdaptor.h"
#include "oETCS/DF/BaliseDeviceOutAdaptor.h"




void InputThread(QCoreApplication* pApplication)
{
    char                                        cInput(0);
    
    
    
    // wait for user pressing a key
    ::std::cin.get(&cInput, 1);
    
    // tell application core to terminate
    pApplication->exit(0);
    
} // void InputThread(QCoreApplication* pApplication)




int main(int argc, char* argv[])
{
    int                                         iResult(1);
    bool                                        bConnected(true);
    QCoreApplication                            Application(argc, argv);
    QDBusConnection                             Connection = QDBusConnection::sessionBus();
    ::oETCS::DF::PS::SIM::COdometer             Odometer;
    ::oETCS::DF::PS::SIM::CEmergencyBrake       EmergencyBrake;
    ::oETCS::DF::PS::SIM::CServiceBrake         ServiceBrake(&Odometer, &EmergencyBrake);
    ::oETCS::DF::PS::SIM::CBaliseDeviceIn       BaliseIn;
    ::oETCS::DF::PS::SIM::CBaliseDeviceOut      BaliseOut;
    ::AOdometer*                                pOdometer(nullptr);
    ::AEmergencyBrake*                          pEmergencyBrake(nullptr);
    ::AServiceBrake*                            pServiceBrake(nullptr);
    ::ABaliseDeviceIn*                          pBaliseIn(nullptr);
    ::ABaliseDeviceOut*                         pBaliseOut(nullptr);
    ::std::thread*                              pEvent(nullptr);
    

    
    try
    {
        // create all apdaptor objects
        pOdometer               = new ::AOdometer(&Odometer);
        pEmergencyBrake         = new ::AEmergencyBrake(&EmergencyBrake);
        pServiceBrake           = new ::AServiceBrake(&ServiceBrake);
        pBaliseOut              = new ::ABaliseDeviceOut(&BaliseOut);
        pBaliseIn               = new ::ABaliseDeviceIn(&BaliseIn);
        
        
        // register all adaptors
        bConnected &= Connection.registerService("oETCS.DF.IOdometer");
        bConnected &= Connection.registerObject("/oETCS/Odometer", &Odometer);
        bConnected &= Connection.registerService("oETCS.DF.IEmergencyBrake");
        bConnected &= Connection.registerObject("/oETCS/EmergencyBrake", &EmergencyBrake);
        bConnected &= Connection.registerService("oETCS.DF.IServiceBrake");
        bConnected &= Connection.registerObject("/oETCS/ServiceBrake", &ServiceBrake);
        bConnected &= Connection.registerService("oETCS.DF.IBaliseDeviceIn");
        bConnected &= Connection.registerObject("/oETCS/BaliseDeviceIn", &BaliseIn);
        bConnected &= Connection.registerService("oETCS.DF.IBaliseDeviceOut");
        bConnected &= Connection.registerObject("/oETCS/BaliseDeviceOut", &BaliseOut);
      
        
        // check, if all adaptors where registered successfully
        if (not bConnected)
        {
            // print warning to stderr
            ::std::cerr << "Could not register all adaptors!" << ::std::endl;
            
        } // if (not bConnected)
        
        
        // print status to stdout
        ::std::cout << "Executing adaptor event loop (<ENTER> to abort)..." << ::std::flush;
        
        // create input thread
        pEvent = new ::std::thread(&::InputThread, &Application);
        
        // execute core application and get result after termination
        iResult = Application.exec();
        
        
        // check, if thread is joinable
        if (pEvent->joinable())
        {
            // wait for thread to terminate
            pEvent->join();
            
        } // if (pEvent->joinable())
       
        
        // print status to stdout
        ::std::cout << "terminated" << ::std::endl;
       
    } // try
    catch (const ::std::bad_alloc& Exception)
    {
        // print error to stderr
        ::std::cerr << "Could not allocate all objects!" << Connection.lastError().message().toStdString() << "Aborting..." << ::std::endl;
        
    } // catch (const ::std::bad_alloc& Exception)
    
    // delete all apdaptor objects
    delete pServiceBrake;
    delete pOdometer;
    delete pEmergencyBrake;
    delete pBaliseIn;
    delete pBaliseOut;
    
   
    // return execution result
    return (iResult);
    
} // int main(int argc, char* argv[]) char* argv[])