[boost] [serialization] Proposal to add support for lexical_cast

13 Jul 2005

      Hi,

I propose the addition of a lexical_cast wrapper to Boost.Serialization.

Motivating example:

Suppose you have several UDTs for which you already have defined
insertion/extraction operators, and you want to use Boost.Serialization
to read/write values of these UDTs, preferably in a non-intrusive way.

Problem:

Boost.Serialization doesn't make use of existing insertion/extraction
operators for the UDTs.

Proposed addition:

A Serialization Wrapper (similar to those described in
http://tinyurl.com/e46v5 [1]) that performs on-the-fly conversion of an
UDT value to some serializable type, usually a std::string. Code is
attached.

The proposed wrapper allows to specify a conversion that will be used
during serialization/deserialization operations. During serialization,
a value will get converted to a different type; the converted value is
written to the archive. During deserialization, the value is converted
back to the original type. The proposed wrapper uses boost::lexical cast
for the conversion.

Usage example:

  // udt.hpp
  struct udt { };
  std::ostream &operator<<(std::ostream &, udt const &);
  std::istream &operator>>(std::istream &, udt const &);

  // someclass.hpp
  #include "udt.hpp"
  #include <boost/serialization.hpp>

  struct someclass
  {
     template<typename Archive>
     void serialize(Archive &ar, const unsigned int version)
     {
       ar & boost::serialization::lexical_cast<std::string>(my_udt);
     }

  private:
     udt my_udt;
  };

Pros:
  - very easy to use
  - non-intrusive

Cons:
  - not very fast

Questions:
  - Would you consider this a useful addition?

  - Would the name boost::serialization::lexical_cast be acceptable?

  - Do you see a use case for using an "external" type other than
    std::string with this wrapper, e.g
      ar & boost::serialization::lexical_cast<int>(my_udt); // ?
    (The code could be simplified, otherwise)

  - Similar wrappers could be written for the C++ cast operations, too.
    Would such wrappers be useful?

  - Would it be desirable to extend this to a general
    conversion-on-the-fly framework?

  - Assuming there are some positive responses about the usefulness
    of the lexical_cast wrapper, would this addition be suitable for
    a fast-track review (it is very tiny)?
    (I'd say no if this evolves into a general conversion-on-the-fly
    framework)

  - other comments?

Thanks to Robert who helped me to understand my own code better.

Regards,
m

[1] http://boost.org/libs/serialization/doc/wrappers.html

//  (C) Copyright Martin Wille 2005. Distributed under the Boost
//  Software License, Version 1.0. (See http://www.boost.org/LICENSE_1_0.txt)

#ifndef BOOST_SERIALIZATION_LEXICAL_CAST_HPP
#define BOOST_SERIALIZATION_LEXICAL_CAST_HPP

#include <boost/lexical_cast.hpp>
#include <boost/serialization/traits.hpp>
#include <boost/serialization/split_member.hpp>

namespace boost { namespace serialization {

template <class T, class Intermediate = std::string>
struct lexical_cast_wrapper
    : traits
        <lexical_cast_wrapper<T, Intermediate>
        ,object_serializable
        , track_never
        >
{
    explicit lexical_cast_wrapper(T &t) : value(t) {}

    template <class Archive>
    void save(Archive &ar, unsigned int) const
    {
        Intermediate tmp((boost::lexical_cast<Intermediate>(value)));
        ar << tmp;
    }

    template <class Archive>
    void load(Archive &ar, unsigned int) const
    {
        Intermediate tmp;
        ar >> tmp;
        value = boost::lexical_cast<T>(tmp);
    }

    BOOST_SERIALIZATION_SPLIT_MEMBER();

private:
    T &value;
};

template <class Intermediate, class T>
lexical_cast_wrapper<T, Intermediate>
lexical_cast(T &value)
{
    return lexical_cast_wrapper<T, Intermediate>(value);
}

template <class T>
lexical_cast_wrapper<T>
lexical_cast(T &value)
{
    return lexical_cast_wrapper<T>(value);
}

}}

#endif