src/grpcquick/qqmlgrpcchanneloptions.cpp


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125

// Copyright (C) 2023 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only

#include <QtGrpcQuick/private/qqmlgrpcchanneloptions_p.h>
#include <QtGrpcQuick/private/qqmlgrpcmetadata_p.h>

#include <QtGrpc/qgrpcserializationformat.h>

#include <QtCore/private/qobject_p.h>

#include <chrono>

using namespace std::chrono_literals;

QT_BEGIN_NAMESPACE

class QQmlGrpcChannelOptionsPrivate : public QObjectPrivate
{
    Q_DECLARE_PUBLIC(QQmlGrpcChannelOptions)

public:
    QQmlGrpcChannelOptionsPrivate();

    QGrpcChannelOptions options;
    QtGrpc::SerializationFormat format = QtGrpc::SerializationFormat::Default;
    QQmlGrpcMetadata *metadata = nullptr;
#if QT_CONFIG(ssl)
    QQmlSslConfiguration configuration;
#endif // QT_CONFIG(ssl)
    QMetaObject::Connection metadataUpdateConnection;
};

QQmlGrpcChannelOptionsPrivate::QQmlGrpcChannelOptionsPrivate() : QObjectPrivate()
{
}

QQmlGrpcChannelOptions::QQmlGrpcChannelOptions(QObject *parent)
    : QObject(*(new QQmlGrpcChannelOptionsPrivate()), parent)
{
}

QQmlGrpcChannelOptions::~QQmlGrpcChannelOptions() = default;

qint64 QQmlGrpcChannelOptions::deadlineTimeout() const
{
    std::chrono::milliseconds ms = d_func()->options.deadlineTimeout().value_or(0ms);
    return ms.count();
}

void QQmlGrpcChannelOptions::setDeadlineTimeout(qint64 value)
{
    Q_D(QQmlGrpcChannelOptions);
    std::chrono::milliseconds ms(value);
    d->options.setDeadlineTimeout(ms);
    emit deadlineTimeoutChanged();
}

const QGrpcChannelOptions &QQmlGrpcChannelOptions::options() const & noexcept
{
    return d_func()->options;
}

QQmlGrpcMetadata *QQmlGrpcChannelOptions::metadata() const
{
    return d_func()->metadata;
}

void QQmlGrpcChannelOptions::setMetadata(QQmlGrpcMetadata *value)
{
    Q_D(QQmlGrpcChannelOptions);
    if (d->metadata != value) {
        if (d->metadataUpdateConnection) {
            disconnect(d->metadataUpdateConnection);
            d->metadataUpdateConnection = {};
        }

        d->metadata = value;
        if (d->metadata) {
            const auto updateMetadata = [this]() {
                Q_D(QQmlGrpcChannelOptions);
                d->options.setMetadata(d->metadata->metadata());
                emit metadataChanged();
            };
            d->metadataUpdateConnection = connect(d->metadata, &QQmlGrpcMetadata::dataChanged, this,
                                                  updateMetadata);
            updateMetadata();
        }
    }
}

QtGrpc::SerializationFormat QQmlGrpcChannelOptions::serializationFormat() const
{
    return d_func()->format;
}

void QQmlGrpcChannelOptions::setSerializationFormat(QtGrpc::SerializationFormat format)
{
    Q_D(QQmlGrpcChannelOptions);
    if (d->format != format) {
        d->format = format;
        d->options.setSerializationFormat(format);
        emit serializationFormatChanged();
    }
}

#if QT_CONFIG(ssl)
QQmlSslConfiguration QQmlGrpcChannelOptions::sslConfiguration() const
{
    return d_func()->configuration;
}

void QQmlGrpcChannelOptions::setSslConfiguration(const QQmlSslConfiguration &config)
{
    Q_D(QQmlGrpcChannelOptions);
    if (d->configuration != config) {
        d->configuration = config;
        d->options.setSslConfiguration(d->configuration.configuration());
        emit sslConfigurationChanged();
    }
}
#endif // QT_CONFIG(ssl)

QT_END_NAMESPACE

#include "moc_qqmlgrpcchanneloptions_p.cpp"