Ejemplo 1 Conexión directa mediante una fuente estática

1. Crear un objeto Fuente

   Para crear este objeto Fuente, primero creamos el archivo de definición, simpleswitch.rep. Este archivo describe las propiedades y los métodos del objeto y se introduce en el compilador repc de Qt Remote Objects. Este archivo sólo define las interfaces que son necesarias exponer a las Replicas.

   simpleswitch.rep

   class SimpleSwitch
   {
       PROP(bool currState=false);
       SLOT(server_slot(bool clientState));
   };

   En simpleswitch.rep,

   • currState mantiene el estado actual del interruptor.
   • server_slot() nos permite interactuar con la fuente - se conectará a la señal echoSwitchState(bool newstate).

   Para que repc procese este archivo, añada la siguiente línea a su archivo cmake:

   qt6_add_repc_sources(directconnectserver
       simpleswitch.rep
   )

   Si estás usando qmake:

   REPC_SOURCE = simpleswitch.rep

   Estas instrucciones sólo son relevantes para el módulo Qt Remote Objects, por lo que también debes añadirlo a tu proyecto. Si estás usando CMake, añade:

   find_package(Qt6 REQUIRED COMPONENTS RemoteObjects)
   target_link_libraries(directconnectserver PRIVATE Qt6::RemoteObjects)

   Si estás usando qmake:

   QT       += remoteobjects

   repc crea la cabecera rep_SimpleSwitch_source.h en el directorio de compilación que especifique. Para obtener más información, consulte Fuente.

   repc crea tres clases de ayuda para su uso con QtRO. Para este ejemplo, usaremos la básica: SimpleSwitchSimpleSource. Es una clase abstracta, definida en rep_SimpleSwitch_source.h. Derivamos de ella para definir nuestra clase de implementación SimpleSwitch como se muestra a continuación:

   simpleswitch.h

   #ifndef SIMPLESWITCH_H
   #define SIMPLESWITCH_H
   
   #include "rep_simpleswitch_source.h"
   
   class SimpleSwitch : public SimpleSwitchSimpleSource
   {
       Q_OBJECT
   public:
       SimpleSwitch(QObject *parent = nullptr);
       ~SimpleSwitch();
       void server_slot(bool clientState) override;
   public Q_SLOTS:
       void timeout_slot();
   private:
       QTimer *stateChangeTimer;
   };
   
   #endif

   En simpleswitch.h,

   • stateChangeTimer es un QTimer que se utiliza para cambiar el estado de nuestro SimpleSwitch.
   • timeout_slot() está conectado a la señal timeout() de stateChangeTimer.
   • server_slot() - que se llama automáticamente en la fuente cada vez que cualquier réplica llama a su versión de la ranura - emite el valor recibido.
   • currStateChanged(bool)definida en el repc-generado rep_SimpleSwitch_source.h, se emite cada vez que currState conmuta. En este ejemplo, ignoramos la señal en el lado de la fuente, y la manejamos más tarde en el lado de la réplica.

   La definición de nuestra clase SimpleSwitch se muestra a continuación:

   simpleswitch.cpp

   #include "simpleswitch.h"// constructorSimpleSwitch::SimpleSwitch(QObject *parent) : SimpleSwitchSimpleSource(parent) { stateChangeTimer = new QTimer(this); // Inicializar temporizador   QObject::connect(stateChangeTimer, &QTimer::timeout, this, &SimpleSwitch::timeout_slot); // conecta la señal timeout() de stateChangeTimer a timeout_slot() de simpleSwitch stateChangeTimer->start(2000); // Inicia el temporizador y establece el tiempo de espera en 2 segundos    qDebug() << "Source Node Started";
   }//destructorSimpleSwitch::~SimpleSwitch() {  stateChangeTimer->stop(); }void SimpleSwitch::server_slot(bool clientState){
       qDebug() << "Replica state is " << clientState; // print switch state echoed back by client
   }void SimpleSwitch::timeout_slot() { // ranura llamada en el tiempo de espera del temporizador if (currState()) // comprueba si el estado actual es verdadero, currState() está definido en rep_simpleswitch_source.h generado en rep_simpleswitch.hsetCurrState(false); // establece el estado a falso elsesetCurrState(true); // establece el estado a verdadero    qDebug() << "Source State is "<<currState();
   
   }

2. Crear un registroDado que

   este ejemplo utiliza una conexión directa entre nodos, podemos omitir este paso.

3. Crear un nodo anfitriónEl

   nodo anfitrión se crea como se muestra a continuación:

   QRemoteObjectHost srcNode(QUrl(QStringLiteral("local:replica")));

4. Objeto fuente anfitrión y remotingLas

   siguientes sentencias instancian el objeto Fuente y lo pasan al anfitrión para habilitar el "remoting", que es el proceso de hacer un objeto visible a la red QtRO:

   SimpleSwitch srcSwitch; // create simple switch
   srcNode.enableRemoting(&srcSwitch); // enable remoting

   El contenido del archivo main.cpp que implementa los pasos descritos anteriormente es el siguiente:

   main.cpp

   #include <QCoreApplication>
   #include "simpleswitch.h"
   
   int main(int argc, char *argv[])
   {
       QCoreApplication a(argc, argv);
   
       SimpleSwitch srcSwitch; // create simple switch
   
       // Create host node without Registry:
       QRemoteObjectHost srcNode(QUrl(QStringLiteral("local:replica")));
       srcNode.enableRemoting(&srcSwitch); // enable remoting/sharing
   
       return a.exec();
   }

   Compila y ejecuta este proyecto del lado fuente. La salida, sin ninguna réplica creada, debería verse como se muestra a continuación, con el estado de conmutación alternando entre true y false cada dos segundos.

   

Los pasos siguientes son para crear el lado réplica de la red, que en este ejemplo obtiene el estado del switch de la Fuente y lo devuelve.

Código de réplica

1. Utilice repc para añadir una réplica a su

   proyectoUtilizamos el mismo archivo de definición de API que hicimos en el lado fuente, SimpleSwitch.rep, para crear un archivo de cabecera de réplica utilizando el repc.

   Si está utilizando cmake, incluya la siguiente línea en su archivo cmake del lado del cliente, especificando una entrada de archivo .rep:

   qt6_add_repc_replicas(directconnectclient
       simpleswitch.rep
   )

   Si está utilizando qmake

   ,

   añada la siguiente línea a su archivo .pro del lado del cliente:

   REPC_REPLICA = simpleswitch.rep

   La herramienta repc genera un archivo rep_SimpleSwitch_replica.h en el directorio de compilación. Para obtener más información, consulte Réplica.

2. Crear un nodo para conectar con el nodo

   host de origenEl siguiente código instancia el segundo nodo de la red y lo conecta con el nodo host de origen:

   QRemoteObjectNode repNode; // create remote object node
   repNode.connectToNode(QUrl(QStringLiteral("local:replica"))); // connect with remote host node

3. Llame a acquire() del nodo para crear un puntero a una réplica.

   En primer lugar, instanciamos una réplica:

   QSharedPointer<SimpleSwitchReplica> ptr;
   ptr.reset(repNode.acquire<SimpleSwitchReplica>()); // acquire replica of source from host node

   Nota: acquire() devuelve un puntero a la réplica, pero no gestiona su vida útil. Este ejemplo muestra el proceso recomendado de envolver el puntero devuelto en un QSharedPointer o QScopedPointer para asegurar que el puntero siempre se elimina correctamente.

   main.cpp implementa los pasos descritos anteriormente e instantiza nuestro objeto:

   main.cpp

   #include <QCoreApplication>
   #include "client.h"
   
   int main(int argc, char *argv[])
   {
       QCoreApplication a(argc, argv);
   
       QSharedPointer<SimpleSwitchReplica> ptr; // shared pointer to hold source replica
   
       QRemoteObjectNode repNode; // create remote object node
       repNode.connectToNode(QUrl(QStringLiteral("local:replica"))); // connect with remote host node
   
       ptr.reset(repNode.acquire<SimpleSwitchReplica>()); // acquire replica of source from host node
   
       Client rswitch(ptr); // create client switch object and pass reference of replica to it
   
       return a.exec();
   }

   La declaración y definición completa de la clase Client es la siguiente:

   client.h

   #ifndef _CLIENT_H
   #define _CLIENT_H
   
   #include <QObject>
   #include <QSharedPointer>
   
   #include "rep_simpleswitch_replica.h"
   
   class Client : public QObject
   {
       Q_OBJECT
   public:
       Client(QSharedPointer<SimpleSwitchReplica> ptr);
       ~Client() override = default;
       void initConnections();// Function to connect signals and slots of source and client
   
   Q_SIGNALS:
       void echoSwitchState(bool switchState);// this signal is connected with server_slot(..) on the source object and echoes back switch state received from source
   
   public Q_SLOTS:
       void recSwitchState_slot(bool); // slot to receive source state
   private:
       bool clientSwitchState; // holds received server switch state
       QSharedPointer<SimpleSwitchReplica> reptr;// holds reference to replica
   
    };
   
   #endif

   client.cpp

   #include "client.h"// constructorClient::Client(QSharedPointer<SimpleSwitchReplica> ptr) : QObject(nullptr),reptr(ptr) { // Señal de conexión para la réplica inicializada con el slot de inicialización.initConnections(); // Podemos conectarnos a las señales/slots de SimpleSwitchReplica // directamente porque nuestra réplica fue generada por repc.}void Client::initConnections() { // inicializar conexiones entre señales y slots // conectar la señal de la réplica fuente currStateChanged() con el slot recSwitchState() del cliente para recibir el estado actual de la fuente.    QObject::connect(reptr.data(), &SimpleSwitchReplica::currStateChanged, this, &Client::recSwitchState_slot); //conecta  la señal echoSwitchState(..) del cliente con la ranura server_slot(..) de la réplica para devolver el estado recibido   QObject::connect(this, &Client::echoSwitchState, reptr.data(), &SimpleSwitchReplica::server_slot); }void Client::recSwitchState_slot(bool value){
       qDebug() << "Received source state "<< value << reptr.data()->currState();
       clientSwitchState = reptr.data()->currState(); Q_EMIT echoSwitchState(clientSwitchState); // Emite señal para devolver al servidor el estado recibido}

   Compilar y ejecutar este ejemplo junto con el ejemplo del lado fuente genera la siguiente salida: