Boost serialization of an empty std::forward_list - c++

Question

I'm using Boost 1.59.0 to serialize objects (let's call them Foo) in a std::forward_list<Foo>. However, I am unable to do this in cases where std::forward_list<Foo> is empty. To demonstrate my problem I have extended the "Very simple case" from Boost's serialization tutorial.
#include <fstream>
#include <unordered_map>
#include <forward_list>
#include <boost/archive/text_oarchive.hpp>
#include <boost/archive/text_iarchive.hpp>
#include <boost/serialization/unordered_map.hpp>
#include <boost/serialization/forward_list.hpp>
class Foo
{
private:
friend class boost::serialization::access;
template<class Archive>
void serialize(Archive & ar, const unsigned int)
{
ar & a;
ar & b;
}
int a;
int b;
public:
Foo()
: a(-1), b(-1) {}
Foo(int new_a, int new_b)
: a(new_a), b(new_b) {}
};
typedef std::forward_list<Foo> TListType;
class gps_position
{
private:
friend class boost::serialization::access;
template<class Archive>
void serialize(Archive & ar, const unsigned int)
{
ar & degrees;
ar & minutes;
ar & seconds;
ar & my_list;
}
int degrees;
int minutes;
float seconds;
TListType my_list;
public:
gps_position(){};
gps_position(int d, int m, float s, TListType new_list) :
degrees(d), minutes(m), seconds(s), my_list(new_list)
{}
};
int main()
{
std::ofstream ofs("filename");
TListType my_list(0);
// my_list.push_front(Foo(-1,-1));
const gps_position g(35, 59, 24.567f, my_list);
{
// save data
boost::archive::text_oarchive oa(ofs);
oa << g;
}
gps_position newg;
{
std::ifstream ifs("filename");
boost::archive::text_iarchive ia(ifs);
ia >> newg;
}
return 0;
}
This code compiles with g++ 4.8.3, however running it throws:
terminate called after throwing an instance of
'boost::archive::archive_exception'
what(): input stream error
Aborted (core dumped)
If we add one element to the list by uncommenting this line
// my_list.push_front(Foo(-1,-1));
no exception is thrown and everything seems to work. If I replace std::forward_list<Foo> with std::forward_list<int> in the above code then the code also works. Additionally, using std::list<Foo> or std::vector<Foo> also works, so the problem seems to be exclusive to std::forward_list.
Question: How can I serialize empty std::forward_list<Foo> without inserting dummy Foo objects?

Answer 1

Try closing the ofstream before reading from the file. Best way, move ofs inside the "// save data" block:
{
// save data
std::ofstream ofs("filename");
boost::archive::text_oarchive oa(ofs);
oa << g;
}
My guess is, with no data the write is smaller than the ofstream buffer and the file is physically empty/incomplete at the time of reading.
This is a flaw in the "very simple case" example, if you ask me.

Answer 2

This is caused by a bug in boost (still there in boost 1.67, explanation and patch here: https://svn.boost.org/trac10/ticket/13563). It's triggered by certain combinations of compiler and default constructors in the list elements.
As a workaround you can serialize a flag indicating if the list is empty. You need to split the serialize function into 'save' and 'load', e.g.:
template<typename Archive>
void save(Archive& ar, const unsigned int version) const
{
ar << degrees;
ar << minutes;
ar << seconds;
bool empty = nodes_.empty(); // workaround
ar << empty;
if (!empty)
ar << nodes_;
}
template<typename Archive>
void load(Archive& ar, const unsigned int version)
{
ar >> degrees;
ar >> minutes;
ar >> seconds;
bool empty; // workaround
ar >> empty;
if (!empty)
ar >> my_list;
}
BOOST_SERIALIZATION_SPLIT_MEMBER()