/usr/include/boost/serialization
Edit: /usr/include/boost/serialization/serialization.hpp (4678B)
#ifndef BOOST_SERIALIZATION_SERIALIZATION_HPP
#define BOOST_SERIALIZATION_SERIALIZATION_HPP
// MS compatible compilers support #pragma once
#if defined(_MSC_VER)
# pragma once
#endif
#if defined(_MSC_VER)
# pragma warning (disable : 4675) // suppress ADL warning
#endif
#include
#include
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// serialization.hpp: interface for serialization system.
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
// Use, modification and distribution is subject to the Boost Software
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
// See http://www.boost.org for updates, documentation, and revision history.
//////////////////////////////////////////////////////////////////////
// public interface to serialization.
/////////////////////////////////////////////////////////////////////////////
// layer 0 - intrusive verison
// declared and implemented for each user defined class to be serialized
//
// template
// serialize(Archive &ar, const unsigned int file_version){
// ar & base_object(*this) & member1 & member2 ... ;
// }
/////////////////////////////////////////////////////////////////////////////
// layer 1 - layer that routes member access through the access class.
// this is what permits us to grant access to private class member functions
// by specifying friend class boost::serialization::access
#include
/////////////////////////////////////////////////////////////////////////////
// layer 2 - default implementation of non-intrusive serialization.
//
// note the usage of function overloading to compensate that C++ does not
// currently support Partial Template Specialization for function templates
// We have declared the version number as "const unsigned long".
// Overriding templates for specific data types should declare the version
// number as "const unsigned int". Template matching will first be applied
// to functions with the same version types - that is the overloads.
// If there is no declared function prototype that matches, the second argument
// will be converted to "const unsigned long" and a match will be made with
// one of the default template functions below.
namespace boost {
namespace serialization {
BOOST_STRONG_TYPEDEF(unsigned int, version_type)
// default implementation - call the member function "serialize"
template
inline void serialize(
Archive & ar, T & t, const unsigned int file_version
){
access::serialize(ar, t, static_cast(file_version));
}
// save data required for construction
template
inline void save_construct_data(
Archive & /*ar*/,
const T * /*t*/,
const unsigned int /*file_version */
){
// default is to save no data because default constructor
// requires no arguments.
}
// load data required for construction and invoke constructor in place
template
inline void load_construct_data(
Archive & /*ar*/,
T * t,
const unsigned int /*file_version*/
){
// default just uses the default constructor. going
// through access permits usage of otherwise private default
// constructor
access::construct(t);
}
/////////////////////////////////////////////////////////////////////////////
// layer 3 - move call into serialization namespace so that ADL will function
// in the manner we desire.
//
// on compilers which don't implement ADL. only the current namespace
// i.e. boost::serialization will be searched.
//
// on compilers which DO implement ADL
// serialize overrides can be in any of the following
//
// 1) same namepace as Archive
// 2) same namespace as T
// 3) boost::serialization
//
// Due to Martin Ecker
template
inline void serialize_adl(
Archive & ar,
T & t,
const unsigned int file_version
){
const version_type v(file_version);
serialize(ar, t, v);
}
template
inline void save_construct_data_adl(
Archive & ar,
const T * t,
const unsigned int file_version
){
const version_type v(file_version);
save_construct_data(ar, t, v);
}
template
inline void load_construct_data_adl(
Archive & ar,
T * t,
const unsigned int file_version
){
// see above comment
const version_type v(file_version);
load_construct_data(ar, t, v);
}
} // namespace serialization
} // namespace boost
#endif //BOOST_SERIALIZATION_SERIALIZATION_HPP