QRemoteObjectHostBase Class
La clase `QRemoteObjectHostBase` proporciona la funcionalidad básica común a las clases ` Host ` y ` RegistryHost `. Más información...
| Encabezado: | #include <QRemoteObjectHostBase> |
| CMake: | find_package(Qt6 REQUIRED COMPONENTS RemoteObjects) target_link_libraries(mytarget PRIVATE Qt6::RemoteObjects) |
| qmake: | QT += remoteobjects |
| Heredado de: | QRemoteObjectNode |
| Heredado por: |
Tipos públicos
| enum | AllowedSchemas { BuiltInSchemasOnly, AllowExternalRegistration } |
Funciones públicas
| void | addHostSideConnection(QIODevice *ioDevice) |
| bool | disableRemoting(QObject *remoteObject) |
| bool | enableRemoting(ObjectType *object) |
| bool | enableRemoting(QObject *object, const QString &name = QString()) |
| bool | enableRemoting(QAbstractItemModel *model, const QString &name, const QList<int> roles, QItemSelectionModel *selectionModel = nullptr) |
| bool | proxy(const QUrl ®istryUrl, const QUrl &hostUrl = {}, QRemoteObjectHostBase::RemoteObjectNameFilter filter = [](QStringView, QStringView) {return true; }) |
| bool | reverseProxy(QRemoteObjectHostBase::RemoteObjectNameFilter filter = [](QStringView, QStringView) {return true; }) |
Funciones públicas reimplementadas
| virtual void | setName(const QString &name) override |
Descripción detallada
QRemoteObjectHostBase es una clase base que no se puede instanciar directamente. Proporciona las funcionalidades « enableRemoting » y « disableRemoting », compartidas por todos los nodos host (Host y RegistryHost), así como la lógica necesaria para exponer objetos «Source» en la red de objetos remotos.
Documentación sobre los tipos de miembro
enum QRemoteObjectHostBase::AllowedSchemas
Esta enumeración se utiliza para especificar si un nodo aceptará una URL con un esquema no reconocido para el campo `hostUrl`. Por defecto, solo se aceptan las URL con esquemas conocidos, pero al utilizar ` AllowExternalRegistration `, se habilitará el Registro para que pase tu URL externa (a QtRO) a los nodos cliente.
| Constante | Valor | Descripción |
|---|---|---|
QRemoteObjectHostBase::BuiltInSchemasOnly | 0 | Solo permite que hostUrl se establezca en un esquema compatible con QtRO. Este es el valor por defecto y provoca que se genere un error de nodo si se proporciona un esquema no reconocido. |
QRemoteObjectHostBase::AllowExternalRegistration | 1 | El esquema proporcionado se registra como un esquema externo |
Véase también QRemoteObjectHost.
Documentación de las funciones de miembro
void QRemoteObjectHostBase::addHostSideConnection(QIODevice *ioDevice)
Para poder utilizar ` QRemoteObjectHost::enableRemoting()` con objetos «Source» a través de dispositivos QIODevice externos, ` Qt Remote Objects ` necesita acceder al canal de comunicación (un ` QIODevice`) entre los nodos correspondientes. La llamada a `addHostSideConnection()` es la que habilita esto en el lado «Source», tomando como entrada el ` ioDevice `. Cualquier llamada a ` enableRemoting()` seguirá funcionando sin llamar a `addHostSideConnection`, pero el nodo no podrá compartir los objetos de origen si no se le proporciona la conexión con el nodo réplica. Antes de llamar a esta función, debe llamar a ` setHostUrl()` con una URL única y ` AllowExternalRegistration`.
Véase también addClientSideConnection.
[invokable] bool QRemoteObjectHostBase::disableRemoting(QObject *remoteObject)
Desactiva el acceso remoto para el objeto ` QObject ` remoteObject. Devuelve ` false ` si el nodo actual es un nodo cliente o si el objeto ` remoteObject ` no está registrado, y devuelve ` true ` si se ha desactivado correctamente el acceso remoto para el objeto `Source`.
Advertencia: Las réplicas de este objeto dejarán de ser válidas tras llamar a este método.
Nota: Esta función se puede invocar a través del sistema de metaobjetos y desde QML. Véase Q_INVOKABLE.
Véase también enableRemoting().
template <template <typename> typename ApiDefinition, typename ObjectType> bool QRemoteObjectHostBase::enableRemoting(ObjectType *object)
Esta sobrecarga de función con plantilla permite a un nodo anfitrión proporcionar acceso remoto a un objeto « QObject » object mediante una interfaz especificada (y comprobada en tiempo de compilación). Los nodos cliente conectados al nodo que aloja este objeto pueden obtener réplicas de esta fuente.
Esto se ilustra mejor con un ejemplo:
#include "rep_TimeModel_source.h"
MinuteTimer timer;
hostNode.enableRemoting<MinuteTimerSourceAPI>(&timer);En este caso, MinuteTimerSourceAPI es el ` ApiDefinition`, que representa el conjunto de señales, ranuras y propiedades definidas por el archivo `TimeModel.rep`. Se realizan comprobaciones en tiempo de compilación para verificar que el ` QObject ` de entrada pueda exponer la API solicitada; de lo contrario, la compilación fallará. Esto permite exponer un subconjunto de la interfaz de object y permite los tipos de conversiones admitidos por las conexiones de señal/ranura.
Devuelve false si el nodo actual es un nodo cliente, o si el QObject ya está registrado para ser controlado de forma remota, y true si el control remoto se ha habilitado correctamente para el QObject.
Véase también disableRemoting().
[invokable] bool QRemoteObjectHostBase::enableRemoting(QObject *object, const QString &name = QString())
Permite a un nodo anfitrión proporcionar de forma dinámica acceso remoto a la fuente de datos « QObject » object. Los nodos cliente conectados al nodo que aloja este objeto pueden obtener réplicas de esta fuente.
La macro opcional « name » define el nombre de búsqueda bajo el cual se puede obtener el « QObject » mediante « QRemoteObjectNode::acquire()». Si no se establece explícitamente, se utilizará el nombre proporcionado en «QCLASSINFO_REMOTEOBJECT_TYPE». Si no se ha definido dicha macro para el « QObject », se utiliza « QObject::objectName()».
Devuelve « false » si el nodo actual es un nodo cliente, o si el « QObject » ya está registrado para ser remoto, y « true » si la comunicación remota se ha habilitado correctamente para el « QObject » dinámico.
Nota: Esta función se puede invocar a través del sistema de metaobjetos y desde QML. Véase Q_INVOKABLE.
Véase también disableRemoting().
bool QRemoteObjectHostBase::enableRemoting(QAbstractItemModel *model, const QString &name, const QList<int> roles, QItemSelectionModel *selectionModel = nullptr)
Esta sobrecarga de `enableRemoting()` es específica para los tipos ` QAbstractItemModel ` (o cualquier tipo derivado de ` QAbstractItemModel`). Resulta útil si se desea tener un modelo y la interfaz HMI de dicho modelo en procesos diferentes.
Los tres parámetros obligatorios son el propio ` model `, el ` name ` mediante el cual se busca el modelo y el ` roles ` que debe exponerse en el lado de la réplica. Si se desea sincronizar la selección entre la fuente y la réplica, se puede utilizar el parámetro opcional ` selectionModel `. Esto solo se recomienda cuando se utiliza una única réplica.
En segundo plano, Qt Remote Objects agrupa las consultas a data() y precarga los datos siempre que es posible para que la interacción con el modelo sea lo más ágil posible.
Devuelve ` false ` si el nodo actual es un nodo cliente, o si el ` QObject ` ya está registrado para el acceso remoto, y ` true ` si el acceso remoto se ha habilitado correctamente para ` QAbstractItemModel`.
Véase también disableRemoting().
bool QRemoteObjectHostBase::proxy(const QUrl ®istryUrl, const QUrl &hostUrl = {}, QRemoteObjectHostBase::RemoteObjectNameFilter filter = [](QStringView, QStringView) {return true; })
Reenviar objetos remotos desde otra red
La funcionalidad de proxy resulta útil cuando se desea compartir objetos de origen a través de varias redes. Por ejemplo, si se dispone de un destino integrado que utiliza conexiones exclusivas para el destino (como «local») y se desea que algunos de esos mismos objetos estén disponibles externamente.
Como ejemplo concreto, supongamos que tienes un conjunto de procesos que se comunican entre sí en tu hardware de destino mediante un registro, con el Registro en «local:registry» y procesos independientes que utilizan un nodo en «local:MyHost» que contiene objetos de origen. Si quisieras acceder a estos objetos, pero a través de TCP, podrías crear un nuevo proxyNode de la siguiente manera:
// myInternalHost is a node only visible on the device...
QRemoteObjectHost myInternalHost("local:MyHost");
myInternalHost.enableRemoting<SomeObject>(&someObject);
// Regular host node, listening on port 12123, so visible to other
// devices
QRemoteObjectHost proxyNode("tcp://localhost:12123");
// Enable proxying objects from nodes on the local machine's internal
// QtRO bus
proxyNode.proxy("local:registry");Y desde otro dispositivo, creas otro nodo:
// NB: localhost resolves to a different ip address than proxyNode
QRemoteObjectHost nodeOnRemoteDevice("tcp://localhost:23234");
// Connect to the target's proxyNode directly, or use a tcp registry...
nodeOnRemoteDevice.connectToNode("tcp://<target device>:12123");
// Because of the proxy, we can get the object over tcp/ip port 12123,
// even though we can't connect directly to "local:MyHost"
SomeObject *so = nodeOnRemoteDevice.acquire<SomeObject>();Esto crearía (internamente) un nodo en `proxyNode`, el cual (de nuevo, interna y automáticamente) se conectaría al registro proporcionado (especificado por el parámetro ` registryUrl `, «local:registry» en este ejemplo). Cada vez que «local:registry» emita la señal « remoteObjectAdded », se pasa « QRemoteObjectSourceLocation » a « filter », especificado en la llamada al proxy. Si este método devuelve «true» (el filtro por defecto simplemente devuelve «true» sin aplicar ningún filtrado), se recupera el objeto mediante «acquire()» del nodo interno y se llama a « enableRemoting()» (una vez inicializada la réplica) en «proxyNode».
Si se proporciona un ` hostUrl ` (lo cual es necesario para habilitar ` reverseProxy`, pero no es necesario en otros casos), el nodo interno será un nodo ` QRemoteObjectHost ` configurado con la dirección proporcionada. Si no se proporciona ningún ` hostUrl `, el nodo interno será un ` QRemoteObjectNode ` (no un `HostNode`).
Devuelve true si el objeto se obtiene del nodo interno.
Véase también reverseProxy().
bool QRemoteObjectHostBase::reverseProxy(QRemoteObjectHostBase::RemoteObjectNameFilter filter = [](QStringView, QStringView) {return true; })
Reenvía objetos remotos a otra red.
La función `reverseProxy()` permite ampliar la funcionalidad de ` proxy()`, reflejando, en la práctica, la funcionalidad del proxy en dirección «inversa». Se trata de dos procesos distintos, ya que la comunicación entre nodos no es simétrica: un lado llama a ` enableRemoting()` con un objeto `Source`, mientras que el otro llama a ` acquire()` para obtener una réplica. El uso de proxy() permite «observar» objetos en un dispositivo de destino de forma remota mediante acquire, pero no permite adquirir objetos Source ajenos al destino desde la red local:* del dispositivo. Ahí es donde entra en juego reverseProxy(). Si se crea un proxyNode de la siguiente manera:
// myInternalHost is a node only visible on the device...
QRemoteObjectHost myInternalHost("local:MyHost", "local:registry");
// RegistryHost node, listening on port 12123, so visible to other
// devices. The node must be a RegistryHost, so the Sources on
// the "outside" network can be forwarded to the inner network.
QRemoteObjectRegistryHost proxyNode("tcp://0.0.0.0:12123");
// Enable proxying objects from nodes on the local machine's internal
// QtRO bus. Note the hostUrl parameter is now needed.
proxyNode.proxy("local:registry", "local:fromProxy");
proxyNode.reverseProxy();Y desde otro dispositivo se crea otro nodo:
// Listen on a local port, and connect to "proxyNode" as the registry.
// NB: localhost resolves to a different ip address than proxyNode
QRemoteObjectHost nodeOnRemoteDevice("tcp://localhost:23234",
"tcp://<target device>:12123");
// Because of the reverseProxy, we can expose objects on this device
// and they will make their way to proxyNode...
nodeOnRemoteDevice.enableRemoting<OtherObject>(&otherObject);// Acquire() can now see the objects on other devices through proxyNode,
// due to the reverseProxy call.
OtherObject *oo = myInternalHost.acquire<OtherObject>();Mientras que la funcionalidad de ` proxy()` permite adquirir objetos «Source» de otra red mediante `acquire()`, `reverseProxy()` permite «enviar» objetos «Source» a una red que, de otro modo, sería inaccesible.
Nota: Es necesario llamar a` proxy()` antes que a `reverseProxy()`, y hay que proporcionar una `hostUrl` a ` proxy ` para que `reverseProxy()` funcione. El método `reverseProxy()` permite aplicar un ` filter ` independiente. Este filtro específico de `reverseProxy` recibirá notificaciones de nuevos objetos `Source` en ` proxyNode ` y los adquirirá en el nodo interno si superan la ` filter`.
Devuelve « true » si se realiza correctamente y « false » en caso contrario.
Nota: Actualmente , la funcionalidad de proxy inverso solo es compatible con QRemoteObjectRegistryHost. Al llamar a este método en un nodo QRemoteObjectHost, siempre se devolverá false.
Véase también proxy().
[override virtual] void QRemoteObjectHostBase::setName(const QString &name)
Reimplementa: ` QRemoteObjectNode::setName(const QString &name)`.
Es similar a ` QObject::setObjectName()` (que este método invoca), pero esta versión también aplica la ` name ` a las clases internas, que se utilizan en parte de la salida de depuración.
© 2026 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.