#ifndef BOOST_SERIALIZATION_ACCESS_HPP

 #define BOOST_SERIALIZATION_ACCESS_HPP

 // MS compatible compilers support #pragma once

 #if defined(_MSC_VER) && (_MSC_VER >= 1020)

 # pragma once

 #endif

 /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8

 // access.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.

 #include <boost/config.hpp>

 #include <boost/pfto.hpp>

 namespace boost {

 namespace archive {

 namespace detail {

     template<class Archive, class T>

     class iserializer;

     template<class Archive, class T>

     class oserializer;

 } // namespace detail

 } // namespace archive

 namespace serialization {

 // forward declarations

 template<class Archive, class T>

 inline void serialize_adl(Archive &, T &, const unsigned int);

 namespace detail {

     template<class Archive, class T>

     struct member_saver;

     template<class Archive, class T>

     struct member_loader;

 } // namespace detail

 // use an "accessor class so that we can use: 

 // "friend class boost::serialization::access;" 

 // in any serialized class to permit clean, safe access to private class members

 // by the serialization system

 class access {

 public:

     // grant access to "real" serialization defaults

 #ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS

 public:

 #else

     template<class Archive, class T>

     friend struct detail::member_saver;

     template<class Archive, class T>

     friend struct detail::member_loader;

     template<class Archive, class T>

     friend class archive::detail::iserializer;

     template<class Archive, class T>

     friend class archive::detail::oserializer;

     template<class Archive, class T>

     friend inline void serialize(

         Archive & ar, 

         T & t, 

         const BOOST_PFTO unsigned int file_version

     );

     template<class Archive, class T>

     friend inline void save_construct_data(

         Archive & ar, 

         const T * t, 

         const BOOST_PFTO unsigned int file_version

     );

     template<class Archive, class T>

     friend inline void load_construct_data(

         Archive & ar, 

         T * t, 

         const BOOST_PFTO unsigned int file_version

     );

 #endif

     // pass calls to users's class implementation

     template<class Archive, class T>

     static void member_save(

         Archive & ar, 

         //const T & t,

         T & t,

         const unsigned int file_version

     ){

         t.save(ar, file_version);

     }

     template<class Archive, class T>

     static void member_load(

         Archive & ar, 

         T & t,

         const unsigned int file_version

     ){

         t.load(ar, file_version);

     }

     template<class Archive, class T>

     static void serialize(

         Archive & ar, 

         T & t, 

         const unsigned int file_version

     ){

         t.serialize(ar, file_version);

     }

     template<class T>

     static void destroy( const T * t) // const appropriate here?

     {

         // the const business is an MSVC 6.0 hack that should be

         // benign on everything else

         delete const_cast<T *>(t);

     }

     template<class Archive, class T>

     static void construct(Archive & /* ar */, T * t){

         // default is inplace invocation of default constructor

         // Note the :: before the placement new. Required if the

         // class doesn't have a class-specific placement new defined.

         ::new(t)T;

     }

 };

 } // namespace serialization

 } // namespace boost

 #endif // BOOST_SERIALIZATION_ACCESS_HPP