1#ifndef BOOST_SERIALIZATION_VECTOR_HPP
2#define BOOST_SERIALIZATION_VECTOR_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// vector.hpp: serialization for stl vector templates
11
12// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
13// fast array serialization (C) Copyright 2005 Matthias Troyer
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 <vector>
21
22#include <boost/config.hpp>
23#include <boost/detail/workaround.hpp>
24
25#include <boost/serialization/access.hpp>
26#include <boost/serialization/nvp.hpp>
27#include <boost/serialization/collection_size_type.hpp>
28#include <boost/serialization/library_version_type.hpp>
29#include <boost/serialization/item_version_type.hpp>
30#include <boost/serialization/library_version_type.hpp>
31
32#include <boost/serialization/collections_save_imp.hpp>
33#include <boost/serialization/collections_load_imp.hpp>
34#include <boost/serialization/split_free.hpp>
35#include <boost/serialization/array_wrapper.hpp>
36#include <boost/mpl/bool_fwd.hpp>
37#include <boost/mpl/if.hpp>
38
39// default is being compatible with version 1.34.1 files, not 1.35 files
40#ifndef BOOST_SERIALIZATION_VECTOR_VERSIONED
41#define BOOST_SERIALIZATION_VECTOR_VERSIONED(V) (V==4 || V==5)
42#endif
43
44// function specializations must be defined in the appropriate
45// namespace - boost::serialization
46#if defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION)
47#define STD _STLP_STD
48#else
49#define STD std
50#endif
51
52namespace boost {
53namespace serialization {
54
55/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
56// vector< T >
57
58// the default versions
59
60template<class Archive, class U, class Allocator>
61inline void save(
62 Archive & ar,
63 const std::vector<U, Allocator> &t,
64 const unsigned int /* file_version */,
65 mpl::false_
66){
67 boost::serialization::stl::save_collection<Archive, STD::vector<U, Allocator> >(
68 ar, t
69 );
70}
71
72template<class Archive, class U, class Allocator>
73inline void load(
74 Archive & ar,
75 std::vector<U, Allocator> &t,
76 const unsigned int /* file_version */,
77 mpl::false_
78){
79 const boost::serialization::library_version_type library_version(
80 ar.get_library_version()
81 );
82 // retrieve number of elements
83 item_version_type item_version(0);
84 collection_size_type count;
85 ar >> BOOST_SERIALIZATION_NVP(count);
86 if(boost::serialization::library_version_type(3) < library_version){
87 ar >> BOOST_SERIALIZATION_NVP(item_version);
88 }
89 t.reserve(count);
90 stl::collection_load_impl(ar, t, count, item_version);
91}
92
93// the optimized versions
94
95template<class Archive, class U, class Allocator>
96inline void save(
97 Archive & ar,
98 const std::vector<U, Allocator> &t,
99 const unsigned int /* file_version */,
100 mpl::true_
101){
102 const collection_size_type count(t.size());
103 ar << BOOST_SERIALIZATION_NVP(count);
104 if (!t.empty())
105 // explicit template arguments to pass intel C++ compiler
106 ar << serialization::make_array<const U, collection_size_type>(
107 static_cast<const U *>(&t[0]),
108 count
109 );
110}
111
112template<class Archive, class U, class Allocator>
113inline void load(
114 Archive & ar,
115 std::vector<U, Allocator> &t,
116 const unsigned int /* file_version */,
117 mpl::true_
118){
119 collection_size_type count(t.size());
120 ar >> BOOST_SERIALIZATION_NVP(count);
121 t.resize(count);
122 unsigned int item_version=0;
123 if(BOOST_SERIALIZATION_VECTOR_VERSIONED(ar.get_library_version())) {
124 ar >> BOOST_SERIALIZATION_NVP(item_version);
125 }
126 if (!t.empty())
127 // explicit template arguments to pass intel C++ compiler
128 ar >> serialization::make_array<U, collection_size_type>(
129 static_cast<U *>(&t[0]),
130 count
131 );
132 }
133
134// dispatch to either default or optimized versions
135
136template<class Archive, class U, class Allocator>
137inline void save(
138 Archive & ar,
139 const std::vector<U, Allocator> &t,
140 const unsigned int file_version
141){
142 typedef typename
143 boost::serialization::use_array_optimization<Archive>::template apply<
144 typename remove_const<U>::type
145 >::type use_optimized;
146 save(ar,t,file_version, use_optimized());
147}
148
149template<class Archive, class U, class Allocator>
150inline void load(
151 Archive & ar,
152 std::vector<U, Allocator> &t,
153 const unsigned int file_version
154){
155#ifdef BOOST_SERIALIZATION_VECTOR_135_HPP
156 if (ar.get_library_version()==boost::serialization::library_version_type(5))
157 {
158 load(ar,t,file_version, boost::is_arithmetic<U>());
159 return;
160 }
161#endif
162 typedef typename
163 boost::serialization::use_array_optimization<Archive>::template apply<
164 typename remove_const<U>::type
165 >::type use_optimized;
166 load(ar,t,file_version, use_optimized());
167}
168
169// split non-intrusive serialization function member into separate
170// non intrusive save/load member functions
171template<class Archive, class U, class Allocator>
172inline void serialize(
173 Archive & ar,
174 std::vector<U, Allocator> & t,
175 const unsigned int file_version
176){
177 boost::serialization::split_free(ar, t, file_version);
178}
179
180/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
181// vector<bool>
182template<class Archive, class Allocator>
183inline void save(
184 Archive & ar,
185 const std::vector<bool, Allocator> &t,
186 const unsigned int /* file_version */
187){
188 // record number of elements
189 collection_size_type count (t.size());
190 ar << BOOST_SERIALIZATION_NVP(count);
191 std::vector<bool>::const_iterator it = t.begin();
192 while(count-- > 0){
193 bool tb = *it++;
194 ar << boost::serialization::make_nvp(n: "item", v&: tb);
195 }
196}
197
198template<class Archive, class Allocator>
199inline void load(
200 Archive & ar,
201 std::vector<bool, Allocator> &t,
202 const unsigned int /* file_version */
203){
204 // retrieve number of elements
205 collection_size_type count;
206 ar >> BOOST_SERIALIZATION_NVP(count);
207 t.resize(count);
208 for(collection_size_type i = collection_size_type(0); i < count; ++i){
209 bool b;
210 ar >> boost::serialization::make_nvp(n: "item", v&: b);
211 t[i] = b;
212 }
213}
214
215// split non-intrusive serialization function member into separate
216// non intrusive save/load member functions
217template<class Archive, class Allocator>
218inline void serialize(
219 Archive & ar,
220 std::vector<bool, Allocator> & t,
221 const unsigned int file_version
222){
223 boost::serialization::split_free(ar, t, file_version);
224}
225
226} // serialization
227} // namespace boost
228
229#include <boost/serialization/collection_traits.hpp>
230
231BOOST_SERIALIZATION_COLLECTION_TRAITS(std::vector)
232#undef STD
233
234#endif // BOOST_SERIALIZATION_VECTOR_HPP
235

source code of boost/libs/serialization/include/boost/serialization/vector.hpp