ceph/src/boost/boost/serialization/set.hpp

   1 #ifndef  BOOST_SERIALIZATION_SET_HPP
   2 #define BOOST_SERIALIZATION_SET_HPP
   3
   4 // MS compatible compilers support #pragma once
   5 #if defined(_MSC_VER)
   6 # pragma once
   7 #endif
   8
   9 /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
  10 // set.hpp: serialization for stl set templates
  11
  12 // (C) Copyright 2002-2014 Robert Ramey - http://www.rrsd.com .
  13 // Use, modification and distribution is subject to the Boost Software
  14 // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
  15 // http://www.boost.org/LICENSE_1_0.txt)
  16
  17 //  See http://www.boost.org for updates, documentation, and revision history.
  18
  19 #include <set>
  20
  21 #include <boost/config.hpp>
  22
  23 #include <boost/archive/detail/basic_iarchive.hpp>
  24 #include <boost/serialization/access.hpp>
  25 #include <boost/serialization/nvp.hpp>
  26 #include <boost/serialization/detail/stack_constructor.hpp>
  27 #include <boost/serialization/collection_size_type.hpp>
  28 #include <boost/serialization/item_version_type.hpp>
  29
  30 #include <boost/serialization/collections_save_imp.hpp>
  31 #include <boost/serialization/split_free.hpp>
  32 #include <boost/move/utility_core.hpp>
  33
  34 namespace boost {
  35 namespace serialization {
  36
  37 template<class Archive, class Container>
  38 inline void load_set_collection(Archive & ar, Container &s)
  39 {
  40     s.clear();
  41     const boost::archive::library_version_type library_version(
  42         ar.get_library_version()
  43     );
  44     // retrieve number of elements
  45     item_version_type item_version(0);
  46     collection_size_type count;
  47     ar >> BOOST_SERIALIZATION_NVP(count);
  48     if(boost::archive::library_version_type(3) < library_version){
  49         ar >> BOOST_SERIALIZATION_NVP(item_version);
  50     }
  51     typename Container::iterator hint;
  52     hint = s.begin();
  53     while(count-- > 0){
  54         typedef typename Container::value_type type;
  55         detail::stack_construct<Archive, type> t(ar, item_version);
  56         // borland fails silently w/o full namespace
  57         ar >> boost::serialization::make_nvp("item", t.reference());
  58         typename Container::iterator result =
  59             s.insert(hint, boost::move(t.reference()));
  60         ar.reset_object_address(& (* result), & t.reference());
  61         hint = result;
  62     }
  63 }
  64
  65 template<class Archive, class Key, class Compare, class Allocator >
  66 inline void save(
  67     Archive & ar,
  68     const std::set<Key, Compare, Allocator> &t,
  69     const unsigned int /* file_version */
  70 ){
  71     boost::serialization::stl::save_collection<
  72         Archive, std::set<Key, Compare, Allocator>
  73     >(ar, t);
  74 }
  75
  76 template<class Archive, class Key, class Compare, class Allocator >
  77 inline void load(
  78     Archive & ar,
  79     std::set<Key, Compare, Allocator> &t,
  80     const unsigned int /* file_version */
  81 ){
  82     load_set_collection(ar, t);
  83 }
  84
  85 // split non-intrusive serialization function member into separate
  86 // non intrusive save/load member functions
  87 template<class Archive, class Key, class Compare, class Allocator >
  88 inline void serialize(
  89     Archive & ar,
  90     std::set<Key, Compare, Allocator> & t,
  91     const unsigned int file_version
  92 ){
  93     boost::serialization::split_free(ar, t, file_version);
  94 }
  95
  96 // multiset
  97 template<class Archive, class Key, class Compare, class Allocator >
  98 inline void save(
  99     Archive & ar,
 100     const std::multiset<Key, Compare, Allocator> &t,
 101     const unsigned int /* file_version */
 102 ){
 103     boost::serialization::stl::save_collection<
 104         Archive,
 105         std::multiset<Key, Compare, Allocator>
 106     >(ar, t);
 107 }
 108
 109 template<class Archive, class Key, class Compare, class Allocator >
 110 inline void load(
 111     Archive & ar,
 112     std::multiset<Key, Compare, Allocator> &t,
 113     const unsigned int /* file_version */
 114 ){
 115     load_set_collection(ar, t);
 116 }
 117
 118 // split non-intrusive serialization function member into separate
 119 // non intrusive save/load member functions
 120 template<class Archive, class Key, class Compare, class Allocator >
 121 inline void serialize(
 122     Archive & ar,
 123     std::multiset<Key, Compare, Allocator> & t,
 124     const unsigned int file_version
 125 ){
 126     boost::serialization::split_free(ar, t, file_version);
 127 }
 128
 129 } // namespace serialization
 130 } // namespace boost
 131
 132 #include <boost/serialization/collection_traits.hpp>
 133
 134 BOOST_SERIALIZATION_COLLECTION_TRAITS(std::set)
 135 BOOST_SERIALIZATION_COLLECTION_TRAITS(std::multiset)
 136
 137 #endif // BOOST_SERIALIZATION_SET_HPP