An example which shows how to use C++ and DLLS to modify incoming data in an input port

Collaboration diagram for An example which shows how to use C++ and DLLS to modify incoming data in an input port:

Description

This example demonstrates how to simply use the port monitor carrier to modify data going through a connection. The port '/write' from 'yarp write' module is connected to the '/read' port of 'yarp read' using a portmonitor plugged into the receiver side. The portmoniotr loads a dll ('libsimple_monitor.so') in which we access and modify the data going through the port.

Requirements

• Enable and compile portmonitor carrier (ENABLE_yarpcar_portmonitor_carrier=ON in YARP cmake).

Running the example

• Open a terminal and follow the below instruction to compile and build the dll

     $ mkdir $YARP_ROOT/example/portmonitor/simple_dll/build
     $ cd $YARP_ROOT/example/portmonitor/simple_dll/build
     $ cmake ../; make;
  

you should see the 'libsimple_monitor.so' after the compilation (the generated dll can have different names on windows or mac os).

• Open a terminal and run yarpserver

     $ yarpserver
  

• Open another terminal (lets call this the sender terminal) and type

     $ yarp write /write
  

• In the directory where you you built the dll (lets call this the receiver terminal), type

     $ yarp read /read
  

• In another terminal connect the port as follow:

     $ yarp connect /write /read tcp+recv.portmonitor+type.dll+file.simple_monitor
  

Now if you write something in the 'sender' terminal, you will see the text "Modified in DLL" will be added to the original message. For example:

[sender terminal]
 Hello

[receiver terminal]
 Hello "Modified in DLL"

As it is constrained in ‘SimpleMonitorObject::accept()’ method from ‘Simple.cpp’, if you type "ignore", the message will be ignored by the portmonitor and it never be delivered to the input port.

Code Samples

SimpleMonitorObject.h

#include <yarp/os/MonitorObject.h>
 
class SimpleMonitorObject : public yarp::os::MonitorObject
{
public:
    bool create(const yarp::os::Property& options) override;
    void destroy() override;
 
    bool setparam(const yarp::os::Property& params) override;
    bool getparam(yarp::os::Property& params) override;
 
    void trig() override;
 
    bool accept(yarp::os::Things& thing) override;
    yarp::os::Things& update(yarp::os::Things& thing) override;
};

SimpleMonitorObject.cpp

#include "Simple.h"
 
#include <yarp/os/Bottle.h>
#include <yarp/os/SharedLibraryClass.h>
#include <yarp/os/Things.h>
 
#include <stdio.h>
 
YARP_DEFINE_SHARED_SUBCLASS(MonitorObject_there, SimpleMonitorObject, MonitorObject);
 
 
bool SimpleMonitorObject::create(const yarp::os::Property& options)
{
    printf("created!\n");
    printf("I am attached to the %s\n",
           (options.find("sender_side").asBool()) ? "sender side" : "receiver side");
    return true;
}
 
void SimpleMonitorObject::destroy()
{
    printf("destroyed!\n");
}
 
bool SimpleMonitorObject::setparam(const yarp::os::Property& params)
{
    return false;
}
 
bool SimpleMonitorObject::getparam(yarp::os::Property& params)
{
    return false;
}
 
bool SimpleMonitorObject::accept(yarp::os::Things& thing)
{
    auto* bt = thing.cast_as<yarp::os::Bottle>();
    if (bt == NULL) {
        printf("SimpleMonitorObject: expected type Bottle but got wrong data type!\n");
        return false;
    }
 
    if (bt->toString() == "ignore")
        return false;
    return true;
}
 
yarp::os::Things& SimpleMonitorObject::update(yarp::os::Things& thing)
{
    auto* bt = thing.cast_as<yarp::os::Bottle>();
    if (bt == NULL) {
        printf("SimpleMonitorObject: expected type Bottle but got wrong data type!\n");
        return thing;
    }
 
    bt->addString("Modified in DLL");
    return thing;
}
 
void SimpleMonitorObject::trig()
{
}