mdds
multi_type_vector_trait.hpp
1 /*************************************************************************
2  *
3  * Copyright (c) 2012-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_TRAIT_HPP
29 #define INCLUDED_MDDS_MULTI_TYPE_VECTOR_TRAIT_HPP
30 
31 #include "multi_type_vector_types.hpp"
32 
33 #include <vector>
34 
35 namespace mdds { namespace mtv {
36 
37 struct element_block_func_base
38 {
39  inline static base_element_block* create_new_block(element_t type, size_t init_size);
40 
41  inline static base_element_block* clone_block(const base_element_block& block);
42 
43  inline static void delete_block(const base_element_block* p);
44 
45  inline static void resize_block(base_element_block& block, size_t new_size);
46 
47  inline static void print_block(const base_element_block& block);
48 
49  inline static void erase(base_element_block& block, size_t pos);
50 
51  inline static void erase(base_element_block& block, size_t pos, size_t size);
52 
53  inline static void append_values_from_block(base_element_block& dest, const base_element_block& src);
54 
55  inline static void append_values_from_block(
56  base_element_block& dest, const base_element_block& src, size_t begin_pos, size_t len);
57 
58  inline static void assign_values_from_block(
59  base_element_block& dest, const base_element_block& src, size_t begin_pos, size_t len);
60 
61  inline static void prepend_values_from_block(
62  base_element_block& dest, const base_element_block& src, size_t begin_pos, size_t len);
63 
64  inline static void swap_values(
65  base_element_block& blk1, base_element_block& blk2, size_t pos1, size_t pos2, size_t len);
66 
67  inline static bool equal_block(const base_element_block& left, const base_element_block& right);
68 
76  inline static void overwrite_values(base_element_block& block, size_t pos, size_t len);
77 
78  inline static void shrink_to_fit(base_element_block& block);
79 
80  inline static size_t size(const base_element_block& block);
81 };
82 
83 base_element_block* element_block_func_base::create_new_block(element_t type, size_t init_size)
84 {
85  switch (type)
86  {
87  case element_type_float:
88  return float_element_block::create_block(init_size);
89  case element_type_double:
90  return double_element_block::create_block(init_size);
91  case element_type_string:
92  return string_element_block::create_block(init_size);
93  case element_type_int16:
94  return int16_element_block::create_block(init_size);
95  case element_type_uint16:
96  return uint16_element_block::create_block(init_size);
97  case element_type_int32:
98  return int32_element_block::create_block(init_size);
99  case element_type_uint32:
100  return uint32_element_block::create_block(init_size);
101  case element_type_int64:
102  return int64_element_block::create_block(init_size);
103  case element_type_uint64:
104  return uint64_element_block::create_block(init_size);
105  case element_type_boolean:
106  return boolean_element_block::create_block(init_size);
107  case element_type_int8:
108  return int8_element_block::create_block(init_size);
109  case element_type_uint8:
110  return uint8_element_block::create_block(init_size);
111  default:
112  throw general_error("create_new_block: failed to create a new block of unknown type.");
113  }
114 }
115 
116 base_element_block* element_block_func_base::clone_block(const base_element_block& block)
117 {
118  switch (get_block_type(block))
119  {
120  case element_type_float:
121  return float_element_block::clone_block(block);
122  case element_type_double:
123  return double_element_block::clone_block(block);
124  case element_type_string:
125  return string_element_block::clone_block(block);
126  case element_type_int16:
127  return int16_element_block::clone_block(block);
128  case element_type_uint16:
129  return uint16_element_block::clone_block(block);
130  case element_type_int32:
131  return int32_element_block::clone_block(block);
132  case element_type_uint32:
133  return uint32_element_block::clone_block(block);
134  case element_type_int64:
135  return int64_element_block::clone_block(block);
136  case element_type_uint64:
137  return uint64_element_block::clone_block(block);
138  case element_type_boolean:
139  return boolean_element_block::clone_block(block);
140  case element_type_int8:
141  return int8_element_block::clone_block(block);
142  case element_type_uint8:
143  return uint8_element_block::clone_block(block);
144  default:
145  throw general_error("clone_block: failed to clone a block of unknown type.");
146  }
147 }
148 
149 void element_block_func_base::delete_block(const base_element_block* p)
150 {
151  if (!p)
152  return;
153 
154  switch (get_block_type(*p))
155  {
156  case element_type_float:
157  float_element_block::delete_block(p);
158  break;
159  case element_type_double:
160  double_element_block::delete_block(p);
161  break;
162  case element_type_string:
163  string_element_block::delete_block(p);
164  break;
165  case element_type_int16:
166  int16_element_block::delete_block(p);
167  break;
168  case element_type_uint16:
169  uint16_element_block::delete_block(p);
170  break;
171  case element_type_int32:
172  int32_element_block::delete_block(p);
173  break;
174  case element_type_uint32:
175  uint32_element_block::delete_block(p);
176  break;
177  case element_type_int64:
178  int64_element_block::delete_block(p);
179  break;
180  case element_type_uint64:
181  uint64_element_block::delete_block(p);
182  break;
183  case element_type_boolean:
184  boolean_element_block::delete_block(p);
185  break;
186  case element_type_int8:
187  int8_element_block::delete_block(p);
188  break;
189  case element_type_uint8:
190  uint8_element_block::delete_block(p);
191  break;
192  default:
193  {
194 #ifdef MDDS_MULTI_TYPE_VECTOR_DEBUG
195  // We sould not throw an exception here as this gets called from a
196  // destructor and destructors should not throw exceptions.
197  cerr << __FILE__ << "#" << __LINE__ << " (element_block_func_base:delete_block): "
198  << "failed to delete a block of unknown type (" << get_block_type(*p) << ")"
199  << endl;
200 #endif
201  }
202  }
203 }
204 
205 void element_block_func_base::resize_block(base_element_block& block, size_t new_size)
206 {
207  switch (get_block_type(block))
208  {
209  case element_type_float:
210  float_element_block::resize_block(block, new_size);
211  break;
212  case element_type_double:
213  double_element_block::resize_block(block, new_size);
214  break;
215  case element_type_string:
216  string_element_block::resize_block(block, new_size);
217  break;
218  case element_type_int16:
219  int16_element_block::resize_block(block, new_size);
220  break;
221  case element_type_uint16:
222  uint16_element_block::resize_block(block, new_size);
223  break;
224  case element_type_int32:
225  int32_element_block::resize_block(block, new_size);
226  break;
227  case element_type_uint32:
228  uint32_element_block::resize_block(block, new_size);
229  break;
230  case element_type_int64:
231  int64_element_block::resize_block(block, new_size);
232  break;
233  case element_type_uint64:
234  uint64_element_block::resize_block(block, new_size);
235  break;
236  case element_type_boolean:
237  boolean_element_block::resize_block(block, new_size);
238  break;
239  case element_type_int8:
240  int8_element_block::resize_block(block, new_size);
241  break;
242  case element_type_uint8:
243  uint8_element_block::resize_block(block, new_size);
244  break;
245  default:
246  throw general_error("resize_block: failed to resize a block of unknown type.");
247  }
248 }
249 
250 void element_block_func_base::print_block(const base_element_block& block)
251 {
252  switch (get_block_type(block))
253  {
254  case element_type_float:
255  float_element_block::print_block(block);
256  break;
257  case element_type_double:
258  double_element_block::print_block(block);
259  break;
260  case element_type_string:
261  string_element_block::print_block(block);
262  break;
263  case element_type_int16:
264  int16_element_block::print_block(block);
265  break;
266  case element_type_uint16:
267  uint16_element_block::print_block(block);
268  break;
269  case element_type_int32:
270  int32_element_block::print_block(block);
271  break;
272  case element_type_uint32:
273  uint32_element_block::print_block(block);
274  break;
275  case element_type_int64:
276  int64_element_block::print_block(block);
277  break;
278  case element_type_uint64:
279  uint64_element_block::print_block(block);
280  break;
281  case element_type_boolean:
282  boolean_element_block::print_block(block);
283  break;
284  case element_type_int8:
285  int8_element_block::print_block(block);
286  break;
287  case element_type_uint8:
288  uint8_element_block::print_block(block);
289  break;
290  default:
291  throw general_error("print_block: failed to print a block of unknown type.");
292  }
293 }
294 
295 void element_block_func_base::erase(base_element_block& block, size_t pos)
296 {
297  switch (get_block_type(block))
298  {
299  case element_type_float:
300  float_element_block::erase_block(block, pos);
301  break;
302  case element_type_double:
303  double_element_block::erase_block(block, pos);
304  break;
305  case element_type_string:
306  string_element_block::erase_block(block, pos);
307  break;
308  case element_type_int16:
309  int16_element_block::erase_block(block, pos);
310  break;
311  case element_type_uint16:
312  uint16_element_block::erase_block(block, pos);
313  break;
314  case element_type_int32:
315  int32_element_block::erase_block(block, pos);
316  break;
317  case element_type_uint32:
318  uint32_element_block::erase_block(block, pos);
319  break;
320  case element_type_int64:
321  int64_element_block::erase_block(block, pos);
322  break;
323  case element_type_uint64:
324  uint64_element_block::erase_block(block, pos);
325  break;
326  case element_type_boolean:
327  boolean_element_block::erase_block(block, pos);
328  break;
329  case element_type_int8:
330  int8_element_block::erase_block(block, pos);
331  break;
332  case element_type_uint8:
333  uint8_element_block::erase_block(block, pos);
334  break;
335  default:
336  throw general_error("erase: failed to erase an element from a block of unknown type.");
337  }
338 }
339 
340 void element_block_func_base::erase(base_element_block& block, size_t pos, size_t size)
341 {
342  switch (get_block_type(block))
343  {
344  case element_type_float:
345  float_element_block::erase_block(block, pos, size);
346  break;
347  case element_type_double:
348  double_element_block::erase_block(block, pos, size);
349  break;
350  case element_type_string:
351  string_element_block::erase_block(block, pos, size);
352  break;
353  case element_type_int16:
354  int16_element_block::erase_block(block, pos, size);
355  break;
356  case element_type_uint16:
357  uint16_element_block::erase_block(block, pos, size);
358  break;
359  case element_type_int32:
360  int32_element_block::erase_block(block, pos, size);
361  break;
362  case element_type_uint32:
363  uint32_element_block::erase_block(block, pos, size);
364  break;
365  case element_type_int64:
366  int64_element_block::erase_block(block, pos, size);
367  break;
368  case element_type_uint64:
369  uint64_element_block::erase_block(block, pos, size);
370  break;
371  case element_type_boolean:
372  boolean_element_block::erase_block(block, pos, size);
373  break;
374  case element_type_int8:
375  int8_element_block::erase_block(block, pos, size);
376  break;
377  case element_type_uint8:
378  uint8_element_block::erase_block(block, pos, size);
379  break;
380  default:
381  throw general_error("erase: failed to erase elements from a block of unknown type.");
382  }
383 }
384 
385 void element_block_func_base::append_values_from_block(base_element_block& dest, const base_element_block& src)
386 {
387  switch (get_block_type(dest))
388  {
389  case element_type_float:
390  float_element_block::append_values_from_block(dest, src);
391  break;
392  case element_type_double:
393  double_element_block::append_values_from_block(dest, src);
394  break;
395  case element_type_string:
396  string_element_block::append_values_from_block(dest, src);
397  break;
398  case element_type_int16:
399  int16_element_block::append_values_from_block(dest, src);
400  break;
401  case element_type_uint16:
402  uint16_element_block::append_values_from_block(dest, src);
403  break;
404  case element_type_int32:
405  int32_element_block::append_values_from_block(dest, src);
406  break;
407  case element_type_uint32:
408  uint32_element_block::append_values_from_block(dest, src);
409  break;
410  case element_type_int64:
411  int64_element_block::append_values_from_block(dest, src);
412  break;
413  case element_type_uint64:
414  uint64_element_block::append_values_from_block(dest, src);
415  break;
416  case element_type_boolean:
417  boolean_element_block::append_values_from_block(dest, src);
418  break;
419  case element_type_int8:
420  int8_element_block::append_values_from_block(dest, src);
421  break;
422  case element_type_uint8:
423  uint8_element_block::append_values_from_block(dest, src);
424  break;
425  default:
426  throw general_error("append_values: failed to append values to a block of unknown type.");
427  }
428 }
429 
430 void element_block_func_base::append_values_from_block(
431  base_element_block& dest, const base_element_block& src, size_t begin_pos, size_t len)
432 {
433  switch (get_block_type(dest))
434  {
435  case element_type_float:
436  float_element_block::append_values_from_block(dest, src, begin_pos, len);
437  break;
438  case element_type_double:
439  double_element_block::append_values_from_block(dest, src, begin_pos, len);
440  break;
441  case element_type_string:
442  string_element_block::append_values_from_block(dest, src, begin_pos, len);
443  break;
444  case element_type_int16:
445  int16_element_block::append_values_from_block(dest, src, begin_pos, len);
446  break;
447  case element_type_uint16:
448  uint16_element_block::append_values_from_block(dest, src, begin_pos, len);
449  break;
450  case element_type_int32:
451  int32_element_block::append_values_from_block(dest, src, begin_pos, len);
452  break;
453  case element_type_uint32:
454  uint32_element_block::append_values_from_block(dest, src, begin_pos, len);
455  break;
456  case element_type_int64:
457  int64_element_block::append_values_from_block(dest, src, begin_pos, len);
458  break;
459  case element_type_uint64:
460  uint64_element_block::append_values_from_block(dest, src, begin_pos, len);
461  break;
462  case element_type_boolean:
463  boolean_element_block::append_values_from_block(dest, src, begin_pos, len);
464  break;
465  case element_type_int8:
466  int8_element_block::append_values_from_block(dest, src, begin_pos, len);
467  break;
468  case element_type_uint8:
469  uint8_element_block::append_values_from_block(dest, src, begin_pos, len);
470  break;
471  default:
472  throw general_error("append_values: failed to append values to a block of unknown type.");
473  }
474 }
475 
476 void element_block_func_base::assign_values_from_block(
477  base_element_block& dest, const base_element_block& src, size_t begin_pos, size_t len)
478 {
479  switch (get_block_type(dest))
480  {
481  case element_type_float:
482  float_element_block::assign_values_from_block(dest, src, begin_pos, len);
483  break;
484  case element_type_double:
485  double_element_block::assign_values_from_block(dest, src, begin_pos, len);
486  break;
487  case element_type_string:
488  string_element_block::assign_values_from_block(dest, src, begin_pos, len);
489  break;
490  case element_type_int16:
491  int16_element_block::assign_values_from_block(dest, src, begin_pos, len);
492  break;
493  case element_type_uint16:
494  uint16_element_block::assign_values_from_block(dest, src, begin_pos, len);
495  break;
496  case element_type_int32:
497  int32_element_block::assign_values_from_block(dest, src, begin_pos, len);
498  break;
499  case element_type_uint32:
500  uint32_element_block::assign_values_from_block(dest, src, begin_pos, len);
501  break;
502  case element_type_int64:
503  int64_element_block::assign_values_from_block(dest, src, begin_pos, len);
504  break;
505  case element_type_uint64:
506  uint64_element_block::assign_values_from_block(dest, src, begin_pos, len);
507  break;
508  case element_type_boolean:
509  boolean_element_block::assign_values_from_block(dest, src, begin_pos, len);
510  break;
511  case element_type_int8:
512  int8_element_block::assign_values_from_block(dest, src, begin_pos, len);
513  break;
514  case element_type_uint8:
515  uint8_element_block::assign_values_from_block(dest, src, begin_pos, len);
516  break;
517  default:
518  throw general_error("assign_values_from_block: failed to assign values to a block of unknown type.");
519  }
520 }
521 
522 void element_block_func_base::prepend_values_from_block(
523  base_element_block& dest, const base_element_block& src, size_t begin_pos, size_t len)
524 {
525  switch (get_block_type(dest))
526  {
527  case element_type_float:
528  float_element_block::prepend_values_from_block(dest, src, begin_pos, len);
529  break;
530  case element_type_double:
531  double_element_block::prepend_values_from_block(dest, src, begin_pos, len);
532  break;
533  case element_type_string:
534  string_element_block::prepend_values_from_block(dest, src, begin_pos, len);
535  break;
536  case element_type_int16:
537  int16_element_block::prepend_values_from_block(dest, src, begin_pos, len);
538  break;
539  case element_type_uint16:
540  uint16_element_block::prepend_values_from_block(dest, src, begin_pos, len);
541  break;
542  case element_type_int32:
543  int32_element_block::prepend_values_from_block(dest, src, begin_pos, len);
544  break;
545  case element_type_uint32:
546  uint32_element_block::prepend_values_from_block(dest, src, begin_pos, len);
547  break;
548  case element_type_int64:
549  int64_element_block::prepend_values_from_block(dest, src, begin_pos, len);
550  break;
551  case element_type_uint64:
552  uint64_element_block::prepend_values_from_block(dest, src, begin_pos, len);
553  break;
554  case element_type_boolean:
555  boolean_element_block::prepend_values_from_block(dest, src, begin_pos, len);
556  break;
557  case element_type_int8:
558  int8_element_block::prepend_values_from_block(dest, src, begin_pos, len);
559  break;
560  case element_type_uint8:
561  uint8_element_block::prepend_values_from_block(dest, src, begin_pos, len);
562  break;
563  default:
564  throw general_error("prepend_values_from_block: failed to prepend values to a block of unknown type.");
565  }
566 }
567 
568 void element_block_func_base::swap_values(
569  base_element_block& blk1, base_element_block& blk2, size_t pos1, size_t pos2, size_t len)
570 {
571  element_t blk1_type = get_block_type(blk1);
572  assert(blk1_type == get_block_type(blk2));
573 
574  switch (blk1_type)
575  {
576  case element_type_float:
577  float_element_block::swap_values(blk1, blk2, pos1, pos2, len);
578  break;
579  case element_type_double:
580  double_element_block::swap_values(blk1, blk2, pos1, pos2, len);
581  break;
582  case element_type_string:
583  string_element_block::swap_values(blk1, blk2, pos1, pos2, len);
584  break;
585  case element_type_int16:
586  int16_element_block::swap_values(blk1, blk2, pos1, pos2, len);
587  break;
588  case element_type_uint16:
589  uint16_element_block::swap_values(blk1, blk2, pos1, pos2, len);
590  break;
591  case element_type_int32:
592  int32_element_block::swap_values(blk1, blk2, pos1, pos2, len);
593  break;
594  case element_type_uint32:
595  uint32_element_block::swap_values(blk1, blk2, pos1, pos2, len);
596  break;
597  case element_type_int64:
598  int64_element_block::swap_values(blk1, blk2, pos1, pos2, len);
599  break;
600  case element_type_uint64:
601  uint64_element_block::swap_values(blk1, blk2, pos1, pos2, len);
602  break;
603  case element_type_boolean:
604  boolean_element_block::swap_values(blk1, blk2, pos1, pos2, len);
605  break;
606  case element_type_int8:
607  int8_element_block::swap_values(blk1, blk2, pos1, pos2, len);
608  break;
609  case element_type_uint8:
610  uint8_element_block::swap_values(blk1, blk2, pos1, pos2, len);
611  break;
612  default:
613  throw general_error("swap_values: block of unknown type.");
614  }
615 }
616 
617 bool element_block_func_base::equal_block(const base_element_block& left, const base_element_block& right)
618 {
619  element_t block_type = get_block_type(left);
620  if (block_type != get_block_type(right))
621  return false;
622 
623  switch (block_type)
624  {
625  case element_type_float:
626  return float_element_block::get(left) == float_element_block::get(right);
627  case element_type_double:
628  return double_element_block::get(left) == double_element_block::get(right);
629  case element_type_string:
630  return string_element_block::get(left) == string_element_block::get(right);
631  case element_type_int16:
632  return int16_element_block::get(left) == int16_element_block::get(right);
633  case element_type_uint16:
634  return uint16_element_block::get(left) == uint16_element_block::get(right);
635  case element_type_int32:
636  return int32_element_block::get(left) == int32_element_block::get(right);
637  case element_type_uint32:
638  return uint32_element_block::get(left) == uint32_element_block::get(right);
639  case element_type_int64:
640  return int64_element_block::get(left) == int64_element_block::get(right);
641  case element_type_uint64:
642  return uint64_element_block::get(left) == uint64_element_block::get(right);
643  case element_type_boolean:
644  return boolean_element_block::get(left) == boolean_element_block::get(right);
645  case element_type_int8:
646  return int8_element_block::get(left) == int8_element_block::get(right);
647  case element_type_uint8:
648  return uint8_element_block::get(left) == uint8_element_block::get(right);
649  default:
650  ;
651  }
652  return false;
653 }
654 
655 void element_block_func_base::overwrite_values(base_element_block&, size_t, size_t)
656 {
657  // Do nothing for the standard types.
658 }
659 
660 void element_block_func_base::shrink_to_fit(base_element_block& block)
661 {
662  switch (get_block_type(block))
663  {
664  case element_type_float:
665  float_element_block::shrink_to_fit(block);
666  break;
667  case element_type_double:
668  double_element_block::shrink_to_fit(block);
669  break;
670  case element_type_string:
671  string_element_block::shrink_to_fit(block);
672  break;
673  case element_type_int16:
674  int16_element_block::shrink_to_fit(block);
675  break;
676  case element_type_uint16:
677  uint16_element_block::shrink_to_fit(block);
678  break;
679  case element_type_int32:
680  int32_element_block::shrink_to_fit(block);
681  break;
682  case element_type_uint32:
683  uint32_element_block::shrink_to_fit(block);
684  break;
685  case element_type_int64:
686  int64_element_block::shrink_to_fit(block);
687  break;
688  case element_type_uint64:
689  uint64_element_block::shrink_to_fit(block);
690  break;
691  case element_type_boolean:
692  boolean_element_block::shrink_to_fit(block);
693  break;
694  case element_type_int8:
695  int8_element_block::shrink_to_fit(block);
696  break;
697  case element_type_uint8:
698  uint8_element_block::shrink_to_fit(block);
699  break;
700  default:
701  throw general_error("shrink_to_fit: failed to print a block of unknown type.");
702  }
703 }
704 
705 size_t element_block_func_base::size(const base_element_block& block)
706 {
707  switch (get_block_type(block))
708  {
709  case element_type_float:
710  return float_element_block::size(block);
711  case element_type_double:
712  return double_element_block::size(block);
713  case element_type_string:
714  return string_element_block::size(block);
715  case element_type_int16:
716  return int16_element_block::size(block);
717  case element_type_uint16:
718  return uint16_element_block::size(block);
719  case element_type_int32:
720  return int32_element_block::size(block);
721  case element_type_uint32:
722  return uint32_element_block::size(block);
723  case element_type_int64:
724  return int64_element_block::size(block);
725  case element_type_uint64:
726  return uint64_element_block::size(block);
727  case element_type_boolean:
728  return boolean_element_block::size(block);
729  case element_type_int8:
730  return int8_element_block::size(block);
731  case element_type_uint8:
732  return uint8_element_block::size(block);
733  default:
734  throw general_error("size: failed to print a block of unknown type.");
735  }
736 }
737 
743 
744 }}
745 
746 #endif
mdds::general_error
Definition: global.hpp:70
mdds::mtv::element_block_func_base
Definition: multi_type_vector_trait.hpp:87
mdds::mtv::base_element_block
Definition: multi_type_vector_types.hpp:139
mdds::mtv::element_block_func_base::overwrite_values
static void overwrite_values(base_element_block &block, size_t pos, size_t len)
Definition: multi_type_vector_trait.hpp:705
mdds::mtv::element_block_func
Definition: multi_type_vector_trait.hpp:792