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