cereal
A C++11 library for serialization
binary.hpp
Go to the documentation of this file.
1 
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  // ######################################################################
39 
51  class BinaryOutputArchive : public OutputArchive<BinaryOutputArchive, AllowEmptyClassElision>
52  {
53  public:
55 
57  BinaryOutputArchive(std::ostream & stream) :
58  OutputArchive<BinaryOutputArchive, AllowEmptyClassElision>(this),
59  itsStream(stream)
60  { }
61 
63 
65  void saveBinary( const void * data, std::size_t size )
66  {
67  auto const writtenSize = static_cast<std::size_t>( itsStream.rdbuf()->sputn( reinterpret_cast<const char*>( data ), size ) );
68 
69  if(writtenSize != size)
70  throw Exception("Failed to write " + std::to_string(size) + " bytes to output stream! Wrote " + std::to_string(writtenSize));
71  }
72 
73  private:
74  std::ostream & itsStream;
75  };
76 
77  // ######################################################################
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:
92  BinaryInputArchive(std::istream & stream) :
93  InputArchive<BinaryInputArchive, AllowEmptyClassElision>(this),
94  itsStream(stream)
95  { }
96 
98 
100  void loadBinary( void * const data, std::size_t size )
101  {
102  auto const readSize = static_cast<std::size_t>( itsStream.rdbuf()->sgetn( reinterpret_cast<char*>( data ), size ) );
103 
104  if(readSize != size)
105  throw Exception("Failed to read " + std::to_string(size) + " bytes from input stream! Read " + std::to_string(readSize));
106  }
107 
108  private:
109  std::istream & itsStream;
110  };
111 
112  // ######################################################################
113  // Common BinaryArchive serialization functions
114 
116  template<class T> inline
117  typename std::enable_if<std::is_arithmetic<T>::value, void>::type
118  CEREAL_SAVE_FUNCTION_NAME(BinaryOutputArchive & ar, T const & t)
119  {
120  ar.saveBinary(std::addressof(t), sizeof(t));
121  }
122 
124  template<class T> inline
125  typename std::enable_if<std::is_arithmetic<T>::value, void>::type
126  CEREAL_LOAD_FUNCTION_NAME(BinaryInputArchive & ar, T & t)
127  {
128  ar.loadBinary(std::addressof(t), sizeof(t));
129  }
130 
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 
140  template <class Archive, class T> inline
141  CEREAL_ARCHIVE_RESTRICT(BinaryInputArchive, BinaryOutputArchive)
142  CEREAL_SERIALIZE_FUNCTION_NAME( Archive & ar, SizeTag<T> & t )
143  {
144  ar( t.size );
145  }
146 
148  template <class T> inline
149  void CEREAL_SAVE_FUNCTION_NAME(BinaryOutputArchive & ar, BinaryData<T> const & bd)
150  {
151  ar.saveBinary( bd.data, static_cast<std::size_t>( bd.size ) );
152  }
153 
155  template <class T> inline
156  void CEREAL_LOAD_FUNCTION_NAME(BinaryInputArchive & ar, BinaryData<T> & bd)
157  {
158  ar.loadBinary(bd.data, static_cast<std::size_t>(bd.size));
159  }
160 } // namespace cereal
161 
162 // register archives for polymorphic support
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_
#define CEREAL_SETUP_ARCHIVE_TRAITS(InputArchive, OutputArchive)
Sets up traits that relate an input archive to an output archive.
Definition: traits.hpp:169
STL namespace.
The base input archive class.
Definition: cereal.hpp:599
#define CEREAL_SERIALIZE_FUNCTION_NAME
The serialization/deserialization function name to search for.
Definition: macros.hpp:78
An input archive designed to load data saved using BinaryOutputArchive.
Definition: binary.hpp:88
Definition: access.hpp:40
#define CEREAL_REGISTER_ARCHIVE(Archive)
Registers a specific Archive type with cereal.
Definition: cereal.hpp:141
#define CEREAL_ARCHIVE_RESTRICT(INTYPE, OUTTYPE)
A macro to use to restrict which types of archives your function will work for.
Definition: traits.hpp:1293
BinaryInputArchive(std::istream &stream)
Construct, loading from the provided stream.
Definition: binary.hpp:92
Main cereal functionality.
#define CEREAL_LOAD_FUNCTION_NAME
The deserialization (load) function name to search for.
Definition: macros.hpp:85
#define CEREAL_NOEXCEPT
Defines the CEREAL_NOEXCEPT macro to use instead of noexcept.
Definition: macros.hpp:130
void saveBinary(const void *data, std::size_t size)
Writes size bytes of data to the output stream.
Definition: binary.hpp:65
BinaryOutputArchive(std::ostream &stream)
Construct, outputting to the provided stream.
Definition: binary.hpp:57
void loadBinary(void *const data, std::size_t size)
Reads size bytes of data from the input stream.
Definition: binary.hpp:100
The base output archive class.
Definition: cereal.hpp:234
#define CEREAL_SAVE_FUNCTION_NAME
The serialization (save) function name to search for.
Definition: macros.hpp:92
An exception class thrown when things go wrong at runtime.
Definition: helpers.hpp:48
An output archive designed to save data in a compact binary representation.
Definition: binary.hpp:51