Process.h

Go to the documentation of this file.

/*****************************************************************************
 *
 * Copyright (C) 2009-2022  Florian Pose <fp@igh.de>
 *
 * This file is part of the QtPdCom library.
 *
 * The QtPdCom library is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or (at your
 * option) any later version.
 *
 * The QtPdCom 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 Lesser General Public
 * License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with the QtPdCom Library. If not, see <http://www.gnu.org/licenses/>.
 *
 ****************************************************************************/
 
#ifndef QTPDCOM_PROCESS_H
#define QTPDCOM_PROCESS_H
 
#include <QObject>
#include <QString>
#include <QList>
#include <QSslCertificate>
#include <QUrl>
 
#include <pdcom5.h>
#include <pdcom5/ClientStatistics.h>
#include <pdcom5/Process.h>
#include <QFuture>
 
#ifndef PDCOM_VERSION_CODE
# error "No PDCOM_VERSION_CODE found."
#elif \
    !PDCOM_DEVEL \
    && (PDCOM_VERSION_CODE < PDCOM_VERSION(5, 0, 0) \
    || PDCOM_VERSION_CODE >= PDCOM_VERSION(6, 0, 0))
# error "Invalid PdCom version."
#endif
 
#include "Export.h"
#include "FutureWatchers.h"
#include "VariableList.h"
 
class QTranslator;
class QSslKey;
 
namespace QtPdCom {
 
class LoginManager;
 
/****************************************************************************/
 
class QTPDCOM_PUBLIC Process:
    public QObject, public PdCom::Process
{
    Q_OBJECT
    Q_PROPERTY(bool connected READ isConnected NOTIFY connectionStatusChanged)
    Q_PROPERTY(ConnectionState connectionState READ getConnectionState NOTIFY connectionStatusChanged)
    Q_PROPERTY(SslCaMode sslCaMode READ getCaMode WRITE setCaMode NOTIFY sslCaModeChanged)
    Q_PROPERTY(int port READ getPort NOTIFY connectionStatusChanged)
    Q_PROPERTY(QString host READ getHost NOTIFY connectionStatusChanged)
    Q_PROPERTY(QUrl url READ getUrl NOTIFY connectionStatusChanged)
    Q_PROPERTY(QString applicationName READ getApplicationName WRITE setApplicationName)
    Q_PROPERTY(QtPdCom::LoginManager * loginManager READ getLoginManager WRITE setLoginManager)
 
    public:
        enum class SslCaMode {
            NoTLS, 
            DefaultCAs ,
            CustomCAs ,
            IgnoreCertificate ,
        };
        Q_ENUM(SslCaMode)
 
        Process(QObject *parent = nullptr);
        virtual ~Process();
 
        void setApplicationName(const QString &);
        QString getApplicationName() const;
        Q_INVOKABLE void connectToHost(const QString &, quint16 = 2345);
        Q_INVOKABLE void disconnectFromHost();
 
        enum ConnectionState {
            Disconnected, 
            Connecting, 
            Connected, 
            ConnectError, 
            ConnectedError 
        };
        Q_ENUM(ConnectionState);
 
        ConnectionState getConnectionState() const;
        bool isConnected() const;
        const QString &getErrorString() const;
        QString getPeerName() const;
        QUrl getUrl() const;
        int getPort() const;
        QString getHost() const;
 
        Q_INVOKABLE void sendBroadcast(const QString &, const QString &attr = "text");
        quint64 getRxBytes() const;
        quint64 getTxBytes() const;
 
        QFuture<PdCom::Variable> find(const QString&);
        QFuture<VariableList> list(const QString& = "");
        QFuture<void> pingQt();
        QFuture<std::vector<PdCom::ClientStatistics>> getClientStatisticsQt();
 
        template<class Class, class Function>
        QFutureWatcher<PdCom::Variable>& find(const QString& path, Class *obj, Function&& callback);
        template<class Class, class Function>
        QFutureWatcher<VariableList>& list(const QString& path, Class *obj, Function&& callback);
        template<class Class, class Function>
        QFutureWatcher<void>& ping(Class *obj, Function&& callback);
        template<class Class, class Function>
        QFutureWatcher<std::vector<PdCom::ClientStatistics>>&
        getClientStatistics(Class *obj, Function&& callback);
 
        void setCaMode(SslCaMode mode);
        SslCaMode getCaMode() const;
 
        void setClientCertificate(const QSslCertificate& cert,const QSslKey& key);
        void setCustomCAs(QList<QSslCertificate> cas);
 
        static QtPdCom::Process *getDefaultProcess();
        static void setDefaultProcess(QtPdCom::Process *);
 
        PdCom::MessageManagerBase *getMessageManager() const;
 
        void setLoginManager(LoginManager* lm);
        LoginManager *getLoginManager() const;
    private:
        struct Q_DECL_HIDDEN Impl;
        std::unique_ptr<Impl> impl;
 
        std::string applicationName() const override;
        std::string hostname() const override;
        int read(char *, int) override;
        void write(const char *, size_t) override;
        void flush() override;
        void connected() override;
        void broadcastReply(
                const std::string &message,
                const std::string &attr,
                std::chrono::nanoseconds time_ns,
                const std::string &user) override;
        void pingReply() override;
        void findReply(PdCom::Variable const& var) override;
        void listReply(std::vector<PdCom::Variable> vars, std::vector<std::string> dirs) override;
        void clientStatisticsReply(std::vector<PdCom::ClientStatistics> statistics) override;
        void reset();
 
        bool disconnect(
                const char *signal = 0, 
                const QObject *receiver = 0, 
                const char *method = 0 
                );
 
        // make setMessageManager() private
        using PdCom::Process::setMessageManager;
 
    signals:
        void processConnected();
 
        void disconnected();
 
        void error();
 
        void broadcastReceived(
                const QString &message,
                const QString &attr,
                std::uint64_t time_ns,
                const QString &user);
 
        void connectionStatusChanged();
 
        void sslCaModeChanged();
 
 
    private slots:
        void socketConnected();
        void socketDisconnected();
        void socketError();
        void socketRead();
};
 
/****************************************************************************/
 
template<class Class, class Function>
inline QFutureWatcher<PdCom::Variable>& Process::find(
    const QString& path, Class *obj, Function&& callback)
{
    auto& ans = createWatcher<PdCom::Variable>(obj, callback);
    ans.setFuture(find(path));
    return ans;
}
 
/****************************************************************************/
 
template<class Class, class Function>
inline QFutureWatcher<VariableList>& Process::list(const QString& path, Class *obj, Function&& callback)
{
    auto& ans = createWatcher<VariableList>(obj, callback);
    ans.setFuture(list(path));
    return ans;
}
 
/****************************************************************************/
 
template<class Class, class Function>
inline QFutureWatcher<void>& Process::ping(Class *obj, Function&& callback)
{
    auto& ans = createWatcher<void>(obj, callback);
    ans.setFuture(pingQt());
    return ans;
}
 
/****************************************************************************/
 
template<class Class, class Function>
inline QFutureWatcher<std::vector<PdCom::ClientStatistics>>&
Process::getClientStatistics(Class *obj, Function&& callback)
{
    auto& ans = createWatcher<std::vector<PdCom::ClientStatistics>>(
        obj, callback
    );
    ans.setFuture(getClientStatisticsQt());
    return ans;
}
 
/****************************************************************************/
 
} // namespace
 
#endif