Revision control
++ // Copyright (C) 2017 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
++
++ #include "qremoteobjectdynamicreplica.h"
++ #include "qremoteobjectreplica_p.h"
++
++ #include <QtCore/qmetaobject.h>
++
++ QT_BEGIN_NAMESPACE
++
++ /*!
++ \class QRemoteObjectDynamicReplica
++ \inmodule QtRemoteObjects
++ \brief A dynamically instantiated \l {Replica}.
++
++ There are generated replicas (replicas having the header files produced by
++ the \l {repc} {Replica Compiler}), and dynamic replicas, that are generated
++ on-the-fly. This is the class for the dynamic type of replica.
++
++ When the connection to the \l {Source} object is made, the initialization
++ step passes the current property values (see \l {Replica Initialization}).
++ In a DynamicReplica, the property/signal/slot details are also sent,
++ allowing the replica object to be created on-the-fly. This can be convenient
++ in QML or scripting, but has two primary disadvantages. First, the object is
++ in effect "empty" until it is successfully initialized by the \l {Source}.
++ Second, in C++, calls must be made using QMetaObject::invokeMethod(), as the
++ moc generated lookup will not be available.
++
++ This class does not have a public constructor. It can only be instantiated
++ by using the dynamic QRemoteObjectNode::acquire method.
++ */
++
++ QRemoteObjectDynamicReplica::QRemoteObjectDynamicReplica()
++ : QRemoteObjectReplica()
++ {
++ }
++
++ QRemoteObjectDynamicReplica::QRemoteObjectDynamicReplica(QRemoteObjectNode *node, const QString &name)
++ : QRemoteObjectReplica(ConstructWithNode)
++ {
++ initializeNode(node, name);
++ }
++
++ /*!
++ Destroys the dynamic replica.
++
++ \sa {Replica Ownership}
++ */
++ QRemoteObjectDynamicReplica::~QRemoteObjectDynamicReplica()
++ {
++ }
++
++ /*!
++ \internal
++ Returns a pointer to the dynamically generated meta-object of this object, or
++ QRemoteObjectDynamicReplica's metaObject if the object is not initialized. This
++ function overrides the QObject::metaObject() virtual function to provide the same
++ functionality for dynamic replicas.
++
++ \sa QObject::metaObject(), {Replica Initialization}
++ */
++ const QMetaObject* QRemoteObjectDynamicReplica::metaObject() const
++ {
++ auto impl = qSharedPointerCast<QRemoteObjectReplicaImplementation>(d_impl);
++ // Returning nullptr will likely result in a crash if this type is used before the
++ // definition is received. Note: QRemoteObjectDynamicReplica doesn't include the
++ // QObject macro, so it's metaobject would resolve to QRemoteObjectReplica::metaObject()
++ // if we weren't overriding it.
++ if (!impl->m_metaObject) {
++ qWarning() << "Dynamic metaobject is not assigned, returning generic Replica metaObject.";
++ qWarning() << "This may cause issues if used for more than checking the Replica state.";
++ return QRemoteObjectReplica::metaObject();
++ }
++
++ return impl->m_metaObject;
++ }
++
++ /*!
++ \internal
++ This function overrides the QObject::qt_metacast() virtual function to provide the same functionality for dynamic replicas.
++
++ \sa QObject::qt_metacast()
++ */
++ void *QRemoteObjectDynamicReplica::qt_metacast(const char *name)
++ {
++ if (!name)
++ return nullptr;
++
++ if (!strcmp(name, "QRemoteObjectDynamicReplica"))
++ return static_cast<void*>(const_cast<QRemoteObjectDynamicReplica*>(this));
++
++ // not entirely sure that one is needed... TODO: check
++ auto impl = qSharedPointerCast<QRemoteObjectReplicaImplementation>(d_impl);
++ if (QString::fromLatin1(name) == impl->m_objectName)
++ return static_cast<void*>(const_cast<QRemoteObjectDynamicReplica*>(this));
++
++ return QObject::qt_metacast(name);
++ }
++
++ /*!
++ \internal
++ This function overrides the QObject::qt_metacall() virtual function to provide the same functionality for dynamic replicas.
++
++ \sa QObject::qt_metacall()
++ */
++ int QRemoteObjectDynamicReplica::qt_metacall(QMetaObject::Call call, int id, void **argv)
++ {
++ static const bool debugArgs = qEnvironmentVariableIsSet("QT_REMOTEOBJECT_DEBUG_ARGUMENTS");
++
++ auto impl = qSharedPointerCast<QConnectedReplicaImplementation>(d_impl);
++
++ int saved_id = id;
++ id = QRemoteObjectReplica::qt_metacall(call, id, argv);
++ if (id < 0 || impl->m_metaObject == nullptr)
++ return id;
++
++ if (call == QMetaObject::ReadProperty || call == QMetaObject::WriteProperty) {
++ QMetaProperty mp = metaObject()->property(saved_id);
++
++ if (call == QMetaObject::WriteProperty) {
++ QVariantList args;
++ if (mp.userType() == QMetaType::QVariant)
++ args << *reinterpret_cast<QVariant*>(argv[0]);
++ else
++ args << QVariant(mp.metaType(), argv[0]);
++ QRemoteObjectReplica::send(QMetaObject::WriteProperty, saved_id, args);
++ } else {
++ if (mp.userType() == QMetaType::QVariant)
++ *reinterpret_cast<QVariant*>(argv[0]) = impl->m_propertyStorage[id];
++ else {
++ const QVariant value = propAsVariant(id);
++ mp.metaType().destruct(argv[0]);
++ mp.metaType().construct(argv[0], value.data());
++ }
++ }
++
++ id = -1;
++ } else if (call == QMetaObject::InvokeMetaMethod) {
++ if (id < impl->m_numSignals) {
++ qCDebug(QT_REMOTEOBJECT) << "DynamicReplica Activate" << impl->m_metaObject->method(saved_id).methodSignature();
++ // signal relay from Source world to Replica
++ QMetaObject::activate(this, impl->m_metaObject, id, argv);
++
++ } else {
++ // method relay from Replica to Source
++ const QMetaMethod mm = impl->m_metaObject->method(saved_id);
++ const int nParam = mm.parameterCount();
++ QVariantList args;
++ args.reserve(nParam);
++ for (int i = 0; i < nParam; ++i) {
++ const auto metaType = mm.parameterMetaType(i);
++ if (metaType.flags().testFlag(QMetaType::IsEnumeration)) {
++ auto transferType = QRemoteObjectPackets::transferTypeForEnum(metaType);
++ args.push_back(QVariant(transferType, argv[i + 1]));
++ } else
++ args.push_back(QVariant(metaType, argv[i + 1]));
++ }
++
++ if (debugArgs) {
++ qCDebug(QT_REMOTEOBJECT) << "method" << mm.methodSignature() << "invoked - args:" << args;
++ } else {
++ qCDebug(QT_REMOTEOBJECT) << "method" << mm.methodSignature() << "invoked";
++ }
++
++ if (mm.returnType() == QMetaType::Void)
++ QRemoteObjectReplica::send(QMetaObject::InvokeMetaMethod, saved_id, args);
++ else {
++ QRemoteObjectPendingCall call = QRemoteObjectReplica::sendWithReply(QMetaObject::InvokeMetaMethod, saved_id, args);
++ if (argv[0])
++ *(static_cast<QRemoteObjectPendingCall*>(argv[0])) = call;
++ }
++ }
++
++ id = -1;
++ }
++
++ return id;
++ }
++
++ QT_END_NAMESPACE