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

 // (C) Copyright 2002-4 Pavel Vozenilek . 

 // 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)

 // Provides non-intrusive serialization for boost::optional.

 #ifndef BOOST_SERIALIZATION_OPTIONAL_HPP_

 #define BOOST_SERIALIZATION_OPTIONAL_HPP_

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

 # pragma once

 #endif

 #include <boost/config.hpp>

 #include <boost/optional.hpp>

 #include <boost/serialization/split_free.hpp>

 #include <boost/serialization/level.hpp>

 #include <boost/serialization/nvp.hpp>

 #include <boost/serialization/detail/stack_constructor.hpp>

 // function specializations must be defined in the appropriate

 // namespace - boost::serialization

 namespace boost { 

 namespace serialization {

 template<class Archive, class T>

 void save(

     Archive & ar, 

     const boost::optional<T> & t, 

     const unsigned int /*version*/

 ){

     const bool tflag = t.is_initialized();

     ar << boost::serialization::make_nvp("initialized", tflag);

     if (tflag){

         if(3 < ar.get_library_version()){

             const int v = version<T>::value;

             ar << make_nvp("item_version", v);

         }

         ar << boost::serialization::make_nvp("value", *t);

     }

 }

 template<class Archive, class T>

 void load(

     Archive & ar, 

     boost::optional<T> & t, 

     const unsigned int /*version*/

 ){

     bool tflag;

     ar >> boost::serialization::make_nvp("initialized", tflag);

     if (tflag){

         unsigned int v;

         if(3 < ar.get_library_version()){

             ar >> make_nvp("item_version", v);

         }

         detail::stack_construct<Archive, T> aux(ar, v);

         ar >> boost::serialization::make_nvp("value", aux.reference());

         t.reset(aux.reference());

     }

     else {

         t.reset();

     }

 }

 template<class Archive, class T>

 void serialize(

     Archive & ar, 

     boost::optional<T> & t, 

     const unsigned int version

 ){

     boost::serialization::split_free(ar, t, version);

 }

 // the following would be slightly more efficient.  But it

 // would mean that archives created with programs that support

 // TPS wouldn't be readable by programs that don't support TPS.

 // Hence we decline to support this otherwise convenient optimization.

 //#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION

 #if 0

 template <class T>

 struct implementation_level<optional<T> >

 {

     typedef mpl::integral_c_tag tag;

     typedef mpl::int_<boost::serialization::object_serializable> type;

     BOOST_STATIC_CONSTANT(

         int , 

         value = boost::serialization::implementation_level::type::value

     );

 };

 template<class T>

 struct tracking_level<optional<T> >

 {

     typedef mpl::integral_c_tag tag;

     typedef mpl::int_<boost::serialization::track_never> type;

     BOOST_STATIC_CONSTANT(

         int , 

         value = boost::serialization::tracking_level::type::value

     );

 };

 #endif

 } // serialization

 } // namespace boost

 #endif // BOOST_SERIALIZATION_OPTIONAL_HPP_