extlibs/cereal/cereal/include/cereal/archives/binary.hpp

   1 /*! \file binary.hpp
   2     \brief Binary input and output archives */
   3 /*
   4   Copyright (c) 2014, Randolph Voorhies, Shane Grant
   5   All rights reserved.
   6
   7   Redistribution and use in source and binary forms, with or without
   8   modification, are permitted provided that the following conditions are met:
   9       * Redistributions of source code must retain the above copyright
  10         notice, this list of conditions and the following disclaimer.
  11       * Redistributions in binary form must reproduce the above copyright
  12         notice, this list of conditions and the following disclaimer in the
  13         documentation and/or other materials provided with the distribution.
  14       * Neither the name of cereal nor the
  15         names of its contributors may be used to endorse or promote products
  16         derived from this software without specific prior written permission.
  17
  18   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  19   ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  20   WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  21   DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES OR SHANE GRANT BE LIABLE FOR ANY
  22   DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  23   (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  24   LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  25   ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  26   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  27   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  28 */
  29 #ifndef CEREAL_ARCHIVES_BINARY_HPP_
  30 #define CEREAL_ARCHIVES_BINARY_HPP_
  31
  32 #include <cereal/cereal.hpp>
  33 #include <sstream>
  34
  35 namespace cereal
  36 {
  37   // ######################################################################
  38   //! An output archive designed to save data in a compact binary representation
  39   /*! This archive outputs data to a stream in an extremely compact binary
  40       representation with as little extra metadata as possible.
  41
  42       This archive does nothing to ensure that the endianness of the saved
  43       and loaded data is the same.  If you need to have portability over
  44       architectures with different endianness, use PortableBinaryOutputArchive.
  45
  46       When using a binary archive and a file stream, you must use the
  47       std::ios::binary format flag to avoid having your data altered
  48       inadvertently.
  49
  50       \ingroup Archives */
  51   class BinaryOutputArchive : public OutputArchive<BinaryOutputArchive, AllowEmptyClassElision>
  52   {
  53     public:
  54       //! Construct, outputting to the provided stream
  55       /*! @param stream The stream to output to.  Can be a stringstream, a file stream, or
  56                         even cout! */
  57       BinaryOutputArchive(std::ostream & stream) :
  58         OutputArchive<BinaryOutputArchive, AllowEmptyClassElision>(this),
  59         itsStream(stream)
  60       { }
  61
  62       //! Writes size bytes of data to the output stream
  63       void saveBinary( const void * data, std::size_t size )
  64       {
  65         auto const writtenSize = static_cast<std::size_t>( itsStream.rdbuf()->sputn( reinterpret_cast<const char*>( data ), size ) );
  66
  67         if(writtenSize != size)
  68           throw Exception("Failed to write " + std::to_string(size) + " bytes to output stream! Wrote " + std::to_string(writtenSize));
  69       }
  70
  71     private:
  72       std::ostream & itsStream;
  73   };
  74
  75   // ######################################################################
  76   //! An input archive designed to load data saved using BinaryOutputArchive
  77   /*  This archive does nothing to ensure that the endianness of the saved
  78       and loaded data is the same.  If you need to have portability over
  79       architectures with different endianness, use PortableBinaryOutputArchive.
  80
  81       When using a binary archive and a file stream, you must use the
  82       std::ios::binary format flag to avoid having your data altered
  83       inadvertently.
  84
  85       \ingroup Archives */
  86   class BinaryInputArchive : public InputArchive<BinaryInputArchive, AllowEmptyClassElision>
  87   {
  88     public:
  89       //! Construct, loading from the provided stream
  90       BinaryInputArchive(std::istream & stream) :
  91         InputArchive<BinaryInputArchive, AllowEmptyClassElision>(this),
  92         itsStream(stream)
  93     { }
  94
  95       //! Reads size bytes of data from the input stream
  96       void loadBinary( void * const data, std::size_t size )
  97       {
  98         auto const readSize = static_cast<std::size_t>( itsStream.rdbuf()->sgetn( reinterpret_cast<char*>( data ), size ) );
  99
 100         if(readSize != size)
 101           throw Exception("Failed to read " + std::to_string(size) + " bytes from input stream! Read " + std::to_string(readSize));
 102       }
 103
 104     private:
 105       std::istream & itsStream;
 106   };
 107
 108   // ######################################################################
 109   // Common BinaryArchive serialization functions
 110
 111   //! Saving for POD types to binary
 112   template<class T> inline
 113   typename std::enable_if<std::is_arithmetic<T>::value, void>::type
 114   save(BinaryOutputArchive & ar, T const & t)
 115   {
 116     ar.saveBinary(std::addressof(t), sizeof(t));
 117   }
 118
 119   //! Loading for POD types from binary
 120   template<class T> inline
 121   typename std::enable_if<std::is_arithmetic<T>::value, void>::type
 122   load(BinaryInputArchive & ar, T & t)
 123   {
 124     ar.loadBinary(std::addressof(t), sizeof(t));
 125   }
 126
 127   //! Serializing NVP types to binary
 128   template <class Archive, class T> inline
 129   CEREAL_ARCHIVE_RESTRICT(BinaryInputArchive, BinaryOutputArchive)
 130   serialize( Archive & ar, NameValuePair<T> & t )
 131   {
 132     ar( t.value );
 133   }
 134
 135   //! Serializing SizeTags to binary
 136   template <class Archive, class T> inline
 137   CEREAL_ARCHIVE_RESTRICT(BinaryInputArchive, BinaryOutputArchive)
 138   serialize( Archive & ar, SizeTag<T> & t )
 139   {
 140     ar( t.size );
 141   }
 142
 143   //! Saving binary data
 144   template <class T> inline
 145   void save(BinaryOutputArchive & ar, BinaryData<T> const & bd)
 146   {
 147     ar.saveBinary( bd.data, static_cast<std::size_t>( bd.size ) );
 148   }
 149
 150   //! Loading binary data
 151   template <class T> inline
 152   void load(BinaryInputArchive & ar, BinaryData<T> & bd)
 153   {
 154     ar.loadBinary(bd.data, static_cast<std::size_t>(bd.size));
 155   }
 156 } // namespace cereal
 157
 158 // register archives for polymorphic support
 159 CEREAL_REGISTER_ARCHIVE(cereal::BinaryOutputArchive)
 160 CEREAL_REGISTER_ARCHIVE(cereal::BinaryInputArchive)
 161
 162 #endif // CEREAL_ARCHIVES_BINARY_HPP_