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 the copyright holder 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 THE COPYRIGHT HOLDER OR CONTRIBUTORS 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::streamsize size )
66  {
67  auto const writtenSize = 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::streamsize size )
101  {
102  auto const readSize = 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
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
127  {
128  ar.loadBinary(std::addressof(t), sizeof(t));
129  }
130 
132  template <class Archive, class T> inline
133  CEREAL_ARCHIVE_RESTRICT(BinaryInputArchive, BinaryOutputArchive)
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
150  {
151  ar.saveBinary( bd.data, static_cast<std::streamsize>( bd.size ) );
152  }
153 
155  template <class T> inline
157  {
158  ar.loadBinary(bd.data, static_cast<std::streamsize>( bd.size ) );
159  }
160 } // namespace cereal
161 
162 // register archives for polymorphic support
165 
166 // tie input and output archives together
168 
169 #endif // CEREAL_ARCHIVES_BINARY_HPP_
cereal::InputArchive
The base input archive class.
Definition: cereal.hpp:710
cereal::BinaryOutputArchive
An output archive designed to save data in a compact binary representation.
Definition: binary.hpp:51
cereal::BinaryData::size
uint64_t size
size in bytes
Definition: helpers.hpp:222
cereal::BinaryInputArchive::loadBinary
void loadBinary(void *const data, std::streamsize size)
Reads size bytes of data from the input stream.
Definition: binary.hpp:100
CEREAL_ARCHIVE_RESTRICT
#define CEREAL_ARCHIVE_RESTRICT(INTYPE, OUTTYPE)
A macro to use to restrict which types of archives your function will work for.
Definition: traits.hpp:1315
CEREAL_SERIALIZE_FUNCTION_NAME
#define CEREAL_SERIALIZE_FUNCTION_NAME
The serialization/deserialization function name to search for.
Definition: macros.hpp:78
cereal::BinaryOutputArchive::saveBinary
void saveBinary(const void *data, std::streamsize size)
Writes size bytes of data to the output stream.
Definition: binary.hpp:65
cereal::BinaryData::data
PT data
pointer to beginning of data
Definition: helpers.hpp:221
CEREAL_LOAD_FUNCTION_NAME
#define CEREAL_LOAD_FUNCTION_NAME
The deserialization (load) function name to search for.
Definition: macros.hpp:85
CEREAL_REGISTER_ARCHIVE
#define CEREAL_REGISTER_ARCHIVE(Archive)
Registers a specific Archive type with cereal.
Definition: cereal.hpp:195
cereal::NameValuePair
For holding name value pairs.
Definition: helpers.hpp:139
cereal::OutputArchive
The base output archive class.
Definition: cereal.hpp:318
cereal::BinaryInputArchive
An input archive designed to load data saved using BinaryOutputArchive.
Definition: binary.hpp:88
CEREAL_SAVE_FUNCTION_NAME
#define CEREAL_SAVE_FUNCTION_NAME
The serialization (save) function name to search for.
Definition: macros.hpp:92
CEREAL_SETUP_ARCHIVE_TRAITS
#define CEREAL_SETUP_ARCHIVE_TRAITS(InputArchive, OutputArchive)
Sets up traits that relate an input archive to an output archive.
Definition: traits.hpp:169
cereal::BinaryData
A wrapper around data that can be serialized in a binary fashion.
Definition: helpers.hpp:211
CEREAL_NOEXCEPT
#define CEREAL_NOEXCEPT
Defines the CEREAL_NOEXCEPT macro to use instead of noexcept.
Definition: macros.hpp:130
cereal.hpp
Main cereal functionality.
cereal::SizeTag
A wrapper around size metadata.
Definition: helpers.hpp:312
cereal::Exception
An exception class thrown when things go wrong at runtime.
Definition: helpers.hpp:48
cereal::BinaryOutputArchive::BinaryOutputArchive
BinaryOutputArchive(std::ostream &stream)
Construct, outputting to the provided stream.
Definition: binary.hpp:57
cereal::BinaryInputArchive::BinaryInputArchive
BinaryInputArchive(std::istream &stream)
Construct, loading from the provided stream.
Definition: binary.hpp:92