Line data Source code
1 : /* Copyright 2003-2021 Joaquin M Lopez Munoz.
2 : * Distributed under the Boost Software License, Version 1.0.
3 : * (See accompanying file LICENSE_1_0.txt or copy at
4 : * http://www.boost.org/LICENSE_1_0.txt)
5 : *
6 : * See http://www.boost.org/libs/multi_index for library home page.
7 : */
8 :
9 : #ifndef BOOST_MULTI_INDEX_DETAIL_INDEX_BASE_HPP
10 : #define BOOST_MULTI_INDEX_DETAIL_INDEX_BASE_HPP
11 :
12 : #if defined(_MSC_VER)
13 : #pragma once
14 : #endif
15 :
16 : #include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
17 : #include <boost/core/addressof.hpp>
18 : #include <boost/core/no_exceptions_support.hpp>
19 : #include <boost/detail/workaround.hpp>
20 : #include <boost/move/utility_core.hpp>
21 : #include <boost/mpl/vector.hpp>
22 : #include <boost/multi_index/detail/allocator_traits.hpp>
23 : #include <boost/multi_index/detail/copy_map.hpp>
24 : #include <boost/multi_index/detail/do_not_copy_elements_tag.hpp>
25 : #include <boost/multi_index/detail/index_access_sequence.hpp>
26 : #include <boost/multi_index/detail/node_handle.hpp>
27 : #include <boost/multi_index/detail/node_type.hpp>
28 : #include <boost/multi_index/detail/vartempl_support.hpp>
29 : #include <boost/multi_index_container_fwd.hpp>
30 : #include <boost/tuple/tuple.hpp>
31 : #include <utility>
32 :
33 : #if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
34 : #include <boost/multi_index/detail/index_loader.hpp>
35 : #include <boost/multi_index/detail/index_saver.hpp>
36 : #endif
37 :
38 : namespace boost{
39 :
40 : namespace multi_index{
41 :
42 : namespace detail{
43 :
44 : /* The role of this class is threefold:
45 : * - tops the linear hierarchy of indices.
46 : * - terminates some cascading backbone function calls (insert_, etc.),
47 : * - grants access to the backbone functions of the final
48 : * multi_index_container class (for access restriction reasons, these
49 : * cannot be called directly from the index classes.)
50 : */
51 :
52 : struct lvalue_tag{};
53 : struct rvalue_tag{};
54 : struct emplaced_tag{};
55 :
56 : template<typename Value,typename IndexSpecifierList,typename Allocator>
57 : class index_base
58 : {
59 : protected:
60 : typedef index_node_base<Value,Allocator> index_node_type;
61 : typedef typename multi_index_node_type<
62 : Value,IndexSpecifierList,Allocator>::type final_node_type;
63 : typedef multi_index_container<
64 : Value,IndexSpecifierList,Allocator> final_type;
65 : typedef tuples::null_type ctor_args_list;
66 : typedef typename rebind_alloc_for<
67 : Allocator,typename Allocator::value_type
68 : >::type final_allocator_type;
69 : typedef node_handle<
70 : final_node_type,final_allocator_type> final_node_handle_type;
71 : typedef mpl::vector0<> index_type_list;
72 : typedef mpl::vector0<> iterator_type_list;
73 : typedef mpl::vector0<> const_iterator_type_list;
74 : typedef copy_map<
75 : final_node_type,
76 : final_allocator_type> copy_map_type;
77 :
78 : #if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
79 : typedef index_saver<
80 : index_node_type,
81 : final_allocator_type> index_saver_type;
82 : typedef index_loader<
83 : index_node_type,
84 : final_node_type,
85 : final_allocator_type> index_loader_type;
86 : #endif
87 :
88 : private:
89 : typedef Value value_type;
90 : typedef allocator_traits<Allocator> alloc_traits;
91 : typedef typename alloc_traits::size_type size_type;
92 :
93 : protected:
94 365865 : explicit index_base(const ctor_args_list&,const Allocator&){}
95 :
96 : index_base(
97 : const index_base<Value,IndexSpecifierList,Allocator>&,
98 : do_not_copy_elements_tag)
99 : {}
100 :
101 : void copy_(
102 : const index_base<Value,IndexSpecifierList,Allocator>&,const copy_map_type&)
103 : {}
104 :
105 40507 : final_node_type* insert_(const value_type& v,final_node_type*& x,lvalue_tag)
106 : {
107 40507 : x=final().allocate_node();
108 : BOOST_TRY{
109 40507 : final().construct_value(x,v);
110 40507 : }
111 : BOOST_CATCH(...){
112 0 : final().deallocate_node(x);
113 0 : BOOST_RETHROW;
114 0 : }
115 : BOOST_CATCH_END
116 40507 : return x;
117 0 : }
118 :
119 : final_node_type* insert_(const value_type& v,final_node_type*& x,rvalue_tag)
120 : {
121 : x=final().allocate_node();
122 : BOOST_TRY{
123 : final().construct_value(x,boost::move(const_cast<value_type&>(v)));
124 : }
125 : BOOST_CATCH(...){
126 : final().deallocate_node(x);
127 : BOOST_RETHROW;
128 : }
129 : BOOST_CATCH_END
130 : return x;
131 : }
132 :
133 63716 : final_node_type* insert_(const value_type&,final_node_type*& x,emplaced_tag)
134 : {
135 63716 : return x;
136 : }
137 :
138 : template<typename MultiIndexContainer>
139 : final_node_type* insert_(
140 : const value_type&,final_node_type*& x,MultiIndexContainer* p)
141 : {
142 : p->final_extract_for_transfer_(
143 : x,index_access_sequence<final_type>(&final()));
144 : return x;
145 : }
146 :
147 : final_node_type* insert_(
148 : const value_type& v,index_node_type*,final_node_type*& x,lvalue_tag)
149 : {
150 : return insert_(v,x,lvalue_tag());
151 : }
152 :
153 : final_node_type* insert_(
154 : const value_type& v,index_node_type*,final_node_type*& x,rvalue_tag)
155 : {
156 : return insert_(v,x,rvalue_tag());
157 : }
158 :
159 : final_node_type* insert_(
160 : const value_type&,index_node_type*,final_node_type*& x,emplaced_tag)
161 : {
162 : return x;
163 : }
164 :
165 : template<typename Dst>
166 72132 : void extract_(index_node_type*,Dst){}
167 :
168 33157 : void clear_(){}
169 :
170 : template<typename BoolConstant>
171 : void swap_(
172 : index_base<Value,IndexSpecifierList,Allocator>&,
173 : BoolConstant /* swap_allocators */)
174 : {}
175 :
176 : void swap_elements_(index_base<Value,IndexSpecifierList,Allocator>&){}
177 :
178 : bool replace_(const value_type& v,index_node_type* x,lvalue_tag)
179 : {
180 : x->value()=v;
181 : return true;
182 : }
183 :
184 : bool replace_(const value_type& v,index_node_type* x,rvalue_tag)
185 : {
186 : x->value()=boost::move(const_cast<value_type&>(v));
187 : return true;
188 : }
189 :
190 1848485 : bool modify_(index_node_type*){return true;}
191 :
192 : bool modify_rollback_(index_node_type*){return true;}
193 :
194 : bool check_rollback_(index_node_type*)const{return true;}
195 :
196 : #if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
197 : /* serialization */
198 :
199 : template<typename Archive>
200 : void save_(Archive&,const unsigned int,const index_saver_type&)const{}
201 :
202 : template<typename Archive>
203 : void load_(Archive&,const unsigned int,const index_loader_type&){}
204 : #endif
205 :
206 : #if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING)
207 : /* invariant stuff */
208 :
209 : bool invariant_()const{return true;}
210 : #endif
211 :
212 : /* access to backbone memfuns of Final class */
213 :
214 2171102 : final_type& final(){return *static_cast<final_type*>(this);}
215 111960641 : const final_type& final()const{return *static_cast<const final_type*>(this);}
216 :
217 : template<typename Index>
218 : static typename Index::final_type& final(Index& x) /* cross-index access */
219 : {return static_cast<typename Index::final_type&>(x);}
220 :
221 94668728 : final_node_type* final_header()const{return final().header();}
222 :
223 635142 : bool final_empty_()const{return final().empty_();}
224 16656327 : size_type final_size_()const{return final().size_();}
225 : size_type final_max_size_()const{return final().max_size_();}
226 :
227 40507 : std::pair<final_node_type*,bool> final_insert_(const value_type& x)
228 40507 : {return final().insert_(x);}
229 : std::pair<final_node_type*,bool> final_insert_rv_(const value_type& x)
230 : {return final().insert_rv_(x);}
231 : template<typename T>
232 : std::pair<final_node_type*,bool> final_insert_ref_(const T& t)
233 : {return final().insert_ref_(t);}
234 : template<typename T>
235 : std::pair<final_node_type*,bool> final_insert_ref_(T& t)
236 : {return final().insert_ref_(t);}
237 : std::pair<final_node_type*,bool> final_insert_nh_(final_node_handle_type& nh)
238 : {return final().insert_nh_(nh);}
239 :
240 : template<typename Index>
241 : std::pair<final_node_type*,bool> final_transfer_(Index& x,final_node_type* n)
242 : {return final().transfer_(x,n);}
243 :
244 : template<BOOST_MULTI_INDEX_TEMPLATE_PARAM_PACK>
245 63716 : std::pair<final_node_type*,bool> final_emplace_(
246 : BOOST_MULTI_INDEX_FUNCTION_PARAM_PACK)
247 : {
248 63716 : return final().emplace_(BOOST_MULTI_INDEX_FORWARD_PARAM_PACK);
249 : }
250 :
251 : std::pair<final_node_type*,bool> final_insert_(
252 : const value_type& x,final_node_type* position)
253 : {return final().insert_(x,position);}
254 : std::pair<final_node_type*,bool> final_insert_rv_(
255 : const value_type& x,final_node_type* position)
256 : {return final().insert_rv_(x,position);}
257 : template<typename T>
258 : std::pair<final_node_type*,bool> final_insert_ref_(
259 : const T& t,final_node_type* position)
260 : {return final().insert_ref_(t,position);}
261 : template<typename T>
262 : std::pair<final_node_type*,bool> final_insert_ref_(
263 : T& t,final_node_type* position)
264 : {return final().insert_ref_(t,position);}
265 : std::pair<final_node_type*,bool> final_insert_nh_(
266 : final_node_handle_type& nh,final_node_type* position)
267 : {return final().insert_nh_(nh,position);}
268 :
269 : template<BOOST_MULTI_INDEX_TEMPLATE_PARAM_PACK>
270 : std::pair<final_node_type*,bool> final_emplace_hint_(
271 : final_node_type* position,BOOST_MULTI_INDEX_FUNCTION_PARAM_PACK)
272 : {
273 : return final().emplace_hint_(
274 : position,BOOST_MULTI_INDEX_FORWARD_PARAM_PACK);
275 : }
276 :
277 : final_node_handle_type final_extract_(final_node_type* x)
278 : {
279 : return final().extract_(x);
280 : }
281 :
282 : template<typename Dst>
283 : void final_extract_for_transfer_(final_node_type* x,Dst dst)
284 : {
285 : final().extract_for_transfer_(x,dst);
286 : }
287 :
288 72132 : void final_erase_(final_node_type* x){final().erase_(x);}
289 :
290 32091 : void final_delete_node_(final_node_type* x){final().delete_node_(x);}
291 : void final_delete_all_nodes_(){final().delete_all_nodes_();}
292 33157 : void final_clear_(){final().clear_();}
293 :
294 : template<typename Index>
295 : void final_transfer_range_(
296 : Index& x,
297 : BOOST_DEDUCED_TYPENAME Index::iterator first,
298 : BOOST_DEDUCED_TYPENAME Index::iterator last)
299 : {final().transfer_range_(x,first,last);}
300 :
301 : void final_swap_(final_type& x){final().swap_(x);}
302 :
303 : bool final_replace_(
304 : const value_type& k,final_node_type* x)
305 : {return final().replace_(k,x);}
306 : bool final_replace_rv_(
307 : const value_type& k,final_node_type* x)
308 : {return final().replace_rv_(k,x);}
309 :
310 : template<typename Modifier>
311 1848485 : bool final_modify_(Modifier& mod,final_node_type* x)
312 1848485 : {return final().modify_(mod,x);}
313 :
314 : template<typename Modifier,typename Rollback>
315 : bool final_modify_(Modifier& mod,Rollback& back,final_node_type* x)
316 : {return final().modify_(mod,back,x);}
317 :
318 : #if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING)
319 : void final_check_invariant_()const{final().check_invariant_();}
320 : #endif
321 : };
322 :
323 : } /* namespace multi_index::detail */
324 :
325 : } /* namespace multi_index */
326 :
327 : } /* namespace boost */
328 :
329 : #endif
|
