I've been trying to use boost::serialization to serialize non-standard
strings. Specifically, std::basic_string with a non-standard allocator
type, and in another case, boost::interprocess::basic_string.
Looking at how std::string serialization was enabled in
serialization/string.hpp, I thought I would try to broaden that
approach by using a specialization of the implementation_level
template as follows:
namespace boost {
namespace serialization {
template
struct implementation_level< std::basic_string >
{
typedef mpl::integral_c_tag tag;
typedef mpl::int_< boost::serialization::primitive_type > type;
BOOST_STATIC_CONSTANT(
int,
value = implementation_level::type::value
);
};
} // namespace
} // namespace
I've tried also adding wraper traits (also in boost::serialization namespace):
template
struct is_wrapper< std::basic_string > : mpl::true_ {};
Serialization of these strings is compiling, and
running. At first it looked like it worked, but not quite.
Specifically: when the string in question is 16 bytes or less in size
(including the \0), the string serializes fine. When longer than
that, its value appears to be completely truncated. (I'm looking at
the dump of a binary_oarchive.) This isn't the case for std::string,
but I'm having a problem figuring out why.
I realize this is an unconventional scenario, but any assistance on
how to make the support for string serialization apply to more than
just std::string is appreciated.
(Perhaps this should be ticketed as a feature request?)
