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  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  // ######################################################################
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:
90  BinaryInputArchive(std::istream & stream) :
91  InputArchive<BinaryInputArchive, AllowEmptyClassElision>(this),
92  itsStream(stream)
93  { }
94 
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 
112  template<class T> inline
113  typename std::enable_if<std::is_arithmetic<T>::value, void>::type
115  {
116  ar.saveBinary(std::addressof(t), sizeof(t));
117  }
118 
120  template<class T> inline
121  typename std::enable_if<std::is_arithmetic<T>::value, void>::type
123  {
124  ar.loadBinary(std::addressof(t), sizeof(t));
125  }
126 
128  template <class Archive, class T> inline
131  {
132  ar( t.value );
133  }
134 
136  template <class Archive, class T> inline
138  CEREAL_SERIALIZE_FUNCTION_NAME( Archive & ar, SizeTag<T> & t )
139  {
140  ar( t.size );
141  }
142 
144  template <class T> inline
146  {
147  ar.saveBinary( bd.data, static_cast<std::size_t>( bd.size ) );
148  }
149 
151  template <class T> inline
153  {
154  ar.loadBinary(bd.data, static_cast<std::size_t>(bd.size));
155  }
156 } // namespace cereal
157 
158 // register archives for polymorphic support
161 
162 // tie input and output archives together
164 
165 #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
PT data
pointer to beginning of data
Definition: helpers.hpp:217
A wrapper around size metadata.
Definition: helpers.hpp:250
The base input archive class.
Definition: cereal.hpp:584
#define CEREAL_SERIALIZE_FUNCTION_NAME
The serialization/deserialization function name to search for.
Definition: macros.hpp:51
An input archive designed to load data saved using BinaryOutputArchive.
Definition: binary.hpp:86
Definition: access.hpp:39
#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:1260
BinaryInputArchive(std::istream &stream)
Construct, loading from the provided stream.
Definition: binary.hpp:90
Main cereal functionality.
For holding name value pairs.
Definition: helpers.hpp:135
#define CEREAL_LOAD_FUNCTION_NAME
The deserialization (load) function name to search for.
Definition: macros.hpp:58
void saveBinary(const void *data, std::size_t size)
Writes size bytes of data to the output stream.
Definition: binary.hpp:63
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:96
A wrapper around data that can be serialized in a binary fashion.
Definition: helpers.hpp:207
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:65
uint64_t size
size in bytes
Definition: helpers.hpp:218
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