LCOV - code coverage report
Current view: top level - cereal/archives - binary.hpp (source / functions) Hit Total Coverage
Test: coverage.info Lines: 31 33 93.9 %
Date: 2017-02-12 13:57:59 Functions: 49 49 100.0 %

          Line data    Source code
       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        3502 :       BinaryOutputArchive(std::ostream & stream) :
      58             :         OutputArchive<BinaryOutputArchive, AllowEmptyClassElision>(this),
      59        3502 :         itsStream(stream)
      60        3502 :       { }
      61             : 
      62        3502 :       ~BinaryOutputArchive() CEREAL_NOEXCEPT = default;
      63             : 
      64             :       //! Writes size bytes of data to the output stream
      65     2516561 :       void saveBinary( const void * data, std::size_t size )
      66             :       {
      67     2516561 :         auto const writtenSize = static_cast<std::size_t>( itsStream.rdbuf()->sputn( reinterpret_cast<const char*>( data ), size ) );
      68             : 
      69     2516561 :         if(writtenSize != size)
      70           0 :           throw Exception("Failed to write " + std::to_string(size) + " bytes to output stream! Wrote " + std::to_string(writtenSize));
      71     2516561 :       }
      72             : 
      73             :     private:
      74             :       std::ostream & itsStream;
      75             :   };
      76             : 
      77             :   // ######################################################################
      78             :   //! An input archive designed to load data saved using BinaryOutputArchive
      79             :   /*  This archive does nothing to ensure that the endianness of the saved
      80             :       and loaded data is the same.  If you need to have portability over
      81             :       architectures with different endianness, use PortableBinaryOutputArchive.
      82             : 
      83             :       When using a binary archive and a file stream, you must use the
      84             :       std::ios::binary format flag to avoid having your data altered
      85             :       inadvertently.
      86             : 
      87             :       \ingroup Archives */
      88             :   class BinaryInputArchive : public InputArchive<BinaryInputArchive, AllowEmptyClassElision>
      89             :   {
      90             :     public:
      91             :       //! Construct, loading from the provided stream
      92        3502 :       BinaryInputArchive(std::istream & stream) :
      93             :         InputArchive<BinaryInputArchive, AllowEmptyClassElision>(this),
      94        3502 :         itsStream(stream)
      95        3502 :       { }
      96             : 
      97        3502 :       ~BinaryInputArchive() CEREAL_NOEXCEPT = default;
      98             : 
      99             :       //! Reads size bytes of data from the input stream
     100     2515561 :       void loadBinary( void * const data, std::size_t size )
     101             :       {
     102     2515561 :         auto const readSize = static_cast<std::size_t>( itsStream.rdbuf()->sgetn( reinterpret_cast<char*>( data ), size ) );
     103             : 
     104     2515561 :         if(readSize != size)
     105           0 :           throw Exception("Failed to read " + std::to_string(size) + " bytes from input stream! Read " + std::to_string(readSize));
     106     2515561 :       }
     107             : 
     108             :     private:
     109             :       std::istream & itsStream;
     110             :   };
     111             : 
     112             :   // ######################################################################
     113             :   // Common BinaryArchive serialization functions
     114             : 
     115             :   //! Saving for POD types to binary
     116             :   template<class T> inline
     117             :   typename std::enable_if<std::is_arithmetic<T>::value, void>::type
     118     2455060 :   CEREAL_SAVE_FUNCTION_NAME(BinaryOutputArchive & ar, T const & t)
     119             :   {
     120     2455060 :     ar.saveBinary(std::addressof(t), sizeof(t));
     121     2455060 :   }
     122             : 
     123             :   //! Loading for POD types from binary
     124             :   template<class T> inline
     125             :   typename std::enable_if<std::is_arithmetic<T>::value, void>::type
     126     2454060 :   CEREAL_LOAD_FUNCTION_NAME(BinaryInputArchive & ar, T & t)
     127             :   {
     128     2454060 :     ar.loadBinary(std::addressof(t), sizeof(t));
     129     2454060 :   }
     130             : 
     131             :   //! Serializing NVP types to binary
     132             :   template <class Archive, class T> inline
     133             :   CEREAL_ARCHIVE_RESTRICT(BinaryInputArchive, BinaryOutputArchive)
     134             :   CEREAL_SERIALIZE_FUNCTION_NAME( Archive & ar, NameValuePair<T> & t )
     135             :   {
     136             :     ar( t.value );
     137             :   }
     138             : 
     139             :   //! Serializing SizeTags to binary
     140             :   template <class Archive, class T> inline
     141             :   CEREAL_ARCHIVE_RESTRICT(BinaryInputArchive, BinaryOutputArchive)
     142      141402 :   CEREAL_SERIALIZE_FUNCTION_NAME( Archive & ar, SizeTag<T> & t )
     143             :   {
     144      141402 :     ar( t.size );
     145      141402 :   }
     146             : 
     147             :   //! Saving binary data
     148             :   template <class T> inline
     149       61501 :   void CEREAL_SAVE_FUNCTION_NAME(BinaryOutputArchive & ar, BinaryData<T> const & bd)
     150             :   {
     151       61501 :     ar.saveBinary( bd.data, static_cast<std::size_t>( bd.size ) );
     152       61501 :   }
     153             : 
     154             :   //! Loading binary data
     155             :   template <class T> inline
     156       61501 :   void CEREAL_LOAD_FUNCTION_NAME(BinaryInputArchive & ar, BinaryData<T> & bd)
     157             :   {
     158       61501 :     ar.loadBinary(bd.data, static_cast<std::size_t>(bd.size));
     159       61501 :   }
     160             : } // namespace cereal
     161             : 
     162             : // register archives for polymorphic support
     163             : CEREAL_REGISTER_ARCHIVE(cereal::BinaryOutputArchive)
     164             : CEREAL_REGISTER_ARCHIVE(cereal::BinaryInputArchive)
     165             : 
     166             : // tie input and output archives together
     167             : CEREAL_SETUP_ARCHIVE_TRAITS(cereal::BinaryInputArchive, cereal::BinaryOutputArchive)
     168             : 
     169             : #endif // CEREAL_ARCHIVES_BINARY_HPP_

Generated by: LCOV version 1.11