Question

Description:

I have a C++ class named GenericMessage which simply holds an id and data as its members (See code snippet 1 below – GenericMessage.hxx). My intention is to serialize an instance of this class and send it via a ZeroMQ socket which implements the push pattern.

The serialization and sending task has been implemented in class ZMQHandler (see sendToBE function) which is placed in a header file name ZMQHandler.hxx shown in the code snippet 2 below. This class is instantiated by TestFE.cxx shown in the 3rd code snippet below.

The receiving and de-serialization of the GenericMessage instance is implemented in TestBE.cxx available in the 4th code snippet below. My intentiton is to receive the GenericMessage instance over the ZMQ socket (i.e. pull socket), de-serialize it and then print its members.

Problem:

The problem is that when I compile TestBE.cxx, I am having a number of compilation errors involving template functions. Considering the code in TestBE.cxx, can anyone tell me what I am missing in de-serialization part that is marked with comments in the 4th code snippets? I am relatively a new C++ programmer and wonder how I should interpret these template functions related compilation errors which have been listed at the bottom of this text (i.e. the final snippet). Line 18 where the compilation error originates is marked in the 4th code snippet. Thanks.

CODE SNIPPET 1 (GenericMessage.hxx)

#include <iostream>
#include <string>
#include <sstream>
#include <boost/serialization/serialization.hpp>
#include <boost/archive/binary_oarchive.hpp>
#include <boost/archive/binary_iarchive.hpp>
#include <boost/archive/text_oarchive.hpp>
#include <boost/archive/text_iarchive.hpp>

template <class T>
class GenericMessage {
public:
      GenericMessage(): 
      beId(-1), data(NULL)
      {}

      GenericMessage(int id, T msg): beId(id), data(msg)
      {}

     ~GenericMessage(){}

     T getData()
     {
       return data;
     }


     std::string toString()
     {
        std::ostringstream ss;
        ss << getBeId();
        std::string ret =  ss.str();

        return ret;
      }

      void setBeId(int id)
      {
        beId = id;
      }

      int getBeId()
      {
        return beId;
      }


      private:
            friend class boost::serialization::access;

            int beId;
            T data;

            template <class Archieve>
            void serialize(Archieve & ar, const unsigned int version)
            {
               ar & beId;
               ar & data;
            }

 };

CODE SNIPPET 2 (ZMQHandler.hxx)

 #include "zmq.hpp"
 #include "GenericMessage.hxx"
 #include <pthread.h>
 #include <unistd.h>
 #include <cassert>

template <class A>
class ZmqHandler {
public:

       ZmqHandler():
   mContext(1),
   mOutbHandlerSocket(mContext, ZMQ_PUSH)
       {    
            mOutbHandlerSocket.bind ("tcp://*:5555");       
       }

       ~ZmqHandler() {}

        void sendToBE(GenericMessage<A> &theMsg)
        {
           std::stringstream ss(std::ios_base::binary| std::ios_base::out|  std::ios_base::in);
           boost::archive::binary_oarchive oa(ss, boost::archive::no_header);
           oa << theMsg;

           zmq::message_t msgToSend(sizeof(ss));

           memcpy(msgToSend.data(), ss.str().data(), ss.str().length());
           if(memcmp(msgToSend.data(), ss.str().data(), ss.str().length()) != 0)
           {
               printf("memcpy error\n");
           }

           mOutbHandlerSocket.send(msgToSend);
           std::cout << "SENT request: [" << theMsg.toString() << "]" << std::endl;
}   

    private:  
          zmq::context_t mContext;
          zmq::socket_t mOutbHandlerSocket;         
};

CODE SNIPPET 3 (TestFE.cxx)

 #include "ZmqHandler.hxx"

 int main ()
 {
   ZmqHandler<std::string> zmqHandler;
   int counter = 1;

   while(1)
   {  
     std::string data = "Hello there!\0";
     GenericMessage<std::string> msg(counter, data);
     zmqHandler.sendToBE(msg);
     counter++;
     sleep(1);
    }

    return 0;
 }     

CODE SNIPPET 4 (TestBE.cxx)

 #include "zmq.hpp"
 #include "GenericMessage.hxx"
 #include <fstream>

 int main ()
 {
    //  Prepare our context and socket
    zmq::context_t context (1);
    zmq::socket_t socket (context, ZMQ_PULL);

   std::cout << "Connecting to FE..." << std::endl;
   socket.connect ("tcp://localhost:5555");

   while(1){
       zmq::message_t reply;
       socket.recv (&reply);

       /* !!!!!!! LINE 18 starts HERE !!!!!!! */
       std::stringstream is(reply.data(), std::ios_base::binary| std::ios_base::out| std::ios_base::in);
       boost::archive::binary_iarchive ia(is, boost::archive::no_header);

       GenericMessage<std::string> msg;
       ia >> msg;

       std::cout << "RECEIVED: " << msg.toString() << std::endl;
       std::cout << "DATA: " << ((std::string)msg.getData())  << std::endl;
    }

     return 0;
 }

Compilation OUTPUT of TestBE.cxx

 g++ -g -c TestBE.cxx GenericMessage.hxx
 TestBE.cxx: In function ‘int main()’:
 TestBE.cxx:18:104: error: invalid user-defined conversion from ‘void*’ to ‘const  __string_type& {aka const std::basic_string<char>&}’ [-fpermissive]
       In file included from /usr/include/c++/4.7/string:55:0,
             from /usr/include/c++/4.7/bits/locale_classes.h:42,
             from /usr/include/c++/4.7/bits/ios_base.h:43,
             from /usr/include/c++/4.7/ios:43,
             from /usr/include/c++/4.7/ostream:40,
             from /usr/include/c++/4.7/iostream:40,
             from GenericMessage.hxx:1,
             from TestBE.cxx:2:
  /usr/include/c++/4.7/bits/basic_string.tcc:214:5: note: candidate is:     std::basic_string<_CharT, _Traits, _Alloc>::basic_string(const _CharT*, const _Alloc&)  [with _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>] <near  match>
  /usr/include/c++/4.7/bits/basic_string.tcc:214:5: note:   no known conversion for argument 1 from ‘void*’ to ‘const char*’
  TestBE.cxx:18:104: error: invalid conversion from ‘void*’ to ‘const char*’ [-fpermissive]
       In file included from /usr/include/c++/4.7/string:55:0,
             from /usr/include/c++/4.7/bits/locale_classes.h:42,
             from /usr/include/c++/4.7/bits/ios_base.h:43,
             from /usr/include/c++/4.7/ios:43,
             from /usr/include/c++/4.7/ostream:40,
             from /usr/include/c++/4.7/iostream:40,
             from GenericMessage.hxx:1,
             from TestBE.cxx:2:
       /usr/include/c++/4.7/bits/basic_string.tcc:214:5: error:   initializing argument 1 of ‘std::basic_string<_CharT, _Traits, _Alloc>::basic_string(const _CharT*, const _Alloc&) [with _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>]’ [-fpermissive]
       make: *** [TestBE.o] Error 1

Answer 1

I would say the error message is quite clear : the constructor of stringstream needs either type openmode or std::string, and you passed a parameter of type void* (the return of reply.data()).

You could dump received message into a binary file instead, but you’d still need to do some casting.