#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