| #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 <boost/config.hpp> |
| #include <boost/serialization/strong_typedef.hpp> |
| #include <boost/serialization/pfto.hpp> |
| |
| /////////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 implementation - 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(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 |