1 // Copyright (c) Lawrence Livermore National Security, LLC and other Conduit
2 // Project developers. See top-level LICENSE AND COPYRIGHT files for dates and
3 // other details. No copyright assignment is required to contribute to Conduit.
4
5 //-----------------------------------------------------------------------------
6 ///
7 /// file: conduit_data_type.cpp
8 ///
9 //-----------------------------------------------------------------------------
10 #include "conduit_data_type.hpp"
11
12 //-----------------------------------------------------------------------------
13 // conduit includes
14 //-----------------------------------------------------------------------------
15 #include "conduit_utils.hpp"
16 #include "conduit_schema.hpp"
17
18 #ifdef CONDUIT_USE_CXX11
19 //-----------------------------------------------------------------------------
20 // Sanity checks of conduit types vs C++11 Types
21 //-----------------------------------------------------------------------------
22
23 //-----------------------------------------------------------------------------
24 // Checked here to avoid header dep of C++11 in client code
25 //-----------------------------------------------------------------------------
26 #include <cstdint>
27 #include <type_traits>
28
29 // signed integers
30 static_assert(std::is_same<conduit_int8, std::int8_t>::value,
31 "error: conduit_int8 != std::int8_t");
32
33 static_assert(std::is_same<conduit_int16, std::int16_t>::value,
34 "error: conduit_int16 != std::int16_t");
35
36 static_assert(std::is_same<conduit_int32, std::int32_t>::value,
37 "error: conduit_int32 != std::int32_t");
38
39 static_assert(std::is_same<conduit_int64, std::int64_t>::value,
40 "error: conduit_int64 != std::int64_t");
41
42 // unsigned integers
43 static_assert(std::is_same<conduit_uint8, std::uint8_t>::value,
44 "error: conduit_uint8 != std::uint8_t");
45
46 static_assert(std::is_same<conduit_uint16, std::uint16_t>::value,
47 "error: conduit_uint16 != std::uint16_t");
48
49 static_assert(std::is_same<conduit_uint32, std::uint32_t>::value,
50 "error: conduit_uint32 != std::uint32_t");
51
52 static_assert(std::is_same<conduit_uint64, std::uint64_t>::value,
53 "error: conduit_uint64 != std::uint64_t");
54
55 #endif
56
57 //-----------------------------------------------------------------------------
58 // -- begin conduit:: --
59 //-----------------------------------------------------------------------------
60 namespace conduit
61 {
62
63
64 DataType
empty()65 DataType::empty()
66 {
67 return DataType(EMPTY_ID);
68 }
69
70 DataType
object()71 DataType::object()
72 {
73 return DataType(OBJECT_ID);
74 }
75
76 DataType
list()77 DataType::list()
78 {
79 return DataType(LIST_ID);
80 }
81
82
83
84 //-----------------------------------------------------------------------------
85 /// signed integer arrays
86 //---------------------------------------------------------------------------//
87 DataType
int8(conduit::index_t num_elements,conduit::index_t offset,conduit::index_t stride,conduit::index_t element_bytes,conduit::index_t endianness)88 DataType::int8(conduit::index_t num_elements,
89 conduit::index_t offset,
90 conduit::index_t stride,
91 conduit::index_t element_bytes,
92 conduit::index_t endianness)
93 {
94 return DataType(INT8_ID,num_elements,offset,stride,element_bytes,endianness);
95 }
96
97 //---------------------------------------------------------------------------//
98 DataType
int16(conduit::index_t num_elements,conduit::index_t offset,conduit::index_t stride,conduit::index_t element_bytes,conduit::index_t endianness)99 DataType::int16(conduit::index_t num_elements,
100 conduit::index_t offset,
101 conduit::index_t stride,
102 conduit::index_t element_bytes,
103 conduit::index_t endianness)
104 {
105 return DataType(INT16_ID,num_elements,offset,stride,element_bytes,endianness);
106 }
107
108 //---------------------------------------------------------------------------//
109 DataType
int32(conduit::index_t num_elements,conduit::index_t offset,conduit::index_t stride,conduit::index_t element_bytes,conduit::index_t endianness)110 DataType::int32(conduit::index_t num_elements,
111 conduit::index_t offset,
112 conduit::index_t stride,
113 conduit::index_t element_bytes,
114 conduit::index_t endianness)
115 {
116 return DataType(INT32_ID,num_elements,offset,stride,element_bytes,endianness);
117 }
118
119 //---------------------------------------------------------------------------//
120 DataType
int64(conduit::index_t num_elements,conduit::index_t offset,conduit::index_t stride,conduit::index_t element_bytes,conduit::index_t endianness)121 DataType::int64(conduit::index_t num_elements,
122 conduit::index_t offset,
123 conduit::index_t stride,
124 conduit::index_t element_bytes,
125 conduit::index_t endianness)
126 {
127 return DataType(INT64_ID,num_elements,offset,stride,element_bytes,endianness);
128 }
129
130 /// unsigned integer arrays
131 //---------------------------------------------------------------------------//
132 DataType
uint8(conduit::index_t num_elements,conduit::index_t offset,conduit::index_t stride,conduit::index_t element_bytes,conduit::index_t endianness)133 DataType::uint8(conduit::index_t num_elements,
134 conduit::index_t offset,
135 conduit::index_t stride,
136 conduit::index_t element_bytes,
137 conduit::index_t endianness)
138 {
139 return DataType(UINT8_ID,num_elements,offset,stride,element_bytes,endianness);
140 }
141
142 //---------------------------------------------------------------------------//
143 DataType
uint16(conduit::index_t num_elements,conduit::index_t offset,conduit::index_t stride,conduit::index_t element_bytes,conduit::index_t endianness)144 DataType::uint16(conduit::index_t num_elements,
145 conduit::index_t offset,
146 conduit::index_t stride,
147 conduit::index_t element_bytes,
148 conduit::index_t endianness)
149 {
150 return DataType(UINT16_ID,num_elements,offset,stride,element_bytes,endianness);
151 }
152
153 //---------------------------------------------------------------------------//
154 DataType
uint32(conduit::index_t num_elements,conduit::index_t offset,conduit::index_t stride,conduit::index_t element_bytes,conduit::index_t endianness)155 DataType::uint32(conduit::index_t num_elements,
156 conduit::index_t offset,
157 conduit::index_t stride,
158 conduit::index_t element_bytes,
159 conduit::index_t endianness)
160 {
161 return DataType(UINT32_ID,num_elements,offset,stride,element_bytes,endianness);
162 }
163
164 //---------------------------------------------------------------------------//
165 DataType
uint64(conduit::index_t num_elements,conduit::index_t offset,conduit::index_t stride,conduit::index_t element_bytes,conduit::index_t endianness)166 DataType::uint64(conduit::index_t num_elements,
167 conduit::index_t offset,
168 conduit::index_t stride,
169 conduit::index_t element_bytes,
170 conduit::index_t endianness)
171 {
172 return DataType(UINT64_ID,num_elements,offset,stride,element_bytes,endianness);
173 }
174
175 /// floating point arrays
176 //---------------------------------------------------------------------------//
177 DataType
float32(conduit::index_t num_elements,conduit::index_t offset,conduit::index_t stride,conduit::index_t element_bytes,conduit::index_t endianness)178 DataType::float32(conduit::index_t num_elements,
179 conduit::index_t offset,
180 conduit::index_t stride,
181 conduit::index_t element_bytes,
182 conduit::index_t endianness)
183 {
184 return DataType(FLOAT32_ID,num_elements,offset,stride,element_bytes,endianness);
185 }
186
187 //---------------------------------------------------------------------------//
188 DataType
float64(conduit::index_t num_elements,conduit::index_t offset,conduit::index_t stride,conduit::index_t element_bytes,conduit::index_t endianness)189 DataType::float64(conduit::index_t num_elements,
190 conduit::index_t offset,
191 conduit::index_t stride,
192 conduit::index_t element_bytes,
193 conduit::index_t endianness)
194 {
195 return DataType(FLOAT64_ID,num_elements,offset,stride,element_bytes,endianness);
196 }
197
198 //---------------------------------------------------------------------------//
199 DataType
char8_str(conduit::index_t num_elements,conduit::index_t offset,conduit::index_t stride,conduit::index_t element_bytes,conduit::index_t endianness)200 DataType::char8_str(conduit::index_t num_elements,
201 conduit::index_t offset,
202 conduit::index_t stride,
203 conduit::index_t element_bytes,
204 conduit::index_t endianness)
205 {
206 return DataType(CHAR8_STR_ID,
207 num_elements,
208 offset,
209 stride,
210 element_bytes,
211 endianness);
212 }
213
214
215 //---------------------------------------------------------------------------//
216 DataType
index_t(conduit::index_t num_elements,conduit::index_t offset,conduit::index_t stride,conduit::index_t element_bytes,conduit::index_t endianness)217 DataType::index_t(conduit::index_t num_elements,
218 conduit::index_t offset,
219 conduit::index_t stride,
220 conduit::index_t element_bytes,
221 conduit::index_t endianness)
222 {
223 #ifdef CONDUIT_INDEX_32
224 return DataType(INT32_ID,
225 num_elements,offset,stride,element_bytes,endianness);
226 #else
227 return DataType(INT64_ID,
228 num_elements,offset,stride,element_bytes,endianness);
229 #endif
230 }
231
232 /// native c types
233 //-----------------------------------------------------------------------------
234 /// signed integer arrays
235 //---------------------------------------------------------------------------//
236 DataType
c_char(conduit::index_t num_elements,conduit::index_t offset,conduit::index_t stride,conduit::index_t element_bytes,conduit::index_t endianness)237 DataType::c_char(conduit::index_t num_elements,
238 conduit::index_t offset,
239 conduit::index_t stride,
240 conduit::index_t element_bytes,
241 conduit::index_t endianness)
242 {
243 return DataType(CONDUIT_NATIVE_CHAR_ID,
244 num_elements,offset,stride,element_bytes,endianness);
245 }
246
247 //---------------------------------------------------------------------------//
248 DataType
c_short(conduit::index_t num_elements,conduit::index_t offset,conduit::index_t stride,conduit::index_t element_bytes,conduit::index_t endianness)249 DataType::c_short(conduit::index_t num_elements,
250 conduit::index_t offset,
251 conduit::index_t stride,
252 conduit::index_t element_bytes,
253 conduit::index_t endianness)
254 {
255 return DataType(CONDUIT_NATIVE_SHORT_ID,
256 num_elements,offset,stride,element_bytes,endianness);
257 }
258
259 //---------------------------------------------------------------------------//
260 DataType
c_int(conduit::index_t num_elements,conduit::index_t offset,conduit::index_t stride,conduit::index_t element_bytes,conduit::index_t endianness)261 DataType::c_int(conduit::index_t num_elements,
262 conduit::index_t offset,
263 conduit::index_t stride,
264 conduit::index_t element_bytes,
265 conduit::index_t endianness)
266 {
267 return DataType(CONDUIT_NATIVE_INT_ID,
268 num_elements,offset,stride,element_bytes,endianness);
269 }
270
271 //---------------------------------------------------------------------------//
272 DataType
c_long(conduit::index_t num_elements,conduit::index_t offset,conduit::index_t stride,conduit::index_t element_bytes,conduit::index_t endianness)273 DataType::c_long(conduit::index_t num_elements,
274 conduit::index_t offset,
275 conduit::index_t stride,
276 conduit::index_t element_bytes,
277 conduit::index_t endianness)
278 {
279 return DataType(CONDUIT_NATIVE_LONG_ID,
280 num_elements,offset,stride,element_bytes,endianness);
281 }
282
283 #ifdef CONDUIT_HAS_LONG_LONG
284 //---------------------------------------------------------------------------//
285 DataType
c_long_long(conduit::index_t num_elements,conduit::index_t offset,conduit::index_t stride,conduit::index_t element_bytes,conduit::index_t endianness)286 DataType::c_long_long(conduit::index_t num_elements,
287 conduit::index_t offset,
288 conduit::index_t stride,
289 conduit::index_t element_bytes,
290 conduit::index_t endianness)
291 {
292 return DataType(CONDUIT_NATIVE_LONG_LONG_ID,
293 num_elements,offset,stride,element_bytes,endianness);
294 }
295 #endif
296
297 /// unsigned integer arrays
298 //---------------------------------------------------------------------------//
299 DataType
c_signed_char(conduit::index_t num_elements,conduit::index_t offset,conduit::index_t stride,conduit::index_t element_bytes,conduit::index_t endianness)300 DataType::c_signed_char(conduit::index_t num_elements,
301 conduit::index_t offset,
302 conduit::index_t stride,
303 conduit::index_t element_bytes,
304 conduit::index_t endianness)
305 {
306 return DataType(CONDUIT_NATIVE_SIGNED_CHAR_ID,
307 num_elements,offset,stride,element_bytes,endianness);
308 }
309
310 //---------------------------------------------------------------------------//
311 DataType
c_signed_short(conduit::index_t num_elements,conduit::index_t offset,conduit::index_t stride,conduit::index_t element_bytes,conduit::index_t endianness)312 DataType::c_signed_short(conduit::index_t num_elements,
313 conduit::index_t offset,
314 conduit::index_t stride,
315 conduit::index_t element_bytes,
316 conduit::index_t endianness)
317 {
318 return DataType(CONDUIT_NATIVE_SIGNED_SHORT_ID,
319 num_elements,offset,stride,element_bytes,endianness);
320 }
321
322 //---------------------------------------------------------------------------//
323 DataType
c_signed_int(conduit::index_t num_elements,conduit::index_t offset,conduit::index_t stride,conduit::index_t element_bytes,conduit::index_t endianness)324 DataType::c_signed_int(conduit::index_t num_elements,
325 conduit::index_t offset,
326 conduit::index_t stride,
327 conduit::index_t element_bytes,
328 conduit::index_t endianness)
329 {
330 return DataType(CONDUIT_NATIVE_SIGNED_INT_ID,
331 num_elements,offset,stride,element_bytes,endianness);
332 }
333
334 //---------------------------------------------------------------------------//
335 DataType
c_signed_long(conduit::index_t num_elements,conduit::index_t offset,conduit::index_t stride,conduit::index_t element_bytes,conduit::index_t endianness)336 DataType::c_signed_long(conduit::index_t num_elements,
337 conduit::index_t offset,
338 conduit::index_t stride,
339 conduit::index_t element_bytes,
340 conduit::index_t endianness)
341 {
342 return DataType(CONDUIT_NATIVE_SIGNED_LONG_ID,
343 num_elements,offset,stride,element_bytes,endianness);
344 }
345
346 #ifdef CONDUIT_HAS_LONG_LONG
347 //---------------------------------------------------------------------------//
348 DataType
c_signed_long_long(conduit::index_t num_elements,conduit::index_t offset,conduit::index_t stride,conduit::index_t element_bytes,conduit::index_t endianness)349 DataType::c_signed_long_long(conduit::index_t num_elements,
350 conduit::index_t offset,
351 conduit::index_t stride,
352 conduit::index_t element_bytes,
353 conduit::index_t endianness)
354 {
355 return DataType(CONDUIT_NATIVE_SIGNED_LONG_LONG_ID,
356 num_elements,offset,stride,element_bytes,endianness);
357 }
358 #endif
359
360
361
362 /// unsigned integer arrays
363 //---------------------------------------------------------------------------//
364 DataType
c_unsigned_char(conduit::index_t num_elements,conduit::index_t offset,conduit::index_t stride,conduit::index_t element_bytes,conduit::index_t endianness)365 DataType::c_unsigned_char(conduit::index_t num_elements,
366 conduit::index_t offset,
367 conduit::index_t stride,
368 conduit::index_t element_bytes,
369 conduit::index_t endianness)
370 {
371 return DataType(CONDUIT_NATIVE_UNSIGNED_CHAR_ID,
372 num_elements,offset,stride,element_bytes,endianness);
373 }
374
375 //---------------------------------------------------------------------------//
376 DataType
c_unsigned_short(conduit::index_t num_elements,conduit::index_t offset,conduit::index_t stride,conduit::index_t element_bytes,conduit::index_t endianness)377 DataType::c_unsigned_short(conduit::index_t num_elements,
378 conduit::index_t offset,
379 conduit::index_t stride,
380 conduit::index_t element_bytes,
381 conduit::index_t endianness)
382 {
383 return DataType(CONDUIT_NATIVE_UNSIGNED_SHORT_ID,
384 num_elements,offset,stride,element_bytes,endianness);
385 }
386
387 //---------------------------------------------------------------------------//
388 DataType
c_unsigned_int(conduit::index_t num_elements,conduit::index_t offset,conduit::index_t stride,conduit::index_t element_bytes,conduit::index_t endianness)389 DataType::c_unsigned_int(conduit::index_t num_elements,
390 conduit::index_t offset,
391 conduit::index_t stride,
392 conduit::index_t element_bytes,
393 conduit::index_t endianness)
394 {
395 return DataType(CONDUIT_NATIVE_UNSIGNED_INT_ID,
396 num_elements,offset,stride,element_bytes,endianness);
397 }
398
399 //---------------------------------------------------------------------------//
400 DataType
c_unsigned_long(conduit::index_t num_elements,conduit::index_t offset,conduit::index_t stride,conduit::index_t element_bytes,conduit::index_t endianness)401 DataType::c_unsigned_long(conduit::index_t num_elements,
402 conduit::index_t offset,
403 conduit::index_t stride,
404 conduit::index_t element_bytes,
405 conduit::index_t endianness)
406 {
407 return DataType(CONDUIT_NATIVE_UNSIGNED_LONG_ID,
408 num_elements,offset,stride,element_bytes,endianness);
409 }
410
411 #ifdef CONDUIT_HAS_LONG_LONG
412 //---------------------------------------------------------------------------//
413 DataType
c_unsigned_long_long(conduit::index_t num_elements,conduit::index_t offset,conduit::index_t stride,conduit::index_t element_bytes,conduit::index_t endianness)414 DataType::c_unsigned_long_long(conduit::index_t num_elements,
415 conduit::index_t offset,
416 conduit::index_t stride,
417 conduit::index_t element_bytes,
418 conduit::index_t endianness)
419 {
420 return DataType(CONDUIT_NATIVE_UNSIGNED_LONG_LONG_ID,
421 num_elements,offset,stride,element_bytes,endianness);
422 }
423 #endif
424
425 /// floating point arrays
426 //---------------------------------------------------------------------------//
427 DataType
c_float(conduit::index_t num_elements,conduit::index_t offset,conduit::index_t stride,conduit::index_t element_bytes,conduit::index_t endianness)428 DataType::c_float(conduit::index_t num_elements,
429 conduit::index_t offset,
430 conduit::index_t stride,
431 conduit::index_t element_bytes,
432 conduit::index_t endianness)
433 {
434 return DataType(CONDUIT_NATIVE_FLOAT_ID,
435 num_elements,offset,stride,element_bytes,endianness);
436 }
437
438 //---------------------------------------------------------------------------//
439 DataType
c_double(conduit::index_t num_elements,conduit::index_t offset,conduit::index_t stride,conduit::index_t element_bytes,conduit::index_t endianness)440 DataType::c_double(conduit::index_t num_elements,
441 conduit::index_t offset,
442 conduit::index_t stride,
443 conduit::index_t element_bytes,
444 conduit::index_t endianness)
445 {
446 return DataType(CONDUIT_NATIVE_DOUBLE_ID,
447 num_elements,offset,stride,element_bytes,endianness);
448 }
449
450 #ifdef CONDUIT_USE_LONG_DOUBLE
451 //---------------------------------------------------------------------------//
452 DataType
c_long_double(conduit::index_t num_elements,conduit::index_t offset,conduit::index_t stride,conduit::index_t element_bytes,conduit::index_t endianness)453 DataType::c_long_double(conduit::index_t num_elements,
454 conduit::index_t offset,
455 conduit::index_t stride,
456 conduit::index_t element_bytes,
457 conduit::index_t endianness)
458 {
459 return DataType(CONDUIT_NATIVE_LONG_DOUBLE_ID,
460 num_elements,offset,stride,element_bytes,endianness);
461 }
462 #endif
463
464
465 //=============================================================================
466 //-----------------------------------------------------------------------------
467 //
468 //
469 // -- begin conduit::Node public methods --
470 //
471 //
472 //-----------------------------------------------------------------------------
473 //=============================================================================
474
475 //-----------------------------------------------------------------------------
476 // Construction and Destruction
477 //-----------------------------------------------------------------------------
478
479 //---------------------------------------------------------------------------//
DataType()480 DataType::DataType()
481 : m_id(DataType::EMPTY_ID),
482 m_num_ele(0),
483 m_offset(0),
484 m_stride(0),
485 m_ele_bytes(0),
486 m_endianness(Endianness::DEFAULT_ID)
487 {}
488
489 //---------------------------------------------------------------------------//
DataType(const DataType & value)490 DataType::DataType(const DataType& value)
491 : m_id(value.m_id),
492 m_num_ele(value.m_num_ele),
493 m_offset(value.m_offset),
494 m_stride(value.m_stride),
495 m_ele_bytes(value.m_ele_bytes),
496 m_endianness(value.m_endianness)
497 {}
498
499
500 //---------------------------------------------------------------------------//
operator =(const DataType & value)501 DataType& DataType::operator=(const DataType& value)
502 {
503 m_id = value.m_id;
504 m_num_ele = value.m_num_ele;
505 m_offset = value.m_offset;
506 m_stride = value.m_stride;
507 m_ele_bytes = value.m_ele_bytes;
508 m_endianness = value.m_endianness;
509
510 return *this;
511 }
512
513
514 //---------------------------------------------------------------------------//
DataType(conduit::index_t id,conduit::index_t num_elements)515 DataType::DataType(conduit::index_t id, conduit::index_t num_elements)
516 : m_id(id),
517 m_num_ele(num_elements),
518 m_offset(0),
519 m_stride(DataType::default_bytes(id)),
520 m_ele_bytes(DataType::default_bytes(id)),
521 m_endianness(Endianness::DEFAULT_ID)
522 {}
523
524 //---------------------------------------------------------------------------//
DataType(const std::string & dtype_name,conduit::index_t num_elements,conduit::index_t offset,conduit::index_t stride,conduit::index_t element_bytes,conduit::index_t endianness)525 DataType::DataType(const std::string &dtype_name,
526 conduit::index_t num_elements,
527 conduit::index_t offset,
528 conduit::index_t stride,
529 conduit::index_t element_bytes,
530 conduit::index_t endianness)
531 : m_id(name_to_id(dtype_name)),
532 m_num_ele(num_elements),
533 m_offset(offset),
534 m_stride(stride),
535 m_ele_bytes(element_bytes),
536 m_endianness(endianness)
537 {}
538
539 //---------------------------------------------------------------------------//
DataType(conduit::index_t dtype_id,conduit::index_t num_elements,conduit::index_t offset,conduit::index_t stride,conduit::index_t element_bytes,conduit::index_t endianness)540 DataType::DataType(conduit::index_t dtype_id,
541 conduit::index_t num_elements,
542 conduit::index_t offset,
543 conduit::index_t stride,
544 conduit::index_t element_bytes,
545 conduit::index_t endianness)
546
547 : m_id(dtype_id),
548 m_num_ele(num_elements),
549 m_offset(offset),
550 m_stride(stride),
551 m_ele_bytes(element_bytes),
552 m_endianness(endianness)
553 {}
554
555
556 //---------------------------------------------------------------------------//
~DataType()557 DataType::~DataType()
558 {}
559
560 //---------------------------------------------------------------------------//
561 void
reset()562 DataType::reset()
563 {
564 m_id = EMPTY_ID;
565 m_num_ele = 0;
566 m_offset = 0;
567 m_stride = 0;
568 m_ele_bytes = 0;
569 m_endianness = Endianness::DEFAULT_ID;
570
571 }
572
573 //-----------------------------------------------------------------------------
574 // Setters
575 //-----------------------------------------------------------------------------
576
577 //---------------------------------------------------------------------------//
578 void
set(const DataType & dtype)579 DataType::set(const DataType& dtype)
580 {
581 m_id = dtype.m_id;
582 m_num_ele = dtype.m_num_ele;
583 m_offset = dtype.m_offset;
584 m_stride = dtype.m_stride;
585 m_ele_bytes = dtype.m_ele_bytes;
586 m_endianness = dtype.m_endianness;
587 }
588
589
590 //---------------------------------------------------------------------------//
591 void
set(const std::string & dtype_name,conduit::index_t num_elements,conduit::index_t offset,conduit::index_t stride,conduit::index_t element_bytes,conduit::index_t endianness)592 DataType::set(const std::string &dtype_name,
593 conduit::index_t num_elements,
594 conduit::index_t offset,
595 conduit::index_t stride,
596 conduit::index_t element_bytes,
597 conduit::index_t endianness)
598 {
599 m_id = name_to_id(dtype_name);
600 m_num_ele = num_elements;
601 m_offset = offset;
602 m_stride = stride;
603 m_ele_bytes = element_bytes;
604 m_endianness = endianness;
605 }
606
607 //---------------------------------------------------------------------------//
608 void
set(conduit::index_t dtype_id,conduit::index_t num_elements,conduit::index_t offset,conduit::index_t stride,conduit::index_t element_bytes,conduit::index_t endianness)609 DataType::set(conduit::index_t dtype_id,
610 conduit::index_t num_elements,
611 conduit::index_t offset,
612 conduit::index_t stride,
613 conduit::index_t element_bytes,
614 conduit::index_t endianness)
615 {
616 m_id = dtype_id;
617 m_num_ele = num_elements;
618 m_offset = offset;
619 m_stride = stride;
620 m_ele_bytes = element_bytes;
621 m_endianness = endianness;
622 }
623
624 //-----------------------------------------------------------------------------
625 // Getters and info methods.
626 //-----------------------------------------------------------------------------
627
628 //---------------------------------------------------------------------------//
629 conduit::index_t
strided_bytes() const630 DataType::strided_bytes() const
631 {
632 // this is the memory extent excluding the offset
633 return m_stride * (m_num_ele -1) + m_ele_bytes;
634 }
635
636
637 //---------------------------------------------------------------------------//
638 conduit::index_t
bytes_compact() const639 DataType::bytes_compact() const
640 {
641 return default_bytes(m_id) * m_num_ele;
642 }
643
644 //---------------------------------------------------------------------------//
645 conduit::index_t
spanned_bytes() const646 DataType::spanned_bytes() const
647 {
648 return m_offset + m_stride * (m_num_ele -1) + m_ele_bytes;
649 }
650
651 //---------------------------------------------------------------------------//
652 bool
compatible(const DataType & dtype) const653 DataType::compatible(const DataType& dtype) const
654 {
655 return ( (m_id == dtype.m_id ) &&
656 (m_ele_bytes == dtype.m_ele_bytes) &&
657 (m_num_ele >= dtype.m_num_ele) );
658 }
659
660 //---------------------------------------------------------------------------//
661 bool
equals(const DataType & dtype) const662 DataType::equals(const DataType& dtype) const
663 {
664 return ( (m_id == dtype.m_id ) &&
665 (m_num_ele == dtype.m_num_ele) &&
666 (m_offset == dtype.m_offset) &&
667 (m_ele_bytes == dtype.m_ele_bytes) &&
668 (m_endianness == dtype.m_endianness));
669 }
670
671
672 //---------------------------------------------------------------------------//
673 bool
is_compact() const674 DataType::is_compact() const
675 {
676 return ( (m_id != EMPTY_ID) &&
677 (m_id != OBJECT_ID) &&
678 (m_id != LIST_ID) &&
679 (spanned_bytes() == bytes_compact()));
680 }
681
682 //---------------------------------------------------------------------------//
683 bool
is_empty() const684 DataType::is_empty() const
685 {
686 return m_id == EMPTY_ID;
687 }
688
689 //---------------------------------------------------------------------------//
690 bool
is_object() const691 DataType::is_object() const
692 {
693 return m_id == OBJECT_ID;
694 }
695
696 //---------------------------------------------------------------------------//
697 bool
is_list() const698 DataType::is_list() const
699 {
700 return m_id == LIST_ID;
701 }
702
703 //---------------------------------------------------------------------------//
704 bool
is_number() const705 DataType::is_number() const
706 {
707 return ( is_integer() ||
708 is_floating_point());
709 }
710
711 //---------------------------------------------------------------------------//
712 bool
is_floating_point() const713 DataType::is_floating_point() const
714 {
715 return ( (m_id == FLOAT32_ID) ||
716 (m_id == FLOAT64_ID));
717 }
718
719 //---------------------------------------------------------------------------//
720 bool
is_integer() const721 DataType::is_integer() const
722 {
723 return ( is_signed_integer() ||
724 is_unsigned_integer());
725 }
726
727 //---------------------------------------------------------------------------//
728 bool
is_signed_integer() const729 DataType::is_signed_integer() const
730 {
731 return ( (m_id == INT8_ID) ||
732 (m_id == INT16_ID) ||
733 (m_id == INT32_ID) ||
734 (m_id == INT64_ID));
735 }
736
737 //---------------------------------------------------------------------------//
738 bool
is_unsigned_integer() const739 DataType::is_unsigned_integer() const
740 {
741 return ( (m_id == UINT8_ID) ||
742 (m_id == UINT16_ID) ||
743 (m_id == UINT32_ID) ||
744 (m_id == UINT64_ID));
745 }
746
747 //---------------------------------------------------------------------------//
748 bool
is_int8() const749 DataType::is_int8() const
750 {
751 return m_id == INT8_ID;
752 }
753
754 //---------------------------------------------------------------------------//
755 bool
is_int16() const756 DataType::is_int16() const
757 {
758 return m_id == INT16_ID;
759 }
760
761
762 //---------------------------------------------------------------------------//
763 bool
is_int32() const764 DataType::is_int32() const
765 {
766 return m_id == INT32_ID;
767 }
768
769 //---------------------------------------------------------------------------//
770 bool
is_int64() const771 DataType::is_int64() const
772 {
773 return m_id == INT64_ID;
774 }
775
776 //---------------------------------------------------------------------------//
777 bool
is_uint8() const778 DataType::is_uint8() const
779 {
780 return m_id == UINT8_ID;
781 }
782
783 //---------------------------------------------------------------------------//
784 bool
is_uint16() const785 DataType::is_uint16() const
786 {
787 return m_id == UINT16_ID;
788 }
789
790 //---------------------------------------------------------------------------//
791 bool
is_uint32() const792 DataType::is_uint32() const
793 {
794 return m_id == UINT32_ID;
795 }
796
797 //---------------------------------------------------------------------------//
798 bool
is_uint64() const799 DataType::is_uint64() const
800 {
801 return m_id == UINT64_ID;
802 }
803
804 //---------------------------------------------------------------------------//
805 bool
is_float32() const806 DataType::is_float32() const
807 {
808 return m_id == FLOAT32_ID;
809 }
810
811 //---------------------------------------------------------------------------//
812 bool
is_float64() const813 DataType::is_float64() const
814 {
815 return m_id == FLOAT64_ID;
816 }
817
818
819 //---------------------------------------------------------------------------//
820 bool
is_index_t() const821 DataType::is_index_t() const
822 {
823 #ifdef CONDUIT_INDEX_32
824 return m_id == INT32_ID;
825 #else
826 return m_id == INT64_ID;
827 #endif
828 }
829
830 //---------------------------------------------------------------------------//
831 bool
is_char() const832 DataType::is_char() const
833 {
834 return m_id == CONDUIT_NATIVE_CHAR_ID;
835 }
836
837 //---------------------------------------------------------------------------//
838 bool
is_short() const839 DataType::is_short() const
840 {
841 return m_id == CONDUIT_NATIVE_SHORT_ID;
842 }
843
844 //---------------------------------------------------------------------------//
845 bool
is_int() const846 DataType::is_int() const
847 {
848 return m_id == CONDUIT_NATIVE_INT_ID;
849 }
850
851 //---------------------------------------------------------------------------//
852 bool
is_long() const853 DataType::is_long() const
854 {
855 return m_id == CONDUIT_NATIVE_LONG_ID;
856 }
857
858 //---------------------------------------------------------------------------//
859 bool
is_long_long() const860 DataType::is_long_long() const
861 {
862 #ifdef CONDUIT_HAS_LONG_LONG
863 return m_id == CONDUIT_NATIVE_LONG_LONG_ID;
864 #else
865 return false;
866 #endif
867 }
868
869
870 //---------------------------------------------------------------------------//
871 bool
is_signed_char() const872 DataType::is_signed_char() const
873 {
874 return m_id == CONDUIT_NATIVE_SIGNED_CHAR_ID;
875 }
876
877 //---------------------------------------------------------------------------//
878 bool
is_signed_short() const879 DataType::is_signed_short() const
880 {
881 return m_id == CONDUIT_NATIVE_SIGNED_SHORT_ID;
882 }
883
884 //---------------------------------------------------------------------------//
885 bool
is_signed_int() const886 DataType::is_signed_int() const
887 {
888 return m_id == CONDUIT_NATIVE_SIGNED_INT_ID;
889 }
890
891 //---------------------------------------------------------------------------//
892 bool
is_signed_long() const893 DataType::is_signed_long() const
894 {
895 return m_id == CONDUIT_NATIVE_SIGNED_LONG_ID;
896 }
897
898
899 //---------------------------------------------------------------------------//
900 bool
is_signed_long_long() const901 DataType::is_signed_long_long() const
902 {
903 #ifdef CONDUIT_HAS_LONG_LONG
904 return m_id == CONDUIT_NATIVE_SIGNED_LONG_LONG_ID;
905 #else
906 return false;
907 #endif
908 }
909
910
911 //---------------------------------------------------------------------------//
912 bool
is_unsigned_char() const913 DataType::is_unsigned_char() const
914 {
915 return m_id == CONDUIT_NATIVE_UNSIGNED_CHAR_ID;
916 }
917
918 //---------------------------------------------------------------------------//
919 bool
is_unsigned_short() const920 DataType::is_unsigned_short() const
921 {
922 return m_id == CONDUIT_NATIVE_UNSIGNED_SHORT_ID;
923 }
924
925 //---------------------------------------------------------------------------//
926 bool
is_unsigned_int() const927 DataType::is_unsigned_int() const
928 {
929 return m_id == CONDUIT_NATIVE_UNSIGNED_INT_ID;
930 }
931
932 //---------------------------------------------------------------------------//
933 bool
is_unsigned_long() const934 DataType::is_unsigned_long() const
935 {
936 return m_id == CONDUIT_NATIVE_UNSIGNED_LONG_ID;
937 }
938
939
940 //---------------------------------------------------------------------------//
941 bool
is_unsigned_long_long() const942 DataType::is_unsigned_long_long() const
943 {
944 #ifdef CONDUIT_HAS_LONG_LONG
945 return m_id == CONDUIT_NATIVE_UNSIGNED_LONG_LONG_ID;
946 #else
947 return false;
948 #endif
949 }
950
951
952 //---------------------------------------------------------------------------//
953 bool
is_float() const954 DataType::is_float() const
955 {
956 return m_id == CONDUIT_NATIVE_FLOAT_ID;
957 }
958
959 //---------------------------------------------------------------------------//
960 bool
is_double() const961 DataType::is_double() const
962 {
963 return m_id == CONDUIT_NATIVE_DOUBLE_ID;
964 }
965
966
967 //---------------------------------------------------------------------------//
968 bool
is_long_double() const969 DataType::is_long_double() const
970 {
971 #ifdef CONDUIT_USE_LONG_DOUBLE
972 return m_id == CONDUIT_NATIVE_LONG_DOUBLE_ID;
973 #else
974 return false;
975 #endif
976 }
977
978
979 //---------------------------------------------------------------------------//
980 bool
is_string() const981 DataType::is_string() const
982 {
983 // we only support one string type
984 return is_char8_str();
985 }
986
987 //---------------------------------------------------------------------------//
988 bool
is_char8_str() const989 DataType::is_char8_str() const
990 {
991 return m_id == CHAR8_STR_ID;
992 }
993
994 //---------------------------------------------------------------------------//
995 bool
is_little_endian() const996 DataType::is_little_endian() const
997 {
998 return ( (m_endianness == Endianness::LITTLE_ID) ||
999 (m_endianness == Endianness::DEFAULT_ID
1000 && Endianness::machine_is_little_endian())
1001 );
1002 }
1003
1004 //---------------------------------------------------------------------------//
1005 bool
is_big_endian() const1006 DataType::is_big_endian() const
1007 {
1008 return ( (m_endianness == Endianness::BIG_ID) ||
1009 (m_endianness == Endianness::DEFAULT_ID
1010 && Endianness::machine_is_big_endian())
1011 );
1012 }
1013
1014 //---------------------------------------------------------------------------//
1015 bool
endianness_matches_machine() const1016 DataType::endianness_matches_machine() const
1017 {
1018 return ( (m_endianness == Endianness::DEFAULT_ID) ||
1019 (m_endianness == Endianness::BIG_ID &&
1020 Endianness::machine_is_big_endian()) ||
1021 (m_endianness == Endianness::LITTLE_ID &&
1022 Endianness::machine_is_little_endian()) );
1023 }
1024
1025 //---------------------------------------------------------------------------//
1026 conduit::index_t
element_index(conduit::index_t idx) const1027 DataType::element_index(conduit::index_t idx) const
1028 {
1029 /// TODO: This will be an expensive check, placed this in
1030 /// to help us ferret out some places were we are creating default
1031 /// datatypes that have stride == 0.
1032
1033 if(idx > 0 && m_stride == 0)
1034 {
1035 CONDUIT_WARN("Node index calculation with with stride = 0");
1036 }
1037
1038 return m_offset + m_stride * idx;
1039 }
1040
1041 //-----------------------------------------------------------------------------
1042 // TypeID to string and string to TypeId
1043 //-----------------------------------------------------------------------------
1044
1045 //---------------------------------------------------------------------------//
1046 conduit::index_t
name_to_id(const std::string & dtype_name)1047 DataType::name_to_id(const std::string &dtype_name)
1048 {
1049 if(dtype_name == "empty") return EMPTY_ID;
1050 else if(dtype_name == "object") return OBJECT_ID;
1051 else if(dtype_name == "list") return LIST_ID;
1052 else if(dtype_name == "int8") return INT8_ID;
1053 else if(dtype_name == "int16") return INT16_ID;
1054 else if(dtype_name == "int32") return INT32_ID;
1055 else if(dtype_name == "int64") return INT64_ID;
1056 else if(dtype_name == "uint8") return UINT8_ID;
1057 else if(dtype_name == "uint16") return UINT16_ID;
1058 else if(dtype_name == "uint32") return UINT32_ID;
1059 else if(dtype_name == "uint64") return UINT64_ID;
1060 else if(dtype_name == "float32") return FLOAT32_ID;
1061 else if(dtype_name == "float64") return FLOAT64_ID;
1062 else if(dtype_name == "char8_str") return CHAR8_STR_ID;
1063 return EMPTY_ID;
1064 }
1065
1066
1067
1068 //---------------------------------------------------------------------------//
1069 std::string
id_to_name(conduit::index_t dtype_id)1070 DataType::id_to_name(conduit::index_t dtype_id)
1071 {
1072 /// container types
1073 if(dtype_id == EMPTY_ID) return "empty";
1074 else if(dtype_id == OBJECT_ID) return "object";
1075 else if(dtype_id == LIST_ID) return "list";
1076
1077 /// signed integer types
1078 else if(dtype_id == INT8_ID) return "int8";
1079 else if(dtype_id == INT16_ID) return "int16";
1080 else if(dtype_id == INT32_ID) return "int32";
1081 else if(dtype_id == INT64_ID) return "int64";
1082
1083 /// unsigned integer types
1084 else if(dtype_id == UINT8_ID) return "uint8";
1085 else if(dtype_id == UINT16_ID) return "uint16";
1086 else if(dtype_id == UINT32_ID) return "uint32";
1087 else if(dtype_id == UINT64_ID) return "uint64";
1088
1089 /// floating point types
1090 else if(dtype_id == FLOAT32_ID) return "float32";
1091 else if(dtype_id == FLOAT64_ID) return "float64";
1092 /// string types
1093 else if(dtype_id == CHAR8_STR_ID) return "char8_str";
1094 // default to empty
1095 return "empty";
1096 }
1097
1098 //-----------------------------------------------------------------------------
1099 // TypeID to string and string to TypeId
1100 //-----------------------------------------------------------------------------
1101
1102 //---------------------------------------------------------------------------//
1103 conduit::index_t
c_type_name_to_id(const std::string & dtype_name)1104 DataType::c_type_name_to_id(const std::string &dtype_name)
1105 {
1106 if(dtype_name == "char")
1107 return CONDUIT_NATIVE_CHAR_ID;
1108 else if(dtype_name == "short")
1109 return CONDUIT_NATIVE_SHORT_ID;
1110 else if(dtype_name == "int")
1111 return CONDUIT_NATIVE_INT_ID;
1112 else if(dtype_name == "long")
1113 return CONDUIT_NATIVE_LONG_ID;
1114 #ifdef CONDUIT_HAS_LONG_LONG
1115 else if(dtype_name == "long long")
1116 return CONDUIT_NATIVE_LONG_LONG_ID;
1117 #endif
1118 else if(dtype_name == "signed char")
1119 return CONDUIT_NATIVE_SIGNED_CHAR_ID;
1120 else if(dtype_name == "signed short")
1121 return CONDUIT_NATIVE_SIGNED_SHORT_ID;
1122 else if(dtype_name == "signed int")
1123 return CONDUIT_NATIVE_SIGNED_INT_ID;
1124 else if(dtype_name == "signed long")
1125 return CONDUIT_NATIVE_SIGNED_LONG_ID;
1126 #ifdef CONDUIT_HAS_LONG_LONG
1127 else if(dtype_name == "signed long long")
1128 return CONDUIT_NATIVE_SIGNED_LONG_LONG_ID;
1129 #endif
1130 else if(dtype_name == "unsigned char")
1131 return CONDUIT_NATIVE_UNSIGNED_CHAR_ID;
1132 else if(dtype_name == "unsigned short")
1133 return CONDUIT_NATIVE_UNSIGNED_SHORT_ID;
1134 else if(dtype_name == "unsigned int")
1135 return CONDUIT_NATIVE_UNSIGNED_INT_ID;
1136 else if(dtype_name == "unsigned long")
1137 return CONDUIT_NATIVE_UNSIGNED_LONG_ID;
1138 #ifdef CONDUIT_HAS_LONG_LONG
1139 else if(dtype_name == "unsigned long long")
1140 return CONDUIT_NATIVE_UNSIGNED_LONG_LONG_ID;
1141 #endif
1142 else if(dtype_name == "float")
1143 return CONDUIT_NATIVE_FLOAT_ID;
1144 else if(dtype_name == "double")
1145 return CONDUIT_NATIVE_DOUBLE_ID;
1146 #ifdef CONDUIT_USE_LONG_DOUBLE
1147 else if(dtype_name == "long double")
1148 return CONDUIT_NATIVE_LONG_DOUBLE_ID;
1149 #endif
1150 else if(dtype_name == "char8_str")
1151 return CHAR8_STR_ID;
1152 return EMPTY_ID;
1153 }
1154
1155
1156 //-----------------------------------------------------------------------------
1157 // Access to simple reference data types by id or name.
1158 //-----------------------------------------------------------------------------
1159
1160 //---------------------------------------------------------------------------//
1161 DataType
default_dtype(conduit::index_t dtype_id)1162 DataType::default_dtype(conduit::index_t dtype_id)
1163 {
1164 switch (dtype_id)
1165 {
1166 /// container types
1167 case OBJECT_ID: return DataType::object();
1168 case LIST_ID : return DataType::list();
1169
1170 /// signed integer types
1171 case INT8_ID : return DataType::int8();
1172 case INT16_ID : return DataType::int16();
1173 case INT32_ID : return DataType::int32();
1174 case INT64_ID : return DataType::int64();
1175
1176 /// unsigned integer types
1177 case UINT8_ID : return DataType::uint8();
1178 case UINT16_ID : return DataType::uint16();
1179 case UINT32_ID : return DataType::uint32();
1180 case UINT64_ID : return DataType::uint64();
1181
1182 /// floating point types
1183 case FLOAT32_ID : return DataType::float32();
1184 case FLOAT64_ID : return DataType::float64();
1185 /// note: there is no default dtype for char8_str
1186
1187 /// default
1188 default :
1189 {
1190 return DataType::empty();
1191 }
1192 }
1193 }
1194
1195 //---------------------------------------------------------------------------//
1196 DataType
default_dtype(const std::string & name)1197 DataType::default_dtype(const std::string &name)
1198 {
1199 return default_dtype(name_to_id(name));
1200 }
1201
1202 //-----------------------------------------------------------------------------
1203 // Default byte sizes for data types
1204 //-----------------------------------------------------------------------------
1205
1206 //---------------------------------------------------------------------------//
1207 conduit::index_t
default_bytes(conduit::index_t dtype_id)1208 DataType::default_bytes(conduit::index_t dtype_id)
1209 {
1210 switch (dtype_id)
1211 {
1212 /// signed integer types
1213 case INT8_ID : return sizeof(conduit::int8);
1214 case INT16_ID : return sizeof(conduit::int16);
1215 case INT32_ID : return sizeof(conduit::int32);
1216 case INT64_ID : return sizeof(conduit::int64);
1217
1218 /// unsigned integer types
1219 case UINT8_ID : return sizeof(conduit::uint8);
1220 case UINT16_ID : return sizeof(conduit::uint16);
1221 case UINT32_ID : return sizeof(conduit::uint32);
1222 case UINT64_ID : return sizeof(conduit::uint64);
1223
1224 /// floating point types
1225 case FLOAT32_ID : return sizeof(conduit::float32);
1226 case FLOAT64_ID : return sizeof(conduit::float64);
1227 /// string types
1228 case CHAR8_STR_ID : return 1;
1229 /// note: there is no default bytes obj,list, or empty
1230 default :
1231 {
1232 return 0;
1233 }
1234 }
1235 }
1236
1237
1238 //---------------------------------------------------------------------------//
1239 conduit::index_t
default_bytes(const std::string & name)1240 DataType::default_bytes(const std::string &name)
1241 {
1242 return default_bytes(name_to_id(name));
1243 }
1244
1245
1246 //-----------------------------------------------------------------------------
1247 // Transforms
1248 //-----------------------------------------------------------------------------
1249
1250 //---------------------------------------------------------------------------//
1251 std::string
to_string(const std::string & protocol,conduit::index_t indent,conduit::index_t depth,const std::string & pad,const std::string & eoe) const1252 DataType::to_string(const std::string &protocol,
1253 conduit::index_t indent,
1254 conduit::index_t depth,
1255 const std::string &pad,
1256 const std::string &eoe) const
1257 {
1258 std::ostringstream oss;
1259 to_string_stream(oss,
1260 protocol,
1261 indent,
1262 depth,
1263 pad,
1264 eoe);
1265 return oss.str();
1266 }
1267
1268 //---------------------------------------------------------------------------//
1269 void
to_string_stream(std::ostream & os,const std::string & protocol,conduit::index_t indent,conduit::index_t depth,const std::string & pad,const std::string & eoe) const1270 DataType::to_string_stream(std::ostream &os,
1271 const std::string &protocol,
1272 conduit::index_t indent,
1273 conduit::index_t depth,
1274 const std::string &pad,
1275 const std::string &eoe) const
1276 {
1277 if(protocol == "yaml")
1278 {
1279 to_yaml_stream(os,
1280 indent,
1281 depth,
1282 pad,
1283 eoe);
1284 }
1285 else if(protocol == "json")
1286 {
1287 to_json_stream(os,
1288 indent,
1289 depth,
1290 pad,
1291 eoe);
1292 }
1293 else
1294 {
1295 // unsupported
1296 CONDUIT_ERROR("Unknown DataType::to_string protocol:" << protocol
1297 <<"\nSupported protocols:\n"
1298 <<" json, yaml");
1299 }
1300 }
1301
1302 //---------------------------------------------------------------------------//
1303 std::string
to_string_default() const1304 DataType::to_string_default() const
1305 {
1306 return to_string();
1307 }
1308
1309 //---------------------------------------------------------------------------//
1310 std::string
to_json(conduit::index_t indent,conduit::index_t depth,const std::string & pad,const std::string & eoe) const1311 DataType::to_json(conduit::index_t indent,
1312 conduit::index_t depth,
1313 const std::string &pad,
1314 const std::string &eoe) const
1315 {
1316 std::ostringstream oss;
1317 to_json_stream(oss,
1318 indent,
1319 depth,
1320 pad,
1321 eoe);
1322 return oss.str();
1323 }
1324
1325 //---------------------------------------------------------------------------//
1326 void
to_json_stream(std::ostream & os,conduit::index_t indent,conduit::index_t depth,const std::string & pad,const std::string & eoe) const1327 DataType::to_json_stream(std::ostream &os,
1328 conduit::index_t indent,
1329 conduit::index_t depth,
1330 const std::string &pad,
1331 const std::string &eoe) const
1332 {
1333 os << eoe;
1334 utils::indent(os,indent,depth,pad);
1335 os << "{" << eoe;
1336 utils::indent(os,indent,depth+1,pad);
1337 os << "\"dtype\":" << "\"" << id_to_name(m_id) << "\"";
1338
1339 if(is_number() || is_string())
1340 {
1341 os << "," << eoe;
1342 utils::indent(os,indent,depth+1,pad);
1343 os << "\"number_of_elements\": " << m_num_ele;
1344
1345 os << "," << eoe;
1346 utils::indent(os,indent,depth+1,pad);
1347 os << "\"offset\": " << m_offset;
1348
1349 os << "," << eoe;
1350 utils::indent(os,indent,depth+1,pad);
1351 os << "\"stride\": " << m_stride;
1352
1353 os << "," << eoe;
1354 utils::indent(os,indent,depth+1,pad);
1355 os << "\"element_bytes\": " << m_ele_bytes;
1356
1357 std::string endian_str;
1358 if(m_endianness == Endianness::DEFAULT_ID)
1359 {
1360 // find this machine's actual endianness
1361 endian_str = Endianness::id_to_name(Endianness::machine_default());
1362 }
1363 else
1364 {
1365 endian_str = Endianness::id_to_name(m_endianness);
1366 }
1367
1368 os << "," << eoe;
1369 utils::indent(os,indent,depth+1,pad);
1370 os << "\"endianness\": \"" << endian_str << "\"";
1371 }
1372 os << eoe;
1373 utils::indent(os,indent,depth,pad);
1374 os << "}" << eoe;
1375 }
1376
1377 //---------------------------------------------------------------------------//
1378 std::string
to_json_default() const1379 DataType::to_json_default() const
1380 {
1381 std::ostringstream oss;
1382 to_json_stream(oss);
1383 return oss.str();
1384 }
1385
1386 //---------------------------------------------------------------------------//
1387 std::string
to_yaml(conduit::index_t indent,conduit::index_t depth,const std::string & pad,const std::string & eoe) const1388 DataType::to_yaml(conduit::index_t indent,
1389 conduit::index_t depth,
1390 const std::string &pad,
1391 const std::string &eoe) const
1392 {
1393 std::ostringstream oss;
1394 to_yaml_stream(oss,
1395 indent,
1396 depth,
1397 pad,
1398 eoe);
1399 return oss.str();
1400 }
1401
1402 //---------------------------------------------------------------------------//
1403 void
to_yaml_stream(std::ostream & os,conduit::index_t indent,conduit::index_t depth,const std::string & pad,const std::string & eoe) const1404 DataType::to_yaml_stream(std::ostream &os,
1405 conduit::index_t indent,
1406 conduit::index_t depth,
1407 const std::string &pad,
1408 const std::string &eoe) const
1409 {
1410 utils::indent(os,indent,depth,pad);
1411 os << "dtype: " << "\"" << id_to_name(m_id) << "\"" << eoe;
1412
1413 if(is_number() || is_string())
1414 {
1415 utils::indent(os,indent,depth,pad);
1416 os << "number_of_elements: " << m_num_ele << eoe;
1417
1418 utils::indent(os,indent,depth,pad);
1419 os << "offset: " << m_offset << eoe;
1420
1421 utils::indent(os,indent,depth,pad);
1422 os << "stride: " << m_stride << eoe;
1423
1424 utils::indent(os,indent,depth,pad);
1425 os << "element_bytes: " << m_ele_bytes << eoe;
1426
1427 std::string endian_str;
1428 if(m_endianness == Endianness::DEFAULT_ID)
1429 {
1430 // find this machine's actual endianness
1431 endian_str = Endianness::id_to_name(Endianness::machine_default());
1432 }
1433 else
1434 {
1435 endian_str = Endianness::id_to_name(m_endianness);
1436 }
1437
1438 utils::indent(os,indent,depth,pad);
1439 os << "endianness: \"" << endian_str << "\"" << eoe;
1440 }
1441 }
1442
1443 //---------------------------------------------------------------------------//
1444 std::string
to_yaml_default() const1445 DataType::to_yaml_default() const
1446 {
1447 return to_yaml();
1448 }
1449
1450 //---------------------------------------------------------------------------//
1451 void
compact_to(DataType & dtype) const1452 DataType::compact_to(DataType &dtype) const
1453 {
1454 conduit::index_t ele_size = default_bytes(m_id);
1455 dtype.set(m_id,
1456 m_num_ele,
1457 0,
1458 ele_size,
1459 ele_size,
1460 m_endianness);
1461 }
1462
1463 //=============================================================================
1464 //-----------------------------------------------------------------------------
1465 //
1466 //
1467 // -- end conduit::DataType public methods --
1468 //
1469 //
1470 //-----------------------------------------------------------------------------
1471 //=============================================================================
1472
1473 }
1474 //-----------------------------------------------------------------------------
1475 // -- end conduit:: --
1476 //-----------------------------------------------------------------------------
1477