// Copyright (C) 2005 Davis E. King (davis@dlib.net)
// License: Boost Software License See LICENSE.txt for the full license.
#ifndef DLIB_SERIALIZe_
#define DLIB_SERIALIZe_
/*!
There are two global functions in the dlib namespace that provide
serialization and deserialization support. Their signatures and specifications
are as follows:
void serialize (
const serializable_type& item,
std::ostream& out
);
/!*
ensures
- writes the state of item to the output stream out
- if (serializable_type implements the enumerable interface) then
- item.at_start() == true
throws
- serialization_error
This exception is thrown if there is some problem which prevents
us from successfully writing item to the output stream.
- any other exception
*!/
void deserialize (
serializable_type& item,
std::istream& in
);
/!*
ensures
- #item == a deserialized copy of the serializable_type that was
in the input stream in.
- if (serializable_type implements the enumerable interface) then
- item.at_start() == true
throws
- serialization_error
This exception is thrown if there is some problem which prevents
us from successfully deserializing item from the input stream.
If this exception is thrown then item will have an initial value
for its type.
- any other exception
*!/
This file provides serialization support to the following object types:
- The C++ base types (NOT including pointer types)
- std::string
- std::wstring
- std::vector
- std::map
- std::pair
- std::complex
- dlib::uint64
- dlib::int64
- enumerable<T> where T is a serializable type
- map_pair<D,R> where D and R are both serializable types.
- C style arrays of serializable types
This file provides deserialization support to the following object types:
- The C++ base types (NOT including pointer types)
- std::string
- std::wstring
- std::vector
- std::map
- std::pair
- std::complex
- dlib::uint64
- dlib::int64
- C style arrays of serializable types
Support for deserialization of objects which implement the enumerable or
map_pair interfaces is the responsibility of those objects.
Note that you can deserialize an integer value to any integral type (except for a
char type) if its value will fit into the target integer type. I.e. the types
short, int, long, unsigned short, unsigned int, unsigned long, and dlib::uint64
can all receive serialized data from each other so long as the actual serizlied
value fits within the receiving integral type's range.
Also note that for any container to be serializable the type of object it contains
must be serializable.
FILE STREAMS
If you are serializing to and from file streams it is important to
remember to set the file streams to binary mode using the std::ios::binary
flag.
INTEGRAL SERIALIZATION FORMAT
All C++ integral types (except the char types) are serialized to the following
format:
The first byte is a control byte. It tells you if the serialized number is
positive or negative and also tells you how many of the following bytes are
part of the number. The absolute value of the number is stored in little
endian byte order and follows the control byte.
The control byte:
The high order bit of the control byte is a flag that tells you if the
encoded number is negative or not. It is set to 1 when the number is
negative and 0 otherwise.
The 4 low order bits of the control byte represent an unsigned number
and tells you how many of the following bytes are part of the encoded
number.
!*/
#include "algs.h"
#include "assert.h"
#include <iomanip>
#include <cstddef>
#include <iostream>
#include <string>
#include <vector>
#include <complex>
#include <map>
#include <limits>
#include "uintn.h"
#include "interfaces/enumerable.h"
#include "interfaces/map_pair.h"
#include "enable_if.h"
#include "unicode.h"
namespace dlib
{
// ----------------------------------------------------------------------------------------
class serialization_error : public error
{
public:
serialization_error(const std::string& e):error(e) {}
};
// ----------------------------------------------------------------------------------------
namespace ser_helper
{
template <
typename T
>
typename enable_if_c<std::numeric_limits<T>::is_signed,bool>::type pack_int (
T item,
std::ostream& out
)
/*!
requires
- T is a signed integral type
ensures
- if (no problems occur serializing item) then
- writes item to out
- returns false
- else
- returns true
!*/
{
COMPILE_TIME_ASSERT(sizeof(T) <= 8);
unsigned char buf[8];
unsigned char size = 0;
unsigned char neg;
if (item < 0)
{
neg = 0x80;
item *= -1;
}
else
{
neg = 0;
}
for (unsigned char i = 0; i < sizeof(T); ++i)
{
buf[i] = static_cast<unsigned char>(item&0xFF);
item >>= 8;
if (item == 0) { size = i+1; break; }
}
if (size == 0)
size = sizeof(T);
size |= neg;
out.write(reinterpret_cast<char*>(&size),1);
size &= 0x7F; // strip off the neg flag
out.write(reinterpret_cast<char*>(buf),size);
// check if there was an error
if (!out)
return true;
else
return false;
}
// ------------------------------------------------------------------------------------
template <
typename T
>
typename enable_if_c<std::numeric_limits<T>::is_signed,bool>::type unpack_int (
T& item,
std::istream& in
)
/*!
requires
- T is a signed integral type
ensures
- if (there are no problems deserializing item) then
- returns false
- #item == the value stored in in
- else
- returns true
!*/
{
COMPILE_TIME_ASSERT(sizeof(T) <= 8);
unsigned char buf[8];
unsigned char size;
bool is_negative;
item = 0;
in.read(reinterpret_cast<char*>(&size),1);
// check if an error occurred
if (!in)
return true;
if (size&0x80)
is_negative = true;
else
is_negative = false;
size &= 0x0F;
// check if the serialized object is too big
if (size > sizeof(T))
return true;
in.read(reinterpret_cast<char*>(&buf),size);
// check if there was an error reading from in.
if (!in)
return true;
for (unsigned char i = size-1; true; --i)
{
item <<= 8;
item |= buf[i];
if (i == 0)
break;
}
if (is_negative)
item *= -1;
return false;
}
// ------------------------------------------------------------------------------------
template <
typename T
>
typename disable_if_c<std::numeric_limits<T>::is_signed,bool>::type pack_int (
T item,
std::ostream& out
)
/*!
requires
- T is an unsigned integral type
ensures
- if (no problems occur serializing item) then
- writes item to out
- returns false
- else
- returns true
!*/
{
COMPILE_TIME_ASSERT(sizeof(T) <= 8);
unsigned char buf[8];
unsigned char size = 0;
for (unsigned char i = 0; i < sizeof(T); ++i)
{
buf[i] = static_cast<unsigned char>(item&0xFF);
item >>= 8;
if (item == 0) { size = i+1; break; }
}
if (size == 0)
size = sizeof(T);
out.write(reinterpret_cast<char*>(&size),1);
out.write(reinterpret_cast<char*>(buf),size);
// check if there was an error
if (!out)
return true;
else
return false;
}
// ------------------------------------------------------------------------------------
template <
typename T
>
typename disable_if_c<std::numeric_limits<T>::is_signed,bool>::type unpack_int (
T& item,
std::istream& in
)
/*!
requires
- T is an unsigned integral type
ensures
- if (there are no problems deserializing item) then
- returns false
- #item == the value stored in in
- else
- returns true
!*/
{
COMPILE_TIME_ASSERT(sizeof(T) <= 8);
unsigned char buf[8];
unsigned char size;
item = 0;
in.read(reinterpret_cast<char*>(&size),1);
// mask out the 3 reserved bits
size &= 0x8F;
// check if an error occurred
if (!in || size > sizeof(T))
return true;
in.read(reinterpret_cast<char*>(&buf),size);
// check if the serialized object is too big to fit into something of type T.
// or if there was an error reading from in.
if (!in)
return true;
for (unsigned char i = size-1; true; --i)
{
item <<= 8;
item |= buf[i];
if (i == 0)
break;
}
return false;
}
}
// ----------------------------------------------------------------------------------------
#define USE_DEFAULT_INT_SERIALIZATION_FOR(T) \
inline void serialize (const T& item, std::ostream& out) \
{ if (ser_helper::pack_int(item,out)) throw serialization_error("Error serializing object of type " + std::string(#T)); } \
inline void deserialize (T& item, std::istream& in) \
{ if (ser_helper::unpack_int(item,in)) throw serialization_error("Error deserializing object of type " + std::string(#T)); }
#define USE_DEFAULT_BYTE_SERIALIZATION_FOR(T) \
inline void serialize (const T& item,std::ostream& out) \
{ out.write(reinterpret_cast<const char*>(&item),1); if (!out) throw serialization_error("Error serializing object of type " + std::string(#T)); } \
inline void deserialize (T& item, std::istream& in) \
{ in.read(reinterpret_cast<char*>(&item),1); if (!in) throw serialization_error("Error deserializing object of type " + std::string(#T)); }
// ----------------------------------------------------------------------------------------
USE_DEFAULT_INT_SERIALIZATION_FOR(short)
USE_DEFAULT_INT_SERIALIZATION_FOR(int)
USE_DEFAULT_INT_SERIALIZATION_FOR(long)
USE_DEFAULT_INT_SERIALIZATION_FOR(unsigned short)
USE_DEFAULT_INT_SERIALIZATION_FOR(unsigned int)
USE_DEFAULT_INT_SERIALIZATION_FOR(unsigned long)
USE_DEFAULT_INT_SERIALIZATION_FOR(uint64)
USE_DEFAULT_INT_SERIALIZATION_FOR(int64)
USE_DEFAULT_BYTE_SERIALIZATION_FOR(char)
USE_DEFAULT_BYTE_SERIALIZATION_FOR(signed char)
USE_DEFAULT_BYTE_SERIALIZATION_FOR(unsigned char)
// Don't define serialization for wchar_t when using visual studio and
// _NATIVE_WCHAR_T_DEFINED isn't defined since if it isn't they improperly set
// wchar_t to be a typedef rather than its own type as required by the C++
// standard.
#if !defined(_MSC_VER) || _NATIVE_WCHAR_T_DEFINED
USE_DEFAULT_INT_SERIALIZATION_FOR(wchar_t)
#endif
// ----------------------------------------------------------------------------------------
template <typename T>
inline bool serialize_floating_point (
const T& item,
std::ostream& out
)
{
std::ios::fmtflags oldflags = out.flags();
out.flags();
std::streamsize ss = out.precision(35);
if (item == std::numeric_limits<T>::infinity())
out << "inf ";
else if (item == -std::numeric_limits<T>::infinity())
out << "ninf ";
else if (item < std::numeric_limits<T>::infinity())
out << item << ' ';
else
out << "NaN ";
out.flags(oldflags);
out.precision(ss);
return (!out);
}
template <typename T>
inline bool deserialize_floating_point (
T& item,
std::istream& in
)
{
std::ios::fmtflags oldflags = in.flags();
in.flags();
std::streamsize ss = in.precision(35);
if (in.peek() == 'i')
{
item = std::numeric_limits<T>::infinity();
in.get();
in.get();
in.get();
}
else if (in.peek() == 'n')
{
item = -std::numeric_limits<T>::infinity();
in.get();
in.get();
in.get();
in.get();
}
else if (in.peek() == 'N')
{
item = std::numeric_limits<T>::quiet_NaN();
in.get();
in.get();
in.get();
}
else
{
in >> item;
}
in.flags(oldflags);
in.precision(ss);
return (in.get() != ' ');
}
inline void serialize ( const float& item, std::ostream& out)
{
if (serialize_floating_point(item,out))
throw serialization_error("Error serializing object of type float");
}
inline void deserialize (float& item, std::istream& in)
{
if (deserialize_floating_point(item,in))
throw serialization_error("Error deserializing object of type float");
}
inline void serialize ( const double& item, std::ostream& out)
{
if (serialize_floating_point(item,out))
throw serialization_error("Error serializing object of type double");
}
inline void deserialize (double& item, std::istream& in)
{
if (deserialize_floating_point(item,in))
throw serialization_error("Error deserializing object of type double");
}
inline void serialize ( const long double& item, std::ostream& out)
{
if (serialize_floating_point(item,out))
throw serialization_error("Error serializing object of type long double");
}
inline void deserialize ( long double& item, std::istream& in)
{
if (deserialize_floating_point(item,in))
throw serialization_error("Error deserializing object of type long double");
}
// ----------------------------------------------------------------------------------------
// prototypes
template <typename domain, typename range, typename compare, typename alloc>
void serialize (
const std::map<domain,range, compare, alloc>& item,
std::ostream& out
);
template <typename domain, typename range, typename compare, typename alloc>
void deserialize (
std::map<domain, range, compare, alloc>& item,
std::istream& in
);
template <typename T, typename alloc>
void serialize (
const std::vector<T,alloc>& item,
std::ostream& out
);
template <typename T, typename alloc>
void deserialize (
std::vector<T,alloc>& item,
std::istream& in
);
inline void serialize (
const std::string& item,
std::ostream& out
);
inline void deserialize (
std::string& item,
std::istream& in
);
template <
typename T
>
inline void serialize (
const enumerable<T>& item,
std::ostream& out
);
template <
typename domain,
typename range
>
inline void serialize (
const map_pair<domain,range>& item,
std::ostream& out
);
template <
typename T,
size_t length
>
inline void serialize (
const T (&array)[length],
std::ostream& out
);
template <
typename T,
size_t length
>
inline void deserialize (
T (&array)[length],
std::istream& in
);
// ----------------------------------------------------------------------------------------
// ----------------------------------------------------------------------------------------
// ----------------------------------------------------------------------------------------
// ----------------------------------------------------------------------------------------
inline void serialize (
bool item,
std::ostream& out
)
{
if (item)
out << '1';
else
out << '0';
if (!out)
throw serialization_error("Error serializing object of type bool");
}
inline void deserialize (
bool& item,
std::istream& in
)
{
int ch = in.get();
if (ch != EOF)
{
if (ch == '1')
item = true;
else if (ch == '0')
item = false;
else
throw serialization_error("Error deserializing object of type bool");
}
else
{
throw serialization_error("Error deserializing object of type bool");
}
}
// ----------------------------------------------------------------------------------------
template <typename first_type, typename second_type>
void serialize (
const std::pair<first_type, second_type>& item,
std::ostream& out
)
{
try
{
serialize(item.first,out);
serialize(item.second,out);
}
catch (serialization_error& e)
{ throw serialization_error(e.info + "\n while serializing object of type std::pair"); }
}
template <typename first_type, typename second_type>
void deserialize (
std::pair<first_type, second_type>& item,
std::istream& in
)
{
try
{
deserialize(item.first,in);
deserialize(item.second,in);
}
catch (serialization_error& e)
{ throw serialization_error(e.info + "\n while deserializing object of type std::pair"); }
}
// ----------------------------------------------------------------------------------------
template <typename domain, typename range, typename compare, typename alloc>
void serialize (
const std::map<domain,range, compare, alloc>& item,
std::ostream& out
)
{
try
{
const unsigned long size = static_cast<unsigned long>(item.size());
serialize(size,out);
typename std::map<domain,range,compare,alloc>::const_iterator i;
for (i = item.begin(); i != item.end(); ++i)
{
serialize(i->first,out);
serialize(i->second,out);
}
}
catch (serialization_error& e)
{ throw serialization_error(e.info + "\n while serializing object of type std::map"); }
}
template <typename domain, typename range, typename compare, typename alloc>
void deserialize (
std::map<domain, range, compare, alloc>& item,
std::istream& in
)
{
try
{
item.clear();
unsigned long size;
deserialize(size,in);
domain d;
range r;
for (unsigned long i = 0; i < size; ++i)
{
deserialize(d,in);
deserialize(r,in);
item[d] = r;
}
}
catch (serialization_error& e)
{ throw serialization_error(e.info + "\n while deserializing object of type std::map"); }
}
// ----------------------------------------------------------------------------------------
template <typename T, typename alloc>
void serialize (
const std::vector<T,alloc>& item,
std::ostream& out
)
{
try
{
const unsigned long size = static_cast<unsigned long>(item.size());
serialize(size,out);
for (unsigned long i = 0; i < item.size(); ++i)
serialize(item[i],out);
}
catch (serialization_error& e)
{ throw serialization_error(e.info + "\n while serializing object of type std::vector"); }
}
template <typename T, typename alloc>
void deserialize (
std::vector<T, alloc>& item,
std::istream& in
)
{
try
{
unsigned long size;
deserialize(size,in);
item.resize(size);
for (unsigned long i = 0; i < size; ++i)
deserialize(item[i],in);
}
catch (serialization_error& e)
{ throw serialization_error(e.info + "\n while deserializing object of type std::vector"); }
}
// ----------------------------------------------------------------------------------------
inline void serialize (
const std::string& item,
std::ostream& out
)
{
const unsigned long size = static_cast<unsigned long>(item.size());
try{ serialize(size,out); }
catch (serialization_error& e)
{ throw serialization_error(e.info + "\n while serializing object of type std::string"); }
out.write(item.c_str(),size);
if (!out) throw serialization_error("Error serializing object of type std::string");
}
inline void deserialize (
std::string& item,
std::istream& in
)
{
char* buf = 0;
try
{
unsigned long size;
try { deserialize(size,in); }
catch (serialization_error& e)
{ throw serialization_error(e.info + "\n while deserializing object of type std::string"); }
buf = new char[size+1];
buf[size] = 0;
in.read(buf,size);
item.assign(buf);
if (!in) throw serialization_error("Error deserializing object of type std::string");
delete [] buf;
}
catch (...)
{
if (buf)
delete [] buf;
item.erase();
throw;
}
}
// ----------------------------------------------------------------------------------------
inline void serialize (
const std::wstring& item,
std::ostream& out
)
{
const unsigned long size = static_cast<unsigned long>(item.size());
try{ serialize(size,out); }
catch (serialization_error& e)
{ throw serialization_error(e.info + "\n while serializing object of type std::wstring"); }
for (unsigned long i = 0; i < item.size(); ++i)
serialize(item[i], out);
if (!out) throw serialization_error("Error serializing object of type std::wstring");
}
inline void deserialize (
std::wstring& item,
std::istream& in
)
{
unsigned long size;
try { deserialize(size,in); }
catch (serialization_error& e)
{ throw serialization_error(e.info + "\n while deserializing object of type std::wstring"); }
item.resize(size);
for (unsigned long i = 0; i < item.size(); ++i)
deserialize(item[i],in);
if (!in) throw serialization_error("Error deserializing object of type std::wstring");
}
// ----------------------------------------------------------------------------------------
inline void serialize (
const ustring& item,
std::ostream& out
)
{
const unsigned long size = static_cast<unsigned long>(item.size());
try{ serialize(size,out); }
catch (serialization_error& e)
{ throw serialization_error(e.info + "\n while serializing object of type ustring"); }
for (unsigned long i = 0; i < item.size(); ++i)
serialize(item[i], out);
if (!out) throw serialization_error("Error serializing object of type ustring");
}
inline void deserialize (
ustring& item,
std::istream& in
)
{
unsigned long size;
try { deserialize(size,in); }
catch (serialization_error& e)
{ throw serialization_error(e.info + "\n while deserializing object of type ustring"); }
item.resize(size);
for (unsigned long i = 0; i < item.size(); ++i)
deserialize(item[i],in);
if (!in) throw serialization_error("Error deserializing object of type ustring");
}
// ----------------------------------------------------------------------------------------
template <
typename T
>
inline void serialize (
const enumerable<T>& item,
std::ostream& out
)
{
try
{
item.reset();
serialize(item.size(),out);
while (item.move_next())
serialize(item.element(),out);
item.reset();
}
catch (serialization_error& e)
{
throw serialization_error(e.info + "\n while serializing object of type enumerable");
}
}
// ----------------------------------------------------------------------------------------
template <
typename domain,
typename range
>
inline void serialize (
const map_pair<domain,range>& item,
std::ostream& out
)
{
try
{
serialize(item.key(),out);
serialize(item.value(),out);
}
catch (serialization_error& e)
{
throw serialization_error(e.info + "\n while serializing object of type map_pair");
}
}
// ----------------------------------------------------------------------------------------
template <
typename T,
size_t length
>
inline void serialize (
const T (&array)[length],
std::ostream& out
)
{
try
{
serialize(length,out);
for (size_t i = 0; i < length; ++i)
serialize(array[i],out);
}
catch (serialization_error& e)
{
throw serialization_error(e.info + "\n while serializing a C style array");
}
}
// ----------------------------------------------------------------------------------------
template <
typename T,
size_t length
>
inline void deserialize (
T (&array)[length],
std::istream& in
)
{
size_t size;
try
{
deserialize(size,in);
if (size == length)
{
for (size_t i = 0; i < length; ++i)
deserialize(array[i],in);
}
}
catch (serialization_error& e)
{
throw serialization_error(e.info + "\n while deserializing a C style array");
}
if (size != length)
throw serialization_error("Error deserializing a C style array, lengths do not match");
}
// ----------------------------------------------------------------------------------------
template <
typename T
>
inline void serialize (
const std::complex<T>& item,
std::ostream& out
)
{
try
{
serialize(item.real(),out);
serialize(item.imag(),out);
}
catch (serialization_error& e)
{
throw serialization_error(e.info + "\n while serializing an object of type std::complex");
}
}
// ----------------------------------------------------------------------------------------
template <
typename T
>
inline void deserialize (
std::complex<T>& item,
std::istream& in
)
{
try
{
T real, imag;
deserialize(real,in);
deserialize(imag,in);
item = std::complex<T>(real,imag);
}
catch (serialization_error& e)
{
throw serialization_error(e.info + "\n while deserializing an object of type std::complex");
}
}
// ----------------------------------------------------------------------------------------
}
#endif // DLIB_SERIALIZe_