How to Publish std::stringstream & receive it on other side.

[piyushmz]

How do I publish a std::stringstream? following is my implementation. Please also give an idea how subscriber will receive it.

#include <sstream>
#include<string>
#include "iceoryx_dust/posix_wrapper/signal_watcher.hpp"
#include "iceoryx_posh/popo/publisher.hpp"
#include "iceoryx_posh/runtime/posh_runtime.hpp"

constexpr char APP_NAME[] = "iox-cpp-publisher-vector";

int main()
{
    // initialize runtime
    iox::runtime::PoshRuntime::initRuntime(APP_NAME);

    // initialize publisher
    //! [create publisher]
    iox::popo::Publisher<std::stringstream> publisher({"Radar", "FrontRight", "VectorData"});
    //! [create publisher]

    while (!iox::posix::hasTerminationRequested())
    {
        std::string s = "This is hello world and I want to send it to the publish this";
        auto tR = publisher.loan();
        std::stringstream stm;
        
        if (!tR.has_error())
        {
            auto& sample = tR.value();
            // sample->stm;
            sample->stm(s);
            sample.publish();
            std::cout << "This is ok\n";
        }
        else
            std::cout << "not OK\n";

        std::this_thread::sleep_for(std::chrono::seconds(1));
    }

    return (EXIT_SUCCESS);
}

[elBoberido]

@piyushmz a std::stringstream cannot be transferred via shared memory since it uses the heap. What you probably can do is to use our iox::cxx::string with a fixed capacity. You should be able to get a char* from the data of the string string and use the iox::cxx::string like iox::cxx::string<100> str{iox::cxx::TruncateToCapacity, stm.str().c_str()};. You just need to use a capacity which suits your needs.

[mossmaurice]

@piyushmz Besides the heap restriction you can find few more in this article. If you want to learn more about iceoryx's shared memory mechanism, refer to this article.

[piyushmz]

@elBoberido @mossmaurice I've the following structs defined. I've tried a lot of things but I'm not able to publish & receive this. If you have any better option for structuring this thing please do suggest. I want to publish Lanes and then pick these values by subscriber.
I've tried protobuf but I'm not able to convert this struct in proto file.
I've also tried vector of vector and that is working fine in iceoryx. So just need some help how this could be done or restructured so that I can easily send the data.

struct lane_coordinate
{
    float32_t x;
    float32_t y;
};

struct lane
{
    iox::cxx::vector<lane_coordinate, 100> l;
    uint32_t ptsPL;
};

struct lanePerFrame
{
    iox::cxx::vector<lane,100> lanes;
};

struct Lanes
{
    iox::cxx::vector<int,100> camID;
    iox::cxx::vector<lanePerFrame,100> lanepf;
};

Thanks.

[piyushmz]

@elfenpiff I was getting the same error but I thought it was my mistake so got a bit frustrated then switched to ecal and implemented with protobuf it worked(This also took a lot of my time). Now I'll try this and check it in my code. Now I've two good options over here for IPC.
Thank you so much. You were of great help. Thanks

[saftabrashid]

Hi,

I have a similar issue which is mentioned in the original post. I am trying to publish a simple std::string data using Iceoryx. I understand that I have to use the iox::string implementation of Iceoryx. Using iox::string I am able to publish dummy data, e.g., by using something as follows

iox::string<3> mystr = "ABC";

I am able to publish this string and I received it at the subscriber. However, in my actual application I have a std::string type data, e.g., message that I need to transmit. I have been trying several method from the iox::string implementation to convert my std::string to the Iceoryx iox::string but I am not able to do it successfully. Can anyone point me out how can I do it? My code looks as follows

`
std::string mymessage;
/* build the message content and put some content in it*/

I have tried several methods using assign, unsafe_assign, TruncateToCapacity, etc but none of them seems to work, e.g., the following does not work

iox::string<100> mystr{(iox::TruncateToCapacity, mymessage.c_str())};

`

[elfenpiff]

@saftabrashid could you explain in more detail what does not work.

iox::string<100> mystr{(iox::TruncateToCapacity, mymessage.c_str())};

This is exactly how you should convert a std::string to an iox::string<100>. What it does behind the scenes is that it copies 100 bytes into the iox::string and truncates the std::string if it has a size larger than 100. If you require a string with more capacity, you can increase the capacity number, for instance, to 1024 by writing iox::string<1024>.

[saftabrashid]

Thanks for the response. Actually, this line works, there was a problem with the paranthesis. The line below works
iox::string<100> mypayload2{iox::TruncateToCapacity, message.c_str()};. However, for this, I have to create another variable in this case mypayload2, and then assign it back to my original payload.

Also, I found another way to do it using something like sample->mypayload.unsafe_assign(message.c_str());, where mypayload is the iox::string and message is std::string. I assume this is unsafe because it does not check the length of the message and may cause an error if the length of the message is larger than the length of mypayload . For reference my code looks as follows

struct IceoryxPayload { iox::string<100> mypayload; };
Publisher

/*Create a Iceoryx runtime*/

 /*Create a publisher*/

while (running)
{
publisher.loan()
                .and_then([&](auto &sample)
{

/*create std::string message and put some data in it*/

sample->mypayload.unsafe_assign(message.c_str());
                std::cout <<"Published: "<< sample->mypayload << std::endl;
                sample.publish(); })
                .or_else([](auto &error)
                         {
                // Do something with error. = "ABC";
                std::cerr << "Unable to loan sample, error: " << error << std::endl; });

}
}

The publisher now works. Now my problem is when I receive the iox::string mypayload at the subscriber how can I convert it back to std::string? My subscriber looks as follows

Subscriber

/*Create a Iceoryx runtime*/

 /*Create a subscriber*/

while (running)
{
subscriber.take()
                //! [sample happy path]
                .and_then([](auto& sample)
                          {
                            //! [print sample info]
                             std::cout << " got value: " << sample->mypayload<< std::endl; // the print seems to be fine

                           // Now how to convert the mypayload back to a std::string??

                         std::string message(sample->mypayload); // This does not work? 
                           
})
                //! [sample happy path]
                .or_else([](auto &result)
                         {
                // only has to be called if the alternative is of interest,
                // i.e. if nothing has to happen when no data is received and
                // a possible error alternative is not checked or_else is not needed
                if (result == iox::popo::ChunkReceiveResult::NO_CHUNK_AVAILABLE)
                {
                    std::cout << "Error receiving chunk." << std::endl;
                } });



}

[elfenpiff]

I assume this is unsafe because it does not check the length of the message and may cause an error if the length of the message is larger than the length of mypayload.

You are correct.

I assume your payload type is iox::string:

Now how to convert the mypayload back to a std::string??

std::string message(sample->mypayload.c_str()); // add .c_str()

If it is possible for you to avoid the usage of std::string and just use iox::string in this context, it would provide you with a performance boost and a little less code to write. Performance boost since you are copying the data once into the shared memory and then on subscriber you copy it out, when calling the std::string constructor. When you use iox::string you could write your data once into the payload and just read it on subscriber side.