CliController.h

Go to the documentation of this file.

#ifndef CLI_CONTROLLER_H_
#define 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 "cli/CliConverterTask.h"
#include "CliSimulationTask.h"
#include "adapt2rfp/adapt2rfp.h"
#include "session/SimSession.h"
#include "util/clock_man/Timeable.h"
#include "workspace/CliWorkspace.h"

#include <QMessageBox>
#include <QObject>
#include <string>

namespace SimPT_Shell {

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

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

        static std::shared_ptr<CliController> Create(std::shared_ptr<Ws::CliWorkspace> workspace, bool quiet);

        int Execute(CliConverterTask task);

        int Execute(CliSimulationTask task);

        Timings GetTimings() const;

        void Terminate();

signals:
        void TerminationRequested();

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

        bool IsQuiet() const;

        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:
        // Because of Qt wanting to match parameter types of signals and slots by string comparison
        using InfoMessageReason = SimShell::Session::ISession::InfoMessageReason;

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

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

private:
        //typedef void (SigIntHandlerType)(int);
        using SigIntHandlerType = void (int);

        using SigIntAdaptorType = UA_CoMP_Adapt2rfp::Adaptor<SigIntHandlerType>;

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

        using SigQtAdaptorType = UA_CoMP_Adapt2rfp::Adaptor<SigQtHandlerType>;

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