CoupledCliController.h

Go to the documentation of this file.

#ifndef COUPLED_CLI_CONTROLLER_H_
#define COUPLED_CLI_CONTROLLER_H_
/*
 * Copyright 2011-2016 Universiteit Antwerpen
 *
 * Licensed under the EUPL, Version 1.1 or  as soon they will be approved by
 * the European Commission - subsequent versions of the EUPL (the "Licence");
 * You may not use this work except in compliance with the Licence.
 * You may obtain a copy of the Licence at: http://ec.europa.eu/idabc/eupl5
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the Licence is distributed on an "AS IS" basis,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the Licence for the specific language governing
 * permissions and limitations under the Licence.
 */
#include "CliSimulationTask.h"

#include "../../cpp_sim/util/clock_man/Timeable.h"
#include "adapt2rfp/adapt2rfp.h"
#include "session/ISession.h"
#include <QObject>
#include <chrono>
#include <memory>
#include <string>

namespace SimPT_Shell {

namespace Session {
        class SimSessionCoupled;
}

namespace Ws {
        class CliWorkspace;
}

class CoupledCliController : public QObject, public SimPT_Sim::ClockMan::Timeable<>
{
        Q_OBJECT
public:
        virtual ~CoupledCliController();

        static std::shared_ptr<CoupledCliController> Create(const std::string& workspace, bool quiet);

        int Execute(CliSimulationTask task);

        Timings GetTimings() const;

        void Terminate();

signals:
        void TerminationRequested();

private:
        CoupledCliController(std::shared_ptr<Ws::CliWorkspace> workspace_model, bool quiet);

        bool IsQuiet() const;

        std::shared_ptr<Session::SimSessionCoupled> OpenProject(const std::string& project_name, const std::string& file_name);

        int SimulatorRun(CliSimulationTask task);

        void SigIntHandler(int sig);

#if (QT_VERSION >= QT_VERSION_CHECK(5,0,0))
        void SigQtHandler(QtMsgType type, const QMessageLogContext&, const QString&);
#else
        void SigQtHandler(QtMsgType type, const char* msg);
#endif

        static void UserError(const std::string& msg);

        static void UserMessage(const std::string& msg);

private:
        typedef SimShell::Session::ISession::InfoMessageReason InfoMessageReason; // Because of Qt wanting to match parameter types of signals and slots by string comparison

private slots:
        void SimulationInfo(const std::string &message, const InfoMessageReason &reason);

        void SimulationError(const std::string &error);

private:
        typedef void (SigIntHandlerType)(int);

        typedef UA_CoMP_Adapt2rfp::Adaptor<SigIntHandlerType> SigIntAdaptorType;

#if (QT_VERSION >= QT_VERSION_CHECK(5,0,0))
        typedef void (SigQtHandlerType)(QtMsgType, const QMessageLogContext&, const QString&);
#else
        typedef void (SigQtHandlerType)(QtMsgType, const char*);
#endif

        typedef UA_CoMP_Adapt2rfp::Adaptor<SigQtHandlerType> SigQtAdaptorType;

private:
        std::shared_ptr<Ws::CliWorkspace> m_workspace_model;

        bool m_quiet;

        SigIntAdaptorType  m_sig_int_adaptor;

        SigQtAdaptorType  m_sig_qt_adaptor;

        Timings  m_timings;
};

} // namespace

#endif // end_of_include_guard