serialization.h

Go to the documentation of this file.

/*
 * Copyright 2006-2008 Savarese Software Research Corporation
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.savarese.com/software/ApacheLicense-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef __SSRC_WISP_SERIALIZATION_H
#define __SSRC_WISP_SERIALIZATION_H

#include <ssrc/wisp-packages.h>
#include <ssrc/spread/detail/ByteBuffer.h>

#include <utility>

#include <boost/iostreams/stream.hpp>
#include <boost/iostreams/device/array.hpp>

#include <boost/archive/binary_iarchive.hpp>
#include <boost/archive/binary_oarchive.hpp>

#include <boost/serialization/split_free.hpp>
#include <boost/serialization/binary_object.hpp>

#define __BEGIN_BOOST_SERIALIZATION \
namespace boost { \
  namespace serialization { 

#define __END_BOOST_SERIALIZATION \
  } \
}

__BEGIN_NS_SSRC_WISP

using NS_SSRC_SPREAD::detail::ByteBuffer;

namespace detail {
  template<typename Ch, typename mode_type = boost::iostreams::seekable>
  class array_device_adapter {
  public:
    typedef Ch char_type;
    typedef std::pair<char_type*, char_type*>  pair_type;

    struct category :
      public mode_type,
      public boost::iostreams::device_tag,
      public boost::iostreams::direct_tag
    { };

  private:
    char_type *_begin, *_end;

  public:

    array_device_adapter() : _begin(0), _end(0) { }

    array_device_adapter(char_type* begin, char_type* end) :
      _begin(begin), _end(end)
    { }

    array_device_adapter(char_type* begin, std::size_t size) :
      _begin(begin), _end(begin + size)
    { }

    void init(char_type* begin, char_type* end) {
      _begin = begin;
      _end   = end;
    }

    void init(char_type* begin, std::size_t size) {
      _begin = begin;
      _end   = begin + size;
    }

    void set_size(std::size_t size) {
      _end = _begin + size;
    }

    pair_type input_sequence() {
      return pair_type(_begin, _end);
    }

    pair_type output_sequence() {
      return pair_type(_begin, _end);
    }
  };

  typedef array_device_adapter<char> char_array_source;
  typedef array_device_adapter<char> char_array_sink;

  // This class is an unfortunately required workaround for a change
  // and possible bug in Boost 1.42.0 which causes stream_buffer::open to
  // throw an "already open" exception even if the buffer has been closed.
  template<typename DeviceAdapter>
  struct char_array_streambuf :
    public boost::iostreams::stream_buffer<DeviceAdapter>
  {
    typedef boost::iostreams::stream_buffer<DeviceAdapter> super;
    typedef
    boost::iostreams::detail::direct_streambuf<DeviceAdapter,
                                               typename super::traits_type>
    direct_streambuf;

    void open(const DeviceAdapter & device_adapter) {
      direct_streambuf::open(device_adapter, 0, 0);
    }
  };

  typedef char_array_streambuf<char_array_source> char_array_source_buffer;
  typedef char_array_streambuf<char_array_sink> char_array_sink_buffer;
}

template<typename Archive>
class Packer {
public:
  typedef detail::char_array_sink sink_type; 
  typedef detail::char_array_sink_buffer sink_buffer;
  typedef Archive output_archive;

protected:
  sink_type _sink;
  sink_buffer _out_buf;

public:

  template<typename T>
  unsigned int pack(const T & obj, ByteBuffer & buffer,
                    const unsigned int archive_flags =
                    boost::archive::no_header | boost::archive::no_codecvt |
                    boost::archive::no_tracking)
    SSRC_DECL_THROW(boost::archive::archive_exception, std::ios_base::failure)
  {
    unsigned int offset, bytes_written;

    _sink.init(&buffer[0], buffer.capacity());
    _out_buf.open(_sink);
    _out_buf.pubseekoff(buffer.offset(), std::basic_ios<sink_buffer>::beg);

    output_archive out_ar(_out_buf, archive_flags);
    out_ar << obj;

    offset = _out_buf.pubseekoff(0, std::basic_ios<sink_buffer>::cur);
    bytes_written = offset - buffer.offset();
    buffer.resize(offset);
    buffer.seek(offset);

    return bytes_written;
  }
};

template<typename Archive>
class Unpacker {
public:
  typedef detail::char_array_source source_type; 
  typedef detail::char_array_sink_buffer source_buffer;
  typedef Archive input_archive;

protected:
  source_type _source;
  source_buffer _in_buf;

public:

  template<typename T>
  unsigned int unpack(T & obj, ByteBuffer & buffer,
                      const unsigned int archive_flags =
                      boost::archive::no_header | boost::archive::no_codecvt |
                      boost::archive::no_tracking)
    SSRC_DECL_THROW(boost::archive::archive_exception, std::ios_base::failure)
  {
    unsigned int bytes_read(0);

    if(buffer.size() > 0) {
      unsigned int offset;

      _source.init(&buffer[0], buffer.size());
      _in_buf.open(_source);
      _in_buf.pubseekoff(buffer.offset(), std::basic_ios<source_buffer>::beg);

      input_archive in_ar(_in_buf, archive_flags);
      in_ar >> obj;

      offset = _in_buf.pubseekoff(0, std::basic_ios<source_buffer>::cur);
      bytes_read = offset - buffer.offset();
      buffer.seek(offset);
    }

    return bytes_read;
  }


  template<typename T>
  unsigned int unpack(T & obj, const void *buffer, unsigned int size,
                      const unsigned int archive_flags =
                      boost::archive::no_header | boost::archive::no_codecvt |
                      boost::archive::no_tracking)
    SSRC_DECL_THROW(boost::archive::archive_exception, std::ios_base::failure)
  {
    unsigned int bytes_read(0);

    if(size > 0) {
      _source.init(static_cast<typename detail::char_array_source::char_type *>(const_cast<void *>(buffer)), size);
      _in_buf.open(_source);
      _in_buf.pubseekoff(0, std::basic_ios<source_buffer>::beg);

      input_archive in_ar(_in_buf, archive_flags);
      in_ar >> obj;

      bytes_read = _in_buf.pubseekoff(0, std::basic_ios<source_buffer>::cur);
    }

    return bytes_read;
  }
};

template<typename P, typename U>
struct PackingTraits {
  typedef P packer_type;
  typedef U unpacker_type;
};

typedef Packer<boost::archive::binary_oarchive> BinaryPacker;
typedef Unpacker<boost::archive::binary_iarchive> BinaryUnpacker;
typedef PackingTraits<BinaryPacker, BinaryUnpacker> BinaryPackingTraits;

__END_NS_SSRC_WISP

__BEGIN_BOOST_SERIALIZATION

template<class Archive>
inline
void save_construct_data(Archive & ar,
                         const NS_SSRC_SPREAD::detail::ByteBuffer *buffer,
                         const unsigned int)
{
  // Could use capacity, but lets keep it as small as we can.
  ar << buffer->size();
}

template<class Archive>
inline
void load_construct_data(Archive & ar,
                         NS_SSRC_SPREAD::detail::ByteBuffer *buffer,
                         const unsigned int)
{
  unsigned int capacity;

  ar >> capacity;
  ::new(buffer)NS_SSRC_SPREAD::detail::ByteBuffer(capacity);
}

template<class Archive>
inline void save(Archive & ar,
                 const NS_SSRC_SPREAD::detail::ByteBuffer & buffer,
                 const unsigned int)
{
  unsigned int size = buffer.size();

  ar & size;

  if(size > 0) {
    const binary_object obj(&buffer[0], size);
    unsigned int offset = buffer.offset();
    ar & offset & obj;
  }
}

template<class Archive>
inline void load(Archive & ar,
                 NS_SSRC_SPREAD::detail::ByteBuffer & buffer,
                 const unsigned int)
{
  unsigned int size;

  ar & size;

  buffer.resize(size);

  if(size > 0) {
    binary_object obj(&buffer[0], size);
    unsigned int offset;
    ar & offset & obj;
    buffer.seek(offset);
  } else
    buffer.rewind();
}

__END_BOOST_SERIALIZATION

BOOST_SERIALIZATION_SPLIT_FREE(NS_SSRC_SPREAD::detail::ByteBuffer)

#endif