Boost Serialization: Serialize/Export derived class without default constructor

Question

I need to serialize all the options on my CommunicationLayer, which is basically a wrapper around serial port, which I will use in an initialization file of sorts.

This class doesn't have a default constructor, but implements a pure virtual class. When I first ran this I got the exception that I didn't register/export the derived class. So I did that. But when I added the export I got the exception that it couldn't find a save/load function:

no matching function for call to ‘save(boost_1_69_0::archive::xml_oarchive&, const amp::communication::RS485CommunicationLayer&, const boost_1_69_0::serialization::version_type&)’
         save(ar, t, v);

This is true! But I can't use the save/load and use save_construct_data and load_construct_data, because the absence of a default constructor. How do I tell boost/serde to use these instead?? Is it the SPLIT_FREE macro?

I'm trying to work myself through the documentation, but it's really hard to find everything.

Following are the base and derived classes, I tried to shorten the derived class as much as possible.

//BASE
class ICommunicationLayer {
    friend class boost::serialization::access;
    template<class Archive>
    inline void serialize(Archive & ar, const unsigned int file_version) {};
public:
    virtual ~ICommunicationLayer();
    virtual std::size_t write(const char* const buffer, std::size_t buffSize) = 0;
    virtual std::size_t readUntil(std::vector<char>& buffer, char delim, std::chrono::microseconds timeout) = 0;
};

// DERIVED
#include "ICommunicationLayer.h"

#include <boost/asio.hpp>

#include <boost/serialization/access.hpp>
#include <boost/serialization/split_free.hpp>
#include <boost/serialization/export.hpp>
#include <boost/serialization/base_object.hpp>
#include <boost/serialization/nvp.hpp>
namespace amp {
namespace communication {

class RS485CommunicationLayer final : public ICommunicationLayer {
public:
    RS485CommunicationLayer(
            const std::string& path,
            unsigned int baud_rate,
            // other options
    );

    ~RS485CommunicationLayer();

    std::size_t write(const char* const buffer, const size_t size) override;
    std::size_t readUntil(std::vector<char>& buffer, char delim,std::chrono::microseconds timeout) override;
    std::string getPath() const;
private:
    friend class boost::serialization::access;
    std::string path;
  // rest of impl
};

} /* namespace communication */
} /* namespace amp */

BOOST_SERIALIZATION_SPLIT_FREE(amp::communication::RS485CommunicationLayer)
BOOST_CLASS_EXPORT(amp::communication::RS485CommunicationLayer)

namespace boost_1_69_0 {
namespace serialization {

template<class Archive>
inline void save_construct_data(Archive& ar, const amp::communication::RS485CommunicationLayer* comLayer, const unsigned int version) {
    ar << boost::serialization::make_nvp(
        BOOST_PP_STRINGIZE(amp::communication::ICommunicationLayer), 
        boost::serialization::base_object<amp::communication::ICommunicationLayer>(*comLayer)
    );

    ar << boost::serialization::make_nvp("path", const_cast<std::string>(comLayer->getPath());

    // other options
}

template<class Archive>
inline void load_construct_data(Archive& ar, amp::communication::RS485CommunicationLayer* comLayer, const unsigned int version) {
    ar >> boost::serialization::base_object<amp::communication::ICommunicationLayer>(*comLayer);

    std::string path;
    ar >> path;

    // other options

    new(comLayer) amp::communication::RS485CommunicationLayer(path, baudrate, /* other options */);
}
}

}

Answer 1

The construct data is an addition to regular serialization. You still need to serialize. As a matter of fact, serializing base_object needs to be in the constructed-object serialize implementation.

Also keep in mind that you need to EXPORT after including the relevant archive type(s).

You have a number of spots with redundant top-level const (even a const-cast). Top-level const on return type/arguments isn't part of the function signature.

Finally, I don't know what namespace boost_1_69_0 is, but that should not work. Use namespace boost. If you're playing with macros to define it like that, I'd suggest to stop doing that. Instead consider putting the overloads in the ADL-associated namespace for your types!

Here's the whole thing made self-contained and working:

Live On Coliru

#include <boost/serialization/access.hpp>
#include <boost/serialization/assume_abstract.hpp>
#include <boost/serialization/export.hpp>
#include <boost/serialization/serialization.hpp>

#include <boost/serialization/base_object.hpp>
#include <boost/serialization/vector.hpp>
#include <boost/serialization/shared_ptr.hpp>

#include <chrono>

// BASE
namespace amp::communication {
    using duration = std::chrono::steady_clock::duration;

    class ICommunicationLayer {
        friend class boost::serialization::access;
        template <class Archive> inline void serialize(Archive&, unsigned){}

      public:
        virtual ~ICommunicationLayer();
        virtual size_t write(char const* const buffer, size_t buffSize)                   = 0;
        virtual size_t readUntil(std::vector<char>& buffer, char delim, duration timeout) = 0;
    };
} // namespace amp::communication

// DERIVED
//#include "ICommunicationLayer.h"

#include <boost/asio.hpp>

#include <boost/serialization/access.hpp>
#include <boost/serialization/base_object.hpp>
#include <boost/serialization/export.hpp>
#include <boost/serialization/nvp.hpp>
#include <boost/serialization/split_free.hpp>

namespace amp { namespace communication {

    class RS485CommunicationLayer final : public ICommunicationLayer {
      public:
        RS485CommunicationLayer(std::string const& path, unsigned baud_rate)
            : path(path)
            , baud_rate(baud_rate) {}

        ~RS485CommunicationLayer();

        size_t      write(char const* const buffer, const size_t size) override;
        size_t      readUntil(std::vector<char>& buffer, char delim, duration timeout) override;
        std::string getPath() const { return path; }
        unsigned    getBaudrate() const { return baud_rate; }

      private:
        friend class boost::serialization::access;
        template <typename Ar> void serialize(Ar& ar, unsigned) {
            ar& boost::make_nvp("ICommunicationLayer",
                                boost::serialization::base_object<ICommunicationLayer>(*this));
        }

        std::string path;
        unsigned    baud_rate;
        // rest of impl
    };

    // ADL resolved overloads
    template <class Archive>
    inline void save_construct_data(Archive& ar, RS485CommunicationLayer const* p, unsigned) {
        auto path = p->getPath();
        unsigned baud_rate = p->getBaudrate();
        ar& BOOST_NVP(path) & BOOST_NVP(baud_rate);
    }

    template <class Archive>
    inline void load_construct_data(Archive& ar, RS485CommunicationLayer* p, unsigned) {
        std::string path;
        unsigned baud_rate;
        ar >> BOOST_NVP(path) >> BOOST_NVP(baud_rate);
        new (p) RS485CommunicationLayer(path, baud_rate);
    }
}} // namespace amp::communication

BOOST_SERIALIZATION_ASSUME_ABSTRACT(amp::communication::ICommunicationLayer)

#include <boost/archive/xml_iarchive.hpp>
#include <boost/archive/xml_oarchive.hpp>
#include <iostream>
#include <sstream>
BOOST_CLASS_EXPORT(amp::communication::ICommunicationLayer)
BOOST_CLASS_EXPORT(amp::communication::RS485CommunicationLayer)

int main() {
    using namespace amp::communication;
    using Ptr = std::shared_ptr<ICommunicationLayer>;

    std::vector<Ptr> ptrs{nullptr, std::make_shared<RS485CommunicationLayer>("hello", 115'200)}, roundtrip;
    ptrs.push_back(ptrs.back()); // one duplicate for testing purposes

    std::stringstream xml;
    {
        boost::archive::xml_oarchive oa(xml);
        oa << boost::make_nvp("root", ptrs);
    }

    std::cout << xml.str();
    {
        boost::archive::xml_iarchive ia(xml);
        ia >> boost::make_nvp("root", roundtrip);
    }

    bool verify = roundtrip.size() == ptrs.size();
    verify &= (roundtrip.at(0) == nullptr);
    verify &= (roundtrip.at(1) == roundtrip.at(2));

    std::cout << "Roundtrip verify " << (verify?"OK":"FAILED") << std::endl;
}

// to satisfy linker
namespace amp { namespace communication {
    ICommunicationLayer::~ICommunicationLayer()         = default;
    RS485CommunicationLayer::~RS485CommunicationLayer() = default;
    size_t RS485CommunicationLayer::write(char const*, size_t) { return 0; }
    size_t RS485CommunicationLayer::readUntil(std::vector<char>&, char, duration) { return 0; }
}} // namespace amp::communication

Prints

<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<!DOCTYPE boost_serialization>
<boost_serialization signature="serialization::archive" version="19">
<root class_id="0" tracking_level="0" version="0">
    <count>3</count>
    <item_version>1</item_version>
    <item class_id="1" tracking_level="0" version="1">
        <px class_id="-1"></px>
    </item>
    <item>
        <px class_id="2" class_name="amp::communication::RS485CommunicationLayer" tracking_level="1" version="0" object_id="_0">
            <path>hello</path>
            <baud_rate>115200</baud_rate>
            <ICommunicationLayer class_id="3" tracking_level="0" version="0"></ICommunicationLayer>
        </px>
    </item>
    <item>
        <px class_id_reference="2" object_id_reference="_0"></px>
    </item>
</root>
</boost_serialization>

Roundtrip verify OK

Afterthought

Perhaps the best location for load/save construct data is as hidden friends. That way you don't even need public accessors for every bit of construct-data:

Live On Coliru

class RS485CommunicationLayer final : public ICommunicationLayer {
  public:
    RS485CommunicationLayer(std::string const& path, unsigned baud_rate)
        : path(path)
        , baud_rate(baud_rate) {}

    ~RS485CommunicationLayer() override;

    size_t write(char const* const buffer, const size_t size) override;
    size_t readUntil(std::vector<char>& buffer, char delim, duration timeout) override;

  private:
    std::string path;
    unsigned    baud_rate;
    // rest of impl

    template <class Archive>
    friend void save_construct_data(Archive& ar, RS485CommunicationLayer const* p, unsigned) {
        auto     path      = p->path;
        unsigned baud_rate = p->baud_rate;
        ar&      BOOST_NVP(path) & BOOST_NVP(baud_rate);
    }

    template <class Archive>
    friend void load_construct_data(Archive& ar, RS485CommunicationLayer* p, unsigned) {
        std::string path;
        unsigned    baud_rate;
        ar >> BOOST_NVP(path) >> BOOST_NVP(baud_rate);
        new (p) RS485CommunicationLayer(path, baud_rate);
    }

    friend class boost::serialization::access;
    template <typename Ar> void serialize(Ar& ar, unsigned) {
        ar& boost::make_nvp("ICommunicationLayer",
                            boost::serialization::base_object<ICommunicationLayer>(*this));
    }
};