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