mdds
multi_type_vector_custom_func2.hpp
1 /*************************************************************************
2  *
3  * Copyright (c) 2013-2016 Kohei Yoshida
4  *
5  * Permission is hereby granted, free of charge, to any person
6  * obtaining a copy of this software and associated documentation
7  * files (the "Software"), to deal in the Software without
8  * restriction, including without limitation the rights to use,
9  * copy, modify, merge, publish, distribute, sublicense, and/or sell
10  * copies of the Software, and to permit persons to whom the
11  * Software is furnished to do so, subject to the following
12  * conditions:
13  *
14  * The above copyright notice and this permission notice shall be
15  * included in all copies or substantial portions of the Software.
16  *
17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
18  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
19  * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
20  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
21  * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
22  * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
23  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
24  * OTHER DEALINGS IN THE SOFTWARE.
25  *
26  ************************************************************************/
27 
28 #ifndef INCLUDED_MDDS_MULTI_TYPE_VECTOR_CUSTOM_FUNC2_HPP
29 #define INCLUDED_MDDS_MULTI_TYPE_VECTOR_CUSTOM_FUNC2_HPP
30 
31 #include "multi_type_vector_types.hpp"
32 #include "multi_type_vector_trait.hpp"
33 
34 namespace mdds { namespace mtv {
35 
39 template<typename _Block1, typename _Block2>
41 {
42  static base_element_block* create_new_block(element_t type, size_t init_size)
43  {
44  switch (type)
45  {
46  case _Block1::block_type:
47  return _Block1::create_block(init_size);
48  case _Block2::block_type:
49  return _Block2::create_block(init_size);
50  default:
51  ;
52  }
53 
54  return element_block_func::create_new_block(type, init_size);
55  }
56 
57  static base_element_block* clone_block(const base_element_block& block)
58  {
59  switch (get_block_type(block))
60  {
61  case _Block1::block_type:
62  return _Block1::clone_block(block);
63  case _Block2::block_type:
64  return _Block2::clone_block(block);
65  default:
66  ;
67  }
68 
69  return element_block_func::clone_block(block);
70  }
71 
72  static void delete_block(const base_element_block* p)
73  {
74  if (!p)
75  return;
76 
77  switch (get_block_type(*p))
78  {
79  case _Block1::block_type:
80  _Block1::delete_block(p);
81  break;
82  case _Block2::block_type:
83  _Block2::delete_block(p);
84  break;
85  default:
86  element_block_func::delete_block(p);
87  }
88  }
89 
90  static void resize_block(base_element_block& block, size_t new_size)
91  {
92  switch (get_block_type(block))
93  {
94  case _Block1::block_type:
95  _Block1::resize_block(block, new_size);
96  break;
97  case _Block2::block_type:
98  _Block2::resize_block(block, new_size);
99  break;
100  default:
101  element_block_func::resize_block(block, new_size);
102  }
103  }
104 
105  static void print_block(const base_element_block& block)
106  {
107  switch (get_block_type(block))
108  {
109  case _Block1::block_type:
110  _Block1::print_block(block);
111  break;
112  case _Block2::block_type:
113  _Block2::print_block(block);
114  break;
115  default:
116  element_block_func::print_block(block);
117  }
118  }
119 
120  static void erase(base_element_block& block, size_t pos)
121  {
122  switch (get_block_type(block))
123  {
124  case _Block1::block_type:
125  _Block1::erase_block(block, pos);
126  break;
127  case _Block2::block_type:
128  _Block2::erase_block(block, pos);
129  break;
130  default:
131  element_block_func::erase(block, pos);
132  }
133  }
134 
135  static void erase(base_element_block& block, size_t pos, size_t size)
136  {
137  switch (get_block_type(block))
138  {
139  case _Block1::block_type:
140  _Block1::erase_block(block, pos, size);
141  break;
142  case _Block2::block_type:
143  _Block2::erase_block(block, pos, size);
144  break;
145  default:
146  element_block_func_base::erase(block, pos, size);
147  }
148  }
149 
150  static void append_values_from_block(base_element_block& dest, const base_element_block& src)
151  {
152  switch (get_block_type(dest))
153  {
154  case _Block1::block_type:
155  _Block1::append_values_from_block(dest, src);
156  break;
157  case _Block2::block_type:
158  _Block2::append_values_from_block(dest, src);
159  break;
160  default:
161  element_block_func_base::append_values_from_block(dest, src);
162  }
163  }
164 
165  static void append_values_from_block(
166  base_element_block& dest, const base_element_block& src, size_t begin_pos, size_t len)
167  {
168  switch (get_block_type(dest))
169  {
170  case _Block1::block_type:
171  _Block1::append_values_from_block(dest, src, begin_pos, len);
172  break;
173  case _Block2::block_type:
174  _Block2::append_values_from_block(dest, src, begin_pos, len);
175  break;
176  default:
177  element_block_func_base::append_values_from_block(dest, src, begin_pos, len);
178  }
179  }
180 
181  static void assign_values_from_block(
182  base_element_block& dest, const base_element_block& src, size_t begin_pos, size_t len)
183  {
184  switch (get_block_type(dest))
185  {
186  case _Block1::block_type:
187  _Block1::assign_values_from_block(dest, src, begin_pos, len);
188  break;
189  case _Block2::block_type:
190  _Block2::assign_values_from_block(dest, src, begin_pos, len);
191  break;
192  default:
193  element_block_func_base::assign_values_from_block(dest, src, begin_pos, len);
194  }
195  }
196 
197  static void prepend_values_from_block(
198  base_element_block& dest, const base_element_block& src, size_t begin_pos, size_t len)
199  {
200  switch (get_block_type(dest))
201  {
202  case _Block1::block_type:
203  _Block1::prepend_values_from_block(dest, src, begin_pos, len);
204  break;
205  case _Block2::block_type:
206  _Block2::prepend_values_from_block(dest, src, begin_pos, len);
207  break;
208  default:
209  element_block_func_base::prepend_values_from_block(dest, src, begin_pos, len);
210  }
211  }
212 
213  static void swap_values(
214  base_element_block& blk1, base_element_block& blk2, size_t pos1, size_t pos2, size_t len)
215  {
216  switch (get_block_type(blk1))
217  {
218  case _Block1::block_type:
219  _Block1::swap_values(blk1, blk2, pos1, pos2, len);
220  break;
221  case _Block2::block_type:
222  _Block2::swap_values(blk1, blk2, pos1, pos2, len);
223  break;
224  default:
225  element_block_func_base::swap_values(blk1, blk2, pos1, pos2, len);
226  }
227  }
228 
229  static bool equal_block(
230  const base_element_block& left, const base_element_block& right)
231  {
232  if (get_block_type(left) == _Block1::block_type)
233  {
234  if (get_block_type(right) != _Block1::block_type)
235  return false;
236 
237  return _Block1::get(left) == _Block1::get(right);
238  }
239  else if (mtv::get_block_type(right) == _Block1::block_type)
240  return false;
241 
242  if (get_block_type(left) == _Block2::block_type)
243  {
244  if (get_block_type(right) != _Block2::block_type)
245  return false;
246 
247  return _Block2::get(left) == _Block2::get(right);
248  }
249  else if (mtv::get_block_type(right) == _Block2::block_type)
250  return false;
251 
252  return element_block_func::equal_block(left, right);
253  }
254 
255  static void overwrite_values(base_element_block& block, size_t pos, size_t len)
256  {
257  switch (get_block_type(block))
258  {
259  case _Block1::block_type:
260  _Block1::overwrite_values(block, pos, len);
261  break;
262  case _Block2::block_type:
263  _Block2::overwrite_values(block, pos, len);
264  break;
265  default:
266  element_block_func::overwrite_values(block, pos, len);
267  }
268  }
269 
270  static void shrink_to_fit(base_element_block& block)
271  {
272  switch (get_block_type(block))
273  {
274  case _Block1::block_type:
275  _Block1::shrink_to_fit(block);
276  break;
277  case _Block2::block_type:
278  _Block2::shrink_to_fit(block);
279  break;
280  default:
281  element_block_func::shrink_to_fit(block);
282  }
283  }
284 
285  static size_t size(const base_element_block& block)
286  {
287  switch (get_block_type(block))
288  {
289  case _Block1::block_type:
290  return _Block1::size(block);
291  case _Block2::block_type:
292  return _Block2::size(block);
293  default:
294  return element_block_func::size(block);
295  }
296  }
297 };
298 
299 }}
300 
301 #endif
Definition: multi_type_vector_types.hpp:88
Definition: multi_type_vector_custom_func2.hpp:40
Definition: default_deleter.hpp:33
static void overwrite_values(base_element_block &block, size_t pos, size_t len)
Definition: multi_type_vector_trait.hpp:610