Robert Ramey wrote:
The real question here is:
What else is supposed to be in this file? Do I need to put in the code
that loads and saves archives in this file?
And here is the answer.
I expect that BOOST_CLASS_EXPORT will be specified in the same
header file as the class declaration to which it corresponds. That is,
BOOST_CLASS_EXPORT(T) is a "trait" of the class. This trait
is the "external name" used to identify the class and is needed when
serializing polymorphic types through a base class pointer.
I expect that one's program will generally look like:
#include
....
#include "my_class.hpp" // which has BOOST_CLASS_EXPORT inside
In boost 1.35 (aka HEAD) these headers can be in any order. In 1.34
and earlier, the archive headers have to go before any headers which
contain BOOST_CLASS_EXPORT
Robert,
First, thank you very much for taking the time to answer my clueless
questions.
Second, I'm not sure what I get when I check out the boost files using
CVS, as instructed in the "Getting Started" section of the web site. Do
I have "HEAD" this way? If not, how do I get it?
Third, here is some code that reproduces my error. I'm sorry if it's a
bit overly complicated; I just don't know what exactly is causing the error.
#include
#include
#include
#include <fstream>
template <class ObjectType>
void save(const ObjectType& object,
const char* filename)
{
std::ofstream ofs(filename);
assert(ofs.good());
boost::archive::xml_oarchive oa(ofs);
oa << BOOST_SERIALIZATION_NVP(object);
}
template <class ObjectType>
void load(ObjectType& object,
const char* filename)
{
std::ifstream ifs(filename);
assert(ifs.good());
boost::archive::xml_iarchive ia(ifs);
ia >> BOOST_SERIALIZATION_NVP(object);
}
namespace A
{
namespace B
{
namespace C
{
struct Base
{
int type;
virtual ~Base()
{}
};
struct Point
:Base
{
double x;
};
}
}
}
#include
namespace boost
{
namespace serialization
{
using namespace A::B;
template<class Archive>
void serialize(Archive& ar,
C::Base& x,
const unsigned int version)
{
ar & BOOST_SERIALIZATION_NVP(x.type);
}
template<class Archive>
void serialize(Archive& ar,
C::Point& x,
const unsigned int version)
{
ar & make_nvp("Base",
base_object(x));
ar & BOOST_SERIALIZATION_NVP(x.x);
}
}
}
namespace A
{
namespace B
{
namespace C
{
BOOST_CLASS_EXPORT(Point);
}
}
}
#include
#include <list>
namespace A
{
namespace B
{
namespace C
{
struct Line
:Base
{
struct Item
{
bool flop;
boost::shared_ptr<Base> ptr;
};
double slope;
double intercept;
std::list<Item> items;
};
}
struct Object
{
struct Item
{
bool flip;
boost::shared_ptr ptr;
};
std::list<Item> items;
};
}
}
#include
#include
#include
namespace boost
{
namespace serialization
{
using namespace A::B;
template<class Archive>
void serialize(Archive& ar,
C::Line::Item& x,
const unsigned int version)
{
ar & BOOST_SERIALIZATION_NVP(x.flop);
ar & BOOST_SERIALIZATION_NVP(x.ptr);
}
template<class Archive>
void serialize(Archive& ar,
C::Line& x,
const unsigned int version)
{
ar & make_nvp("Security",
base_object(x));
ar & BOOST_SERIALIZATION_NVP(x.items);
}
template<class Archive>
void serialize(Archive& ar,
Object::Item& x,
const unsigned int version)
{
ar & BOOST_SERIALIZATION_NVP(x.flip);
ar & BOOST_SERIALIZATION_NVP(x.ptr);
}
template<class Archive>
void serialize(Archive& ar,
Object& x,
const unsigned int version)
{
ar & BOOST_SERIALIZATION_NVP(x.items);
}
}
}
namespace A
{
namespace B
{
namespace C
{
BOOST_CLASS_EXPORT(Line)
}
}
}
namespace A
{
namespace B
{
void Load(Object& object, const char* filename);
void Save(const Object& object, const char* filename);
void Load(Object& object, const char* filename)
{
load(object, filename);
}
void Save(const Object& object, const char* filename)
{
save(object, filename);
}
}
}
