qconnectionfactories.h

Enable keyboard shortcuts

// Copyright (C) 2021 Ford Motor Company

// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only

// Qt-Security score:significant reason:default

#ifndef QCONNECTIONFACTORIES_H

#define QCONNECTIONFACTORIES_H

//

//  W A R N I N G

//  -------------

//

// This file is part of the QtRO internal API and is not meant to be used

// in applications. It contains "internal" components, which are exported

// to allow new QIODevice channels to be added to extend QtRO. Usage of these

// APIs may make your code source and binary incompatible with future versions

// of Qt.

//

#include <QtNetwork/qabstractsocket.h>

#include <QtRemoteObjects/qtremoteobjectglobal.h>

#include <QtRemoteObjects/qremoteobjectnode.h>

QT_BEGIN_NAMESPACE

class QtROIoDeviceBasePrivate;

class QtROClientIoDevicePrivate;

class QtROExternalIoDevicePrivate;

class Q_REMOTEOBJECTS_EXPORT QtROIoDeviceBase : public QObject

    Q_OBJECT

    Q_DISABLE_COPY(QtROIoDeviceBase)

public:

    explicit QtROIoDeviceBase(QObject *parent = nullptr);

    ~QtROIoDeviceBase() override;

    bool read(QtRemoteObjects::QRemoteObjectPacketTypeEnum &, QString &);

    virtual void write(const QByteArray &data);

    virtual void write(const QByteArray &data, qint64);

    virtual bool isOpen() const;

    virtual void close();

    virtual qint64 bytesAvailable() const;

    virtual QIODevice *connection() const = 0;

    void initializeDataStream();

    bool isClosing() const;

    void addSource(const QString &);

    void removeSource(const QString &);

    QSet<QString> remoteObjects() const;

Q_SIGNALS:

    void readyRead();

    void disconnected();

protected:

    explicit QtROIoDeviceBase(QtROIoDeviceBasePrivate &, QObject *parent);

    virtual QString deviceType() const = 0;

    virtual void doClose() = 0;

private:

    Q_DECLARE_PRIVATE(QtROIoDeviceBase)

    friend class QRemoteObjectNodePrivate;

    friend class QConnectedReplicaImplementation;

    friend class QRemoteObjectSourceIo;

};

class Q_REMOTEOBJECTS_EXPORT QtROServerIoDevice : public QtROIoDeviceBase

    Q_OBJECT

    Q_DISABLE_COPY(QtROServerIoDevice)

public:

    explicit QtROServerIoDevice(QObject *parent = nullptr);

protected:

    QString deviceType() const override;

};

class Q_REMOTEOBJECTS_EXPORT QConnectionAbstractServer : public QObject

    Q_OBJECT

    Q_DISABLE_COPY(QConnectionAbstractServer)

public:

    explicit QConnectionAbstractServer(QObject *parent = nullptr);

    ~QConnectionAbstractServer() override;

    virtual bool hasPendingConnections() const = 0;

    QtROServerIoDevice* nextPendingConnection();

    virtual QUrl address() const = 0;

    virtual bool listen(const QUrl &address) = 0;

    virtual QAbstractSocket::SocketError serverError() const = 0;

    virtual void close() = 0;

protected:

    virtual QtROServerIoDevice* configureNewConnection() = 0;

Q_SIGNALS:

    void newConnection();

};

class Q_REMOTEOBJECTS_EXPORT QtROClientIoDevice : public QtROIoDeviceBase

    Q_OBJECT

    Q_DISABLE_COPY(QtROClientIoDevice)

public:

    explicit QtROClientIoDevice(QObject *parent = nullptr);

    ~QtROClientIoDevice() override;

    void disconnectFromServer();

    virtual void connectToServer() = 0;

    QUrl url() const;

Q_SIGNALS:

    void shouldReconnect(QtROClientIoDevice*);

    void setError(QRemoteObjectNode::ErrorCode);

protected:

    virtual void doDisconnectFromServer() = 0;

    QString deviceType() const override;

    void setUrl(const QUrl &url);

private:

    Q_DECLARE_PRIVATE(QtROClientIoDevice)

    friend class QtROClientFactory;

};

class QtROServerFactory

public:

    Q_REMOTEOBJECTS_EXPORT static QtROServerFactory *instance();

    QConnectionAbstractServer *create(const QUrl &url, QObject *parent = nullptr)

        auto creatorFunc = m_creatorFuncs.value(url.scheme());

        return creatorFunc ? (*creatorFunc)(parent) : nullptr;

    template<typename T>

    void registerType(const QString &id)

        m_creatorFuncs[id] = [](QObject *parent) -> QConnectionAbstractServer * {

            return new T(parent);

};

    bool isValid(const QUrl &url)

        return m_creatorFuncs.contains(url.scheme());

private:

    friend class QtROFactoryLoader;

    QtROServerFactory();

    using CreatorFunc = QConnectionAbstractServer * (*)(QObject *);

    QHash<QString, CreatorFunc> m_creatorFuncs;

};

class QtROClientFactory

public:

    Q_REMOTEOBJECTS_EXPORT static QtROClientFactory *instance();

    /// creates an object from a string

    QtROClientIoDevice *create(const QUrl &url, QObject *parent = nullptr)

        auto creatorFunc = m_creatorFuncs.value(url.scheme());

        if (!creatorFunc)

            return nullptr;

        QtROClientIoDevice *res = (*creatorFunc)(parent);

        if (res)

            res->setUrl(url);

        return res;

    template<typename T>

    void registerType(const QString &id)

        m_creatorFuncs[id] = [](QObject *parent) -> QtROClientIoDevice * {

            return new T(parent);

};

    bool isValid(const QUrl &url)

        return m_creatorFuncs.contains(url.scheme());

private:

    friend class QtROFactoryLoader;

    QtROClientFactory();

    using CreatorFunc = QtROClientIoDevice * (*)(QObject *);

    QHash<QString, CreatorFunc> m_creatorFuncs;

};

template <typename T>

inline void qRegisterRemoteObjectsClient(const QString &id)

    QtROClientFactory::instance()->registerType<T>(id);

template <typename T>

inline void qRegisterRemoteObjectsServer(const QString &id)

    QtROServerFactory::instance()->registerType<T>(id);

QT_END_NAMESPACE

#endif // QCONNECTIONFACTORIES_H