ceph/src/boost/libs/serialization/include/boost/serialization/hash_map.hpp

   1 #ifndef  BOOST_SERIALIZATION_HASH_MAP_HPP
   2 #define BOOST_SERIALIZATION_HASH_MAP_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 // serialization/hash_map.hpp:
  11 // serialization for stl hash_map templates
  12
  13 // (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
  14 // Use, modification and distribution is subject to the Boost Software
  15 // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
  16 // http://www.boost.org/LICENSE_1_0.txt)
  17
  18 //  See http://www.boost.org for updates, documentation, and revision history.
  19
  20 #include <boost/config.hpp>
  21 #ifdef BOOST_HAS_HASH
  22 #include BOOST_HASH_MAP_HEADER
  23
  24 #include <boost/serialization/utility.hpp>
  25 #include <boost/serialization/hash_collections_save_imp.hpp>
  26 #include <boost/serialization/hash_collections_load_imp.hpp>
  27 #include <boost/serialization/split_free.hpp>
  28
  29 namespace boost {
  30 namespace serialization {
  31
  32 namespace stl {
  33
  34 // map input
  35 template<class Archive, class Container>
  36 struct archive_input_hash_map
  37 {
  38     inline void operator()(
  39         Archive &ar,
  40         Container &s,
  41         const unsigned int v
  42     ){
  43         typedef typename Container::value_type type;
  44         detail::stack_construct<Archive, type> t(ar, v);
  45         // borland fails silently w/o full namespace
  46         ar >> boost::serialization::make_nvp("item", t.reference());
  47         std::pair<typename Container::const_iterator, bool> result =
  48             s.insert(t.reference());
  49         // note: the following presumes that the map::value_type was NOT tracked
  50         // in the archive.  This is the usual case, but here there is no way
  51         // to determine that.
  52         if(result.second){
  53             ar.reset_object_address(
  54                 & (result.first->second),
  55                 & t.reference().second
  56             );
  57         }
  58     }
  59 };
  60
  61 // multimap input
  62 template<class Archive, class Container>
  63 struct archive_input_hash_multimap
  64 {
  65     inline void operator()(
  66         Archive &ar,
  67         Container &s,
  68         const unsigned int v
  69     ){
  70         typedef typename Container::value_type type;
  71         detail::stack_construct<Archive, type> t(ar, v);
  72         // borland fails silently w/o full namespace
  73         ar >> boost::serialization::make_nvp("item", t.reference());
  74         typename Container::const_iterator result
  75             = s.insert(t.reference());
  76         // note: the following presumes that the map::value_type was NOT tracked
  77         // in the archive.  This is the usual case, but here there is no way
  78         // to determine that.
  79         ar.reset_object_address(
  80             & result->second,
  81             & t.reference()
  82         );
  83     }
  84 };
  85
  86 } // stl
  87
  88 template<
  89     class Archive,
  90     class Key,
  91     class HashFcn,
  92     class EqualKey,
  93     class Allocator
  94 >
  95 inline void save(
  96     Archive & ar,
  97     const BOOST_STD_EXTENSION_NAMESPACE::hash_map<
  98         Key, HashFcn, EqualKey, Allocator
  99     > &t,
 100     const unsigned int file_version
 101 ){
 102     boost::serialization::stl::save_hash_collection<
 103         Archive,
 104         BOOST_STD_EXTENSION_NAMESPACE::hash_map<
 105             Key, HashFcn, EqualKey, Allocator
 106         >
 107     >(ar, t);
 108 }
 109
 110 template<
 111     class Archive,
 112     class Key,
 113     class HashFcn,
 114     class EqualKey,
 115     class Allocator
 116 >
 117 inline void load(
 118     Archive & ar,
 119     BOOST_STD_EXTENSION_NAMESPACE::hash_map<
 120         Key, HashFcn, EqualKey, Allocator
 121     > &t,
 122     const unsigned int file_version
 123 ){
 124     boost::serialization::stl::load_hash_collection<
 125         Archive,
 126         BOOST_STD_EXTENSION_NAMESPACE::hash_map<
 127             Key, HashFcn, EqualKey, Allocator
 128         >,
 129         boost::serialization::stl::archive_input_hash_map<
 130             Archive,
 131             BOOST_STD_EXTENSION_NAMESPACE::hash_map<
 132                 Key, HashFcn, EqualKey, Allocator
 133             >
 134         >
 135     >(ar, t);
 136 }
 137
 138 // split non-intrusive serialization function member into separate
 139 // non intrusive save/load member functions
 140 template<
 141     class Archive,
 142     class Key,
 143     class HashFcn,
 144     class EqualKey,
 145     class Allocator
 146 >
 147 inline void serialize(
 148     Archive & ar,
 149     BOOST_STD_EXTENSION_NAMESPACE::hash_map<
 150         Key, HashFcn, EqualKey, Allocator
 151     > &t,
 152     const unsigned int file_version
 153 ){
 154     boost::serialization::split_free(ar, t, file_version);
 155 }
 156
 157 // hash_multimap
 158 template<
 159     class Archive,
 160     class Key,
 161     class HashFcn,
 162     class EqualKey,
 163     class Allocator
 164 >
 165 inline void save(
 166     Archive & ar,
 167     const BOOST_STD_EXTENSION_NAMESPACE::hash_multimap<
 168         Key, HashFcn, EqualKey, Allocator
 169     > &t,
 170     const unsigned int file_version
 171 ){
 172     boost::serialization::stl::save_hash_collection<
 173         Archive,
 174         BOOST_STD_EXTENSION_NAMESPACE::hash_multimap<
 175             Key, HashFcn, EqualKey, Allocator
 176         >
 177     >(ar, t);
 178 }
 179
 180 template<
 181     class Archive,
 182     class Key,
 183     class HashFcn,
 184     class EqualKey,
 185     class Allocator
 186 >
 187 inline void load(
 188     Archive & ar,
 189     BOOST_STD_EXTENSION_NAMESPACE::hash_multimap<
 190         Key, HashFcn, EqualKey, Allocator
 191     > &t,
 192     const unsigned int file_version
 193 ){
 194     boost::serialization::stl::load_hash_collection<
 195         Archive,
 196         BOOST_STD_EXTENSION_NAMESPACE::hash_multimap<
 197             Key, HashFcn, EqualKey, Allocator
 198         >,
 199         boost::serialization::stl::archive_input_hash_multimap<
 200             Archive,
 201             BOOST_STD_EXTENSION_NAMESPACE::hash_multimap<
 202                 Key, HashFcn, EqualKey, Allocator
 203             >
 204         >
 205     >(ar, t);
 206 }
 207
 208 // split non-intrusive serialization function member into separate
 209 // non intrusive save/load member functions
 210 template<
 211     class Archive,
 212     class Key,
 213     class HashFcn,
 214     class EqualKey,
 215     class Allocator
 216 >
 217 inline void serialize(
 218     Archive & ar,
 219     BOOST_STD_EXTENSION_NAMESPACE::hash_multimap<
 220         Key, HashFcn, EqualKey, Allocator
 221     > &t,
 222     const unsigned int file_version
 223 ){
 224     boost::serialization::split_free(ar, t, file_version);
 225 }
 226
 227 } // namespace serialization
 228 } // namespace boost
 229
 230 #endif // BOOST_HAS_HASH
 231 #endif // BOOST_SERIALIZATION_HASH_MAP_HPP