How to serialize a union within a struct using Boost library?

Question

I want to serialize and store the union which is declared within a struct and store it in the boost::message_queue since we can't store and retrieve struct object in the Message queue.

I have serialized and stored a structure like this and it is working fine.

typedef struct
{
  unsigned short m_short1;
  unsigned short m_short2;
  unsigned char m_character;

  template <typename Archive>
  void serialize(Archive& ar, const unsigned int version)
  {
    ar & m_short1;
    ar & m_short2;
    ar & m_character;
  }
} MyDataType;

But I want to store an structure object which has union and sub structure as shown below

typedef struct 
{
  int  msg_type;
  char msg_name[100];

  union
  {
    struct 
    {
        int     ID;
        char    ReportedTime[100];
        char    ReceivedAt[200];
        int     Number;

    } mess1;

    struct
    {
        char    host_ip[20];
        char    mac_addr[30];
        char    time_stamp[100];

    }mess2;

  }struct_type;

}msg_struct;

To serialize this I did like this.

typedef struct 
{
int  msg_type;
char msg_name[100];

union
{
    struct 
    {
        int     ID;
        char    ReportedTime[100];
        char    ReceivedAt[200];
        int     Number;

        template <typename Archive>
        void serialize(Archive& ar, const unsigned int version)
        {
            ar & ID;
            ar & DeviceReportedTime;
            ar & ReceivedAt;
            ar & Number;

        }
    } mess1;

    struct
    {
        char    host_ip[20];
        char    mac_addr[30];
        char    time_stamp[100];
        template <typename Archive>
        void serialize(Archive& ar, const unsigned int version)
        {
            ar & host_ip;

            ar & mac_addr;
            ar & time_stamp;
        }

    }mess2;
    template <typename Archive>
    void serialize(Archive& ar, const unsigned int version)
    {
        ar & mess1;
        ar & mess2;

    }

}struct_type;
template <typename Archive>
void serialize(Archive& ar, const unsigned int version)
{
        ar & msg_type;
        ar & msg_name;
        ar & struct_type;

}

}msg_struct;

Is it the correct way, But it is giving Following error

 from ControlQueue.cpp:1:
/usr/local/include/boost/archive/detail/check.hpp: In instantiation of ‘void          boost::archive::detail::check_object_level() [with T = msg_struct::<anonymous union>]’:
/usr/local/include/boost/archive/detail/iserializer.hpp:438:33:   required from ‘static void boost::archive::detail::load_non_pointer_type<Archive>::invoke(Archive&, T&) [with T = msg_struct::<anonymous union>; Archive = boost::archive::text_iarchive]’
/usr/local/include/boost/archive/detail/iserializer.hpp:592:24:   required from ‘void boost::archive::load(Archive&, T&) [with Archive = boost::archive::text_iarchive; T = msg_struct::<anonymous union>]’
/usr/local/include/boost/archive/detail/common_iarchive.hpp:66:40:   required from ‘void boost::archive::detail::common_iarchive<Archive>::load_override(T&, int) [with T = msg_struct::<anonymous union>; Archive = boost::archive::text_iarchive]’
/usr/local/include/boost/archive/basic_text_iarchive.hpp:65:9:   required from ‘void boost::archive::basic_text_iarchive<Archive>::load_override(T&, int) [with T = msg_struct::<anonymous union>; Archive = boost::archive::text_iarchive]’
/usr/local/include/boost/archive/text_iarchive.hpp:82:57:   required from ‘void boost::archive::text_iarchive_impl<Archive>::load_override(T&, int) [with T = msg_struct::<anonymous union>; Archive = boost::archive::text_iarchive]’
/usr/local/include/boost/archive/detail/interface_iarchive.hpp:60:9:   [ skipping 15 instantiation contexts, use -ftemplate-backtrace-limit=0 to disable ]
  /usr/local/include/boost/archive/detail/iserializer.hpp:592:24:   required from ‘void boost::archive::load(Archive&, T&) [with Archive = boost::archive::text_iarchive; T = msg_struct*]’
    /usr/local/include/boost/archive/detail/common_iarchive.hpp:66:40:   required from ‘void boost::archive::detail::common_iarchive<Archive>::load_override(T&, int) [with T = msg_struct*; Archive = boost::archive::text_iarchive]’
  /usr/local/include/boost/archive/basic_text_iarchive.hpp:65:9:   required from ‘void boost::archive::basic_text_iarchive<Archive>::load_override(T&, int) [with T = msg_struct*; Archive = boost::archive::text_iarchive]’
    /usr/local/include/boost/archive/text_iarchive.hpp:82:57:   required from ‘void boost::archive::text_iarchive_impl<Archive>::load_override(T&, int) [with T = msg_struct*; Archive = boost::archive::text_iarchive]’
 /usr/local/include/boost/archive/detail/interface_iarchive.hpp:60:9:   required from ‘Archive& boost::archive::detail::interface_iarchive<Archive>::operator>>(T&) [with T = msg_struct*; Archive = boost::archive::text_iarchive]’
 ControlQueue.cpp:177:15:   required from here
  /usr/local/include/boost/archive/detail/check.hpp:60:5: error: static assertion failed: typex::value
 BOOST_STATIC_ASSERT(typex::value);
 ^
 make: *** [ControlQueue.o] Error 1

note:I am using make file and included all the linking libraries.

How to solve this problem

Answer 1

I noticed that you spent a lot of effort keeping the structure POD. You can simply leverage this by using

BOOST_IS_BITWISE_SERIALIZABLE(msg_struct)

to get serialization done. Strangely this seems limited to arrays of POD, but the C++ standard lets us treat a single object as a single-element array, so we can:

struct msg_struct {
    int  msg_type;
    char msg_name[100];

    union X {
        struct {
            int     ID;
            char    ReportedTime[100];
            char    ReceivedAt[200];
            int     Number;
        } mess1;

        struct XB {
            char    host_ip[20];
            char    mac_addr[30];
            char    time_stamp[100];
        } mess2;
    } struct_type;
};

#include <boost/serialization/is_bitwise_serializable.hpp>
BOOST_IS_BITWISE_SERIALIZABLE(msg_struct)

Serialization/deserialization can be done: See it Live On Coliru

int main()
{
    std::stringstream ss;
    boost::archive::binary_oarchive oa(ss);

    msg_struct msg;

    strncpy(msg.msg_name,                       "msg_name",     sizeof(msg.msg_name));
    strncpy(msg.struct_type.mess1.ReportedTime, "ReportedTime", sizeof(msg.struct_type.mess1.ReportedTime));
    strncpy(msg.struct_type.mess1.ReceivedAt,   "ReceivedAt",   sizeof(msg.struct_type.mess1.ReceivedAt));
    strncpy(msg.struct_type.mess2.host_ip,      "host_ip",      sizeof(msg.struct_type.mess2.host_ip));
    strncpy(msg.struct_type.mess2.mac_addr,     "mac_addr",     sizeof(msg.struct_type.mess2.mac_addr));
    strncpy(msg.struct_type.mess2.time_stamp,   "time_stamp",   sizeof(msg.struct_type.mess2.time_stamp));

    oa << boost::serialization::make_array(&msg, 1);

    for(auto c : ss.str())
        std::cout << std::hex << std::setfill('0') << std::setw(2) << ((int) c);

    boost::archive::binary_iarchive ia(ss);
    ia >> boost::serialization::make_array(&msg, 1);
}

Full Code

struct msg_struct {
    int  msg_type;
    char msg_name[100];

    union X {
        struct {
            int     ID;
            char    ReportedTime[100];
            char    ReceivedAt[200];
            int     Number;
        } mess1;

        struct XB {
            char    host_ip[20];
            char    mac_addr[30];
            char    time_stamp[100];
        } mess2;
    } struct_type;
};

#include <boost/serialization/is_bitwise_serializable.hpp>
BOOST_IS_BITWISE_SERIALIZABLE(msg_struct)

#include <boost/archive/binary_oarchive.hpp>
#include <boost/archive/binary_iarchive.hpp>

#include <sstream>
#include <iostream>
#include <cstring>
#include <iomanip>

int main()
{
    std::stringstream ss;
    boost::archive::binary_oarchive oa(ss);

    msg_struct msg;

    strncpy(msg.msg_name,                       "msg_name",     sizeof(msg.msg_name));
    strncpy(msg.struct_type.mess1.ReportedTime, "ReportedTime", sizeof(msg.struct_type.mess1.ReportedTime));
    strncpy(msg.struct_type.mess1.ReceivedAt,   "ReceivedAt",   sizeof(msg.struct_type.mess1.ReceivedAt));
    strncpy(msg.struct_type.mess2.host_ip,      "host_ip",      sizeof(msg.struct_type.mess2.host_ip));
    strncpy(msg.struct_type.mess2.mac_addr,     "mac_addr",     sizeof(msg.struct_type.mess2.mac_addr));
    strncpy(msg.struct_type.mess2.time_stamp,   "time_stamp",   sizeof(msg.struct_type.mess2.time_stamp));

    oa << boost::serialization::make_array(&msg, 1);

    for(auto c : ss.str())
        std::cout << std::hex << std::setfill('0') << std::setw(2) << ((int) c);

    boost::archive::binary_iarchive ia(ss);
    ia >> boost::serialization::make_array(&msg, 1);
}