Example 1: Direct Connection using a Static Source

1. Create a source object

   To create this Source object, first we create the definition file, simpleswitch.rep. This file describes the properties and methods for the object and is input to the Qt Remote Objects Compiler repc. This file only defines interfaces that are necessary to expose to the Replicas.

   simpleswitch.rep

    

   Sélectionnez

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

   In simpleswitch.rep,

   • currState holds the current state of the switch.

   • server_slot() allows us to interact with the source - it will be connected to the echoSwitchState(bool newstate) signal.

   For repc to process this file, add the following line to your cmake file:

    

   Sélectionnez

   qt6_add_repc_sources(directconnectserver
       simpleswitch.rep
   )

   If you're using qmake:

    

   Sélectionnez

   REPC_SOURCE = simpleswitch.rep

   These instructions are only relevant for the Qt Remote Object module, so you need to add it to your project as well. If you're using CMake, add:

    

   Sélectionnez

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

   If you're using qmake:

    

   Sélectionnez

   QT       += remoteobjects

   repc creates the rep_SimpleSwitch_source.h header in the build directory that you specify. For more information, see Source.

   repc creates three helper classes for use with QtRO. For this example, we use the basic: SimpleSwitchSimpleSource. It's an abstract class, defined in rep_SimpleSwitch_source.h. We derive from it to define our SimpleSwitch implementation class as shown below:

   simpleswitch.h

    

   Sélectionnez

   #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

   In simpleswitch.h,

   • stateChangeTimer is a QTimer that is used to toggle the state of our SimpleSwitch.

   • timeout_slot() is connected to stateChangeTimer's timeout() signal.

   • server_slot() – which is called automatically on the source whenever any replica calls their version of the slot – outputs the received value.

   • currStateChanged(bool), defined in the repc-generated rep_SimpleSwitch_source.h, is emitted whenever currState toggles. In this example, we ignore the signal on the source side, and handle it later on the replica side.

   The definition of our SwitchState class is shown below:

   simpleswitch.cpp

    

   Sélectionnez

   #include "simpleswitch.h"
   
   // constructor
   SimpleSwitch::SimpleSwitch(QObject *parent) : SimpleSwitchSimpleSource(parent)
   {
       stateChangeTimer = new QTimer(this); // Initialize timer
       QObject::connect(stateChangeTimer, &SimpleSwitch::timeout, this, &SimpleSwitch::timeout_slot); // connect timeout() signal from stateChangeTimer to timeout_slot() of simpleSwitch
       stateChangeTimer->start(2000); // Start timer and set timout to 2 seconds
       qDebug() << "Source Node Started";
   }
   
   //destructor
   SimpleSwitch::~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()
   {
       // slot called on timer timeout
       if (currState()) // check if current state is true, currState() is defined in repc generated rep_simpleswitch_source.h
           setCurrState(false); // set state to false
       else
           setCurrState(true); // set state to true
       qDebug() << "Source State is "<<currState();
   
   }

2. Create a registry

   Because this example uses a direct connection between nodes, we can omit this step.

3. Create a host node

   The host node is created as shown below:

    

   Sélectionnez

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

4. Host source object and remoting

   The following statements instantiate the Source object and pass it on to the host to enable "remoting", which is the process of making an object visible to the QtRO network:

    

   Sélectionnez

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

   The contents of main.cpp file that implements the steps described above are as follows:

   main.cpp

    

   Sélectionnez

   #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();
   }

   Compile and run this source-side project. The output, without any replicas created, should look as shown below with the switch state toggling between true and false every two seconds.

   

The subsequent steps are for creating the replica side of the network, which in this example gets the state of switch from the Source and echoes it back.

Replica Code▲