FCL/sf/os/ossrv: comparison ossrv_pub/boost_apis/boost/serialization/serialization.hpp

equal deleted inserted replaced

--1:000000000000
+:e4d67989cc36
+#ifndef BOOST_SERIALIZATION_SERIALIZATION_HPP
+#define BOOST_SERIALIZATION_SERIALIZATION_HPP
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+#if defined(_MSC_VER) && (_MSC_VER >= 1310)
+#  pragma warning (disable : 4675) // suppress ADL warning
+#endif
+#include <cstddef> // size_t
+#include <boost/config.hpp>
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{
+using ::size_t;
+} // namespace std
+#endif
+#include <boost/strong_typedef.hpp>
+#include <boost/pfto.hpp>
+#include <boost/throw_exception.hpp>
+#include <boost/serialization/nvp.hpp>
+// incremented for each "release"
+#define BOOST_SERIALIZATION_LIBRARY_VERSION 19
+/////////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<Archive>
+//  serialize(Archive &ar, const unsigned int file_version){
+//      ar & base_object<base>(*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 <boost/serialization/access.hpp>
+/////////////////////////////////////////////////////////////////////////////
+// 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 implemenation - call the member function "serialize"
+template<class Archive, class T>
+inline void serialize(
+Archive & ar, T & t, const BOOST_PFTO unsigned int file_version
+){
+access::serialize(ar, t, static_cast<unsigned int>(file_version));
+}
+// save data required for construction
+template<class Archive, class T>
+inline void save_construct_data(
+Archive & /*ar*/,
+const T * /*t*/,
+const BOOST_PFTO 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<class Archive, class T>
+inline void load_construct_data(
+Archive & ar,
+T * t,
+const BOOST_PFTO unsigned int /*file_version*/
+){
+// default just uses the default constructor.  going
+// through access permits usage of otherwise private default
+// constructor
+access::construct(ar, 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<class Archive, class T>
+inline void serialize_adl(
+Archive & ar,
+T & t,
+const unsigned int file_version
+){
+// note usage of function overloading to delay final resolution
+// until the point of instantiation.  This works around the two-phase
+// lookup "feature" which inhibits redefintion of a default function
+// template implementation. Due to Robert Ramey
+//
+// Note that this trick generates problems for compiles which don't support
+// PFTO, suppress it here.  As far as we know, there are no compilers
+// which fail to support PFTO while supporting two-phase lookup.
+#if ! defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
+const version_type v(file_version);
+serialize(ar, t, v);
+#else
+serialize(ar, t, file_version);
+#endif
+}
+template<class Archive, class T>
+inline void save_construct_data_adl(
+Archive & ar,
+const T * t,
+const unsigned int file_version
+){
+// see above
+#if ! defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
+const version_type v(file_version);
+save_construct_data(ar, t, v);
+#else
+save_construct_data(ar, t, file_version);
+#endif
+}
+template<class Archive, class T>
+inline void load_construct_data_adl(
+Archive & ar,
+T * t,
+const unsigned int file_version
+){
+// see above comment
+#if ! defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
+const version_type v(file_version);
+load_construct_data(ar, t, v);
+#else
+load_construct_data(ar, t, file_version);
+#endif
+}
+} // namespace serialization
+} // namespace boost
+#endif //BOOST_SERIALIZATION_SERIALIZATION_HPP