projects / babeltrace.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
lib: rename include dir to babeltrace2
[babeltrace.git] / lib / ctf-writer / fields.c
CommitLineData
3dca2276
PP		 1/*
2 * Copyright 2013, 2014 Jérémie Galarneau <jeremie.galarneau@efficios.com>
3 *
4 * Author: Jérémie Galarneau <jeremie.galarneau@efficios.com>
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
22 * SOFTWARE.
23 */
24
25#define BT_LOG_TAG "CTF-WRITER-FIELDS"
3fadfbc0 26#include <babeltrace2/lib-logging-internal.h>
3dca2276 27
3fadfbc0
MJ		 28#include <babeltrace2/assert-pre-internal.h>
29#include <babeltrace2/align-internal.h>
30#include <babeltrace2/assert-internal.h>
31#include <babeltrace2/compat/fcntl-internal.h>
32#include <babeltrace2/compiler-internal.h>
33#include <babeltrace2/ctf-writer/field-types-internal.h>
34#include <babeltrace2/ctf-writer/fields-internal.h>
35#include <babeltrace2/endian-internal.h>
36#include <babeltrace2/ctf-writer/object-internal.h>
37#include <babeltrace2/ctf-writer/object.h>
38#include <babeltrace2/ctfser-internal.h>
3dca2276
PP		 39#include <float.h>
40#include <inttypes.h>
16ca5ff0 41#include <inttypes.h>
3dca2276
PP		 42#include <stdlib.h>
43
16ca5ff0
PP		 44#define BT_ASSERT_PRE_CTF_FIELD_IS_INT_OR_ENUM(_field, _name) \
45 BT_ASSERT_PRE((_field)->type->id == BT_CTF_FIELD_TYPE_ID_INTEGER || \
46 (_field)->type->id == BT_CTF_FIELD_TYPE_ID_ENUM, \
47 _name " is not an integer or an enumeration field: " \
48 "field-addr=%p", (_field))
49
50BT_HIDDEN
51struct bt_ctf_field_common *bt_ctf_field_common_copy(struct bt_ctf_field_common *field)
52{
53 struct bt_ctf_field_common *copy = NULL;
54
55 BT_ASSERT_PRE_NON_NULL(field, "Field");
56 BT_ASSERT(field_type_common_has_known_id(field->type));
57 BT_ASSERT(field->methods->copy);
58 copy = field->methods->copy(field);
59 if (!copy) {
60 BT_LOGW("Cannot create field: ft-addr=%p", field->type);
61 goto end;
62 }
63
64 bt_ctf_field_common_set(copy, field->payload_set);
65
66end:
67 return copy;
68}
69
70BT_HIDDEN
71int bt_ctf_field_common_structure_initialize(struct bt_ctf_field_common *field,
72 struct bt_ctf_field_type_common *type,
e1e02a22 73 bool is_shared, bt_ctf_object_release_func release_func,
16ca5ff0
PP		 74 struct bt_ctf_field_common_methods *methods,
75 bt_ctf_field_common_create_func field_create_func,
76 GDestroyNotify field_release_func)
77{
78 int ret = 0;
79 struct bt_ctf_field_type_common_structure *structure_type =
80 BT_CTF_FROM_COMMON(type);
81 struct bt_ctf_field_common_structure *structure = BT_CTF_FROM_COMMON(field);
82 size_t i;
83
84 BT_LOGD("Initializing common structure field object: ft-addr=%p", type);
85 bt_ctf_field_common_initialize(field, type, is_shared,
86 release_func, methods);
87 structure->fields = g_ptr_array_new_with_free_func(field_release_func);
88 g_ptr_array_set_size(structure->fields, structure_type->fields->len);
89
90 /* Create all fields contained in the structure field. */
91 for (i = 0; i < structure_type->fields->len; i++) {
92 struct bt_ctf_field_common *field;
93 struct bt_ctf_field_type_common_structure_field *struct_field =
94 BT_CTF_FIELD_TYPE_COMMON_STRUCTURE_FIELD_AT_INDEX(
95 structure_type, i);
96 field = field_create_func(struct_field->type);
97 if (!field) {
98 BT_LOGE("Failed to create structure field's member: name=\"%s\", index=%zu",
99 g_quark_to_string(struct_field->name), i);
100 ret = -1;
101 goto end;
102 }
103
104 g_ptr_array_index(structure->fields, i) = field;
105 }
106
107 BT_LOGD("Initialized common structure field object: addr=%p, ft-addr=%p",
108 field, type);
109
110end:
111 return ret;
112}
113
114BT_HIDDEN
115int bt_ctf_field_common_variant_initialize(struct bt_ctf_field_common *field,
116 struct bt_ctf_field_type_common *type,
e1e02a22 117 bool is_shared, bt_ctf_object_release_func release_func,
16ca5ff0
PP		 118 struct bt_ctf_field_common_methods *methods,
119 bt_ctf_field_common_create_func field_create_func,
120 GDestroyNotify field_release_func)
121{
122 int ret = 0;
123 struct bt_ctf_field_type_common_variant *variant_type =
124 BT_CTF_FROM_COMMON(type);
125 struct bt_ctf_field_common_variant *variant = BT_CTF_FROM_COMMON(field);
126 size_t i;
127
128 BT_LOGD("Initializing common variant field object: ft-addr=%p", type);
129 bt_ctf_field_common_initialize(field, type, is_shared,
130 release_func, methods);
131 ret = bt_ctf_field_type_common_variant_update_choices(type);
132 if (ret) {
133 BT_LOGE("Cannot update common variant field type choices: "
134 "ret=%d", ret);
135 goto end;
136 }
137
138 variant->fields = g_ptr_array_new_with_free_func(field_release_func);
139 g_ptr_array_set_size(variant->fields, variant_type->choices->len);
140
141 /* Create all fields contained in the variant field. */
142 for (i = 0; i < variant_type->choices->len; i++) {
143 struct bt_ctf_field_common *field;
144 struct bt_ctf_field_type_common_variant_choice *var_choice =
145 BT_CTF_FIELD_TYPE_COMMON_VARIANT_CHOICE_AT_INDEX(
146 variant_type, i);
147
148 field = field_create_func(var_choice->type);
149 if (!field) {
150 BT_LOGE("Failed to create variant field's member: name=\"%s\", index=%zu",
151 g_quark_to_string(var_choice->name), i);
152 ret = -1;
153 goto end;
154 }
155
156 g_ptr_array_index(variant->fields, i) = field;
157 }
158
159 BT_LOGD("Initialized common variant field object: addr=%p, ft-addr=%p",
160 field, type);
161
162end:
163 return ret;
164}
165
166BT_HIDDEN
167int bt_ctf_field_common_string_initialize(struct bt_ctf_field_common *field,
168 struct bt_ctf_field_type_common *type,
e1e02a22 169 bool is_shared, bt_ctf_object_release_func release_func,
16ca5ff0
PP		 170 struct bt_ctf_field_common_methods *methods)
171{
172 int ret = 0;
173 struct bt_ctf_field_common_string *string = BT_CTF_FROM_COMMON(field);
174
175 BT_LOGD("Initializing common string field object: ft-addr=%p", type);
176 bt_ctf_field_common_initialize(field, type, is_shared,
177 release_func, methods);
178 string->buf = g_array_sized_new(FALSE, FALSE, sizeof(char), 1);
179 if (!string->buf) {
180 ret = -1;
181 goto end;
182 }
183
184 g_array_index(string->buf, char, 0) = '\0';
185 BT_LOGD("Initialized common string field object: addr=%p, ft-addr=%p",
186 field, type);
187
188end:
189 return ret;
190}
191
192BT_HIDDEN
193int bt_ctf_field_common_array_initialize(struct bt_ctf_field_common *field,
194 struct bt_ctf_field_type_common *type,
e1e02a22 195 bool is_shared, bt_ctf_object_release_func release_func,
16ca5ff0
PP		 196 struct bt_ctf_field_common_methods *methods,
197 bt_ctf_field_common_create_func field_create_func,
198 GDestroyNotify field_destroy_func)
199{
200 struct bt_ctf_field_type_common_array *array_type = BT_CTF_FROM_COMMON(type);
201 struct bt_ctf_field_common_array *array = BT_CTF_FROM_COMMON(field);
202 unsigned int array_length;
203 int ret = 0;
204 uint64_t i;
205
206 BT_LOGD("Initializing common array field object: ft-addr=%p", type);
207 BT_ASSERT(type);
208 bt_ctf_field_common_initialize(field, type, is_shared,
209 release_func, methods);
210 array_length = array_type->length;
211 array->elements = g_ptr_array_sized_new(array_length);
212 if (!array->elements) {
213 ret = -1;
214 goto end;
215 }
216
217 g_ptr_array_set_free_func(array->elements, field_destroy_func);
218 g_ptr_array_set_size(array->elements, array_length);
219
220 for (i = 0; i < array_length; i++) {
221 array->elements->pdata[i] = field_create_func(
222 array_type->element_ft);
223 if (!array->elements->pdata[i]) {
224 ret = -1;
225 goto end;
226 }
227 }
228
229 BT_LOGD("Initialized common array field object: addr=%p, ft-addr=%p",
230 field, type);
231
232end:
233 return ret;
234}
235
236BT_HIDDEN
237int bt_ctf_field_common_sequence_initialize(struct bt_ctf_field_common *field,
238 struct bt_ctf_field_type_common *type,
e1e02a22 239 bool is_shared, bt_ctf_object_release_func release_func,
16ca5ff0
PP		 240 struct bt_ctf_field_common_methods *methods,
241 GDestroyNotify field_destroy_func)
242{
243 struct bt_ctf_field_common_sequence *sequence = BT_CTF_FROM_COMMON(field);
244 int ret = 0;
245
246 BT_LOGD("Initializing common sequence field object: ft-addr=%p", type);
247 BT_ASSERT(type);
248 bt_ctf_field_common_initialize(field, type, is_shared,
249 release_func, methods);
250 sequence->elements = g_ptr_array_new();
251 if (!sequence->elements) {
252 ret = -1;
253 goto end;
254 }
255
256 g_ptr_array_set_free_func(sequence->elements, field_destroy_func);
257 BT_LOGD("Initialized common sequence field object: addr=%p, ft-addr=%p",
258 field, type);
259
260end:
261 return ret;
262}
263
264BT_HIDDEN
265int bt_ctf_field_common_generic_validate(struct bt_ctf_field_common *field)
266{
267 return (field && field->payload_set) ? 0 : -1;
268}
269
270BT_HIDDEN
271int bt_ctf_field_common_structure_validate_recursive(struct bt_ctf_field_common *field)
272{
273 int64_t i;
274 int ret = 0;
275 struct bt_ctf_field_common_structure *structure = BT_CTF_FROM_COMMON(field);
276
277 BT_ASSERT(field);
278
279 for (i = 0; i < structure->fields->len; i++) {
280 ret = bt_ctf_field_common_validate_recursive(
281 (void *) structure->fields->pdata[i]);
282
283 if (ret) {
284 int this_ret;
285 const char *name;
286
287 this_ret = bt_ctf_field_type_common_structure_borrow_field_by_index(
288 field->type, &name, NULL, i);
289 BT_ASSERT(this_ret == 0);
290 BT_ASSERT_PRE_MSG("Invalid structure field's field: "
291 "struct-field-addr=%p, field-name=\"%s\", "
292 "index=%" PRId64 ", field-addr=%p",
293 field, name, i, structure->fields->pdata[i]);
294 goto end;
295 }
296 }
297
298end:
299 return ret;
300}
301
302BT_HIDDEN
303int bt_ctf_field_common_variant_validate_recursive(struct bt_ctf_field_common *field)
304{
305 int ret = 0;
306 struct bt_ctf_field_common_variant *variant = BT_CTF_FROM_COMMON(field);
307
308 BT_ASSERT(field);
309
310 if (!variant->current_field) {
311 ret = -1;
312 goto end;
313 }
314
315 ret = bt_ctf_field_common_validate_recursive(variant->current_field);
316
317end:
318 return ret;
319}
320
321BT_HIDDEN
322int bt_ctf_field_common_array_validate_recursive(struct bt_ctf_field_common *field)
323{
324 int64_t i;
325 int ret = 0;
326 struct bt_ctf_field_common_array *array = BT_CTF_FROM_COMMON(field);
327
328 BT_ASSERT(field);
329
330 for (i = 0; i < array->elements->len; i++) {
331 ret = bt_ctf_field_common_validate_recursive((void *) array->elements->pdata[i]);
332 if (ret) {
333 BT_ASSERT_PRE_MSG("Invalid array field's element field: "
334 "array-field-addr=%p, " PRId64 ", "
335 "elem-field-addr=%p",
336 field, i, array->elements->pdata[i]);
337 goto end;
338 }
339 }
340
341end:
342 return ret;
343}
344
345BT_HIDDEN
346int bt_ctf_field_common_sequence_validate_recursive(struct bt_ctf_field_common *field)
347{
348 size_t i;
349 int ret = 0;
350 struct bt_ctf_field_common_sequence *sequence = BT_CTF_FROM_COMMON(field);
351
352 BT_ASSERT(field);
353
354 for (i = 0; i < sequence->elements->len; i++) {
355 ret = bt_ctf_field_common_validate_recursive(
356 (void *) sequence->elements->pdata[i]);
357 if (ret) {
358 BT_ASSERT_PRE_MSG("Invalid sequence field's element field: "
359 "seq-field-addr=%p, " PRId64 ", "
360 "elem-field-addr=%p",
361 field, i, sequence->elements->pdata[i]);
362 goto end;
363 }
364 }
365end:
366 return ret;
367}
368
369BT_HIDDEN
370void bt_ctf_field_common_generic_reset(struct bt_ctf_field_common *field)
371{
372 BT_ASSERT(field);
373 field->payload_set = false;
374}
375
376BT_HIDDEN
377void bt_ctf_field_common_structure_reset_recursive(struct bt_ctf_field_common *field)
378{
379 int64_t i;
380 struct bt_ctf_field_common_structure *structure = BT_CTF_FROM_COMMON(field);
381
382 BT_ASSERT(field);
383
384 for (i = 0; i < structure->fields->len; i++) {
385 struct bt_ctf_field_common *member = structure->fields->pdata[i];
386
387 if (!member) {
388 /*
389 * Structure members are lazily initialized;
390 * skip if this member has not been allocated
391 * yet.
392 */
393 continue;
394 }
395
396 bt_ctf_field_common_reset_recursive(member);
397 }
398}
399
400BT_HIDDEN
401void bt_ctf_field_common_variant_reset_recursive(struct bt_ctf_field_common *field)
402{
403 struct bt_ctf_field_common_variant *variant = BT_CTF_FROM_COMMON(field);
404
405 BT_ASSERT(field);
406 variant->current_field = NULL;
407}
408
409BT_HIDDEN
410void bt_ctf_field_common_array_reset_recursive(struct bt_ctf_field_common *field)
411{
412 size_t i;
413 struct bt_ctf_field_common_array *array = BT_CTF_FROM_COMMON(field);
414
415 BT_ASSERT(field);
416
417 for (i = 0; i < array->elements->len; i++) {
418 struct bt_ctf_field_common *member = array->elements->pdata[i];
419
420 if (!member) {
421 /*
422 * Array elements are lazily initialized; skip
423 * if this member has not been allocated yet.
424 */
425 continue;
426 }
427
428 bt_ctf_field_common_reset_recursive(member);
429 }
430}
431
432BT_HIDDEN
433void bt_ctf_field_common_sequence_reset_recursive(struct bt_ctf_field_common *field)
434{
435 struct bt_ctf_field_common_sequence *sequence = BT_CTF_FROM_COMMON(field);
436 uint64_t i;
437
438 BT_ASSERT(field);
439
440 for (i = 0; i < sequence->elements->len; i++) {
441 if (sequence->elements->pdata[i]) {
442 bt_ctf_field_common_reset_recursive(
443 sequence->elements->pdata[i]);
444 }
445 }
446
447 sequence->length = 0;
448}
449
450BT_HIDDEN
451void bt_ctf_field_common_generic_set_is_frozen(struct bt_ctf_field_common *field,
452 bool is_frozen)
453{
454 field->frozen = is_frozen;
455}
456
457BT_HIDDEN
458void bt_ctf_field_common_structure_set_is_frozen_recursive(
459 struct bt_ctf_field_common *field, bool is_frozen)
460{
461 uint64_t i;
462 struct bt_ctf_field_common_structure *structure_field =
463 BT_CTF_FROM_COMMON(field);
464
465 BT_LOGD("Freezing structure field object: addr=%p", field);
466
467 for (i = 0; i < structure_field->fields->len; i++) {
468 struct bt_ctf_field_common *struct_field =
469 g_ptr_array_index(structure_field->fields, i);
470
471 BT_LOGD("Freezing structure field's field: field-addr=%p, index=%" PRId64,
472 struct_field, i);
473 bt_ctf_field_common_set_is_frozen_recursive(struct_field,
474 is_frozen);
475 }
476
477 bt_ctf_field_common_generic_set_is_frozen(field, is_frozen);
478}
479
480BT_HIDDEN
481void bt_ctf_field_common_variant_set_is_frozen_recursive(
482 struct bt_ctf_field_common *field, bool is_frozen)
483{
484 uint64_t i;
485 struct bt_ctf_field_common_variant *variant_field = BT_CTF_FROM_COMMON(field);
486
487 BT_LOGD("Freezing variant field object: addr=%p", field);
488
489 for (i = 0; i < variant_field->fields->len; i++) {
490 struct bt_ctf_field_common *var_field =
491 g_ptr_array_index(variant_field->fields, i);
492
493 BT_LOGD("Freezing variant field's field: field-addr=%p, index=%" PRId64,
494 var_field, i);
495 bt_ctf_field_common_set_is_frozen_recursive(var_field, is_frozen);
496 }
497
498 bt_ctf_field_common_generic_set_is_frozen(field, is_frozen);
499}
500
501BT_HIDDEN
502void bt_ctf_field_common_array_set_is_frozen_recursive(
503 struct bt_ctf_field_common *field, bool is_frozen)
504{
505 int64_t i;
506 struct bt_ctf_field_common_array *array_field = BT_CTF_FROM_COMMON(field);
507
508 BT_LOGD("Freezing array field object: addr=%p", field);
509
510 for (i = 0; i < array_field->elements->len; i++) {
511 struct bt_ctf_field_common *elem_field =
512 g_ptr_array_index(array_field->elements, i);
513
514 BT_LOGD("Freezing array field object's element field: "
515 "element-field-addr=%p, index=%" PRId64,
516 elem_field, i);
517 bt_ctf_field_common_set_is_frozen_recursive(elem_field, is_frozen);
518 }
519
520 bt_ctf_field_common_generic_set_is_frozen(field, is_frozen);
521}
522
523BT_HIDDEN
524void bt_ctf_field_common_sequence_set_is_frozen_recursive(
525 struct bt_ctf_field_common *field, bool is_frozen)
526{
527 int64_t i;
528 struct bt_ctf_field_common_sequence *sequence_field =
529 BT_CTF_FROM_COMMON(field);
530
531 BT_LOGD("Freezing sequence field object: addr=%p", field);
532
533 for (i = 0; i < sequence_field->length; i++) {
534 struct bt_ctf_field_common *elem_field =
535 g_ptr_array_index(sequence_field->elements, i);
536
537 BT_LOGD("Freezing sequence field object's element field: "
538 "element-field-addr=%p, index=%" PRId64,
539 elem_field, i);
540 bt_ctf_field_common_set_is_frozen_recursive(elem_field, is_frozen);
541 }
542
543 bt_ctf_field_common_generic_set_is_frozen(field, is_frozen);
544}
545
546BT_HIDDEN
547void _bt_ctf_field_common_set_is_frozen_recursive(struct bt_ctf_field_common *field,
548 bool is_frozen)
549{
550 if (!field) {
551 goto end;
552 }
553
554 BT_LOGD("Setting field object's frozen state: addr=%p, is-frozen=%d",
555 field, is_frozen);
556 BT_ASSERT(field_type_common_has_known_id(field->type));
557 BT_ASSERT(field->methods->set_is_frozen);
558 field->methods->set_is_frozen(field, is_frozen);
559
560end:
561 return;
562}
563
564BT_HIDDEN
565bt_bool bt_ctf_field_common_generic_is_set(struct bt_ctf_field_common *field)
566{
567 return field && field->payload_set;
568}
569
570BT_HIDDEN
571bt_bool bt_ctf_field_common_structure_is_set_recursive(
572 struct bt_ctf_field_common *field)
573{
574 bt_bool is_set = BT_FALSE;
575 size_t i;
576 struct bt_ctf_field_common_structure *structure = BT_CTF_FROM_COMMON(field);
577
578 BT_ASSERT(field);
579
580 for (i = 0; i < structure->fields->len; i++) {
581 is_set = bt_ctf_field_common_is_set_recursive(
582 structure->fields->pdata[i]);
583 if (!is_set) {
584 goto end;
585 }
586 }
587
588end:
589 return is_set;
590}
591
592BT_HIDDEN
593bt_bool bt_ctf_field_common_variant_is_set_recursive(struct bt_ctf_field_common *field)
594{
595 struct bt_ctf_field_common_variant *variant = BT_CTF_FROM_COMMON(field);
596 bt_bool is_set = BT_FALSE;
597
598 BT_ASSERT(field);
599
600 if (variant->current_field) {
601 is_set = bt_ctf_field_common_is_set_recursive(
602 variant->current_field);
603 }
604
605 return is_set;
606}
607
608BT_HIDDEN
609bt_bool bt_ctf_field_common_array_is_set_recursive(struct bt_ctf_field_common *field)
610{
611 size_t i;
612 bt_bool is_set = BT_FALSE;
613 struct bt_ctf_field_common_array *array = BT_CTF_FROM_COMMON(field);
614
615 BT_ASSERT(field);
616
617 for (i = 0; i < array->elements->len; i++) {
618 is_set = bt_ctf_field_common_is_set_recursive(array->elements->pdata[i]);
619 if (!is_set) {
620 goto end;
621 }
622 }
623
624end:
625 return is_set;
626}
627
628BT_HIDDEN
629bt_bool bt_ctf_field_common_sequence_is_set_recursive(struct bt_ctf_field_common *field)
630{
631 size_t i;
632 bt_bool is_set = BT_FALSE;
633 struct bt_ctf_field_common_sequence *sequence = BT_CTF_FROM_COMMON(field);
634
635 BT_ASSERT(field);
636
637 if (!sequence->elements) {
638 goto end;
639 }
640
641 for (i = 0; i < sequence->elements->len; i++) {
642 is_set = bt_ctf_field_common_is_set_recursive(
643 sequence->elements->pdata[i]);
644 if (!is_set) {
645 goto end;
646 }
647 }
648
649end:
650 return is_set;
651}
652
653static struct bt_ctf_field_common_methods bt_ctf_field_integer_methods = {
654 .set_is_frozen = bt_ctf_field_common_generic_set_is_frozen,
655 .validate = bt_ctf_field_common_generic_validate,
3dca2276 656 .copy = NULL,
16ca5ff0
PP		 657 .is_set = bt_ctf_field_common_generic_is_set,
658 .reset = bt_ctf_field_common_generic_reset,
3dca2276
PP		 659};
660
16ca5ff0
PP		 661static struct bt_ctf_field_common_methods bt_ctf_field_floating_point_methods = {
662 .set_is_frozen = bt_ctf_field_common_generic_set_is_frozen,
663 .validate = bt_ctf_field_common_generic_validate,
3dca2276 664 .copy = NULL,
16ca5ff0
PP		 665 .is_set = bt_ctf_field_common_generic_is_set,
666 .reset = bt_ctf_field_common_generic_reset,
3dca2276
PP		 667};
668
312c056a
PP		 669static
670void bt_ctf_field_enumeration_set_is_frozen_recursive(
16ca5ff0 671 struct bt_ctf_field_common *field, bool is_frozen);
312c056a
PP		 672
673static
16ca5ff0 674int bt_ctf_field_enumeration_validate_recursive(struct bt_ctf_field_common *field);
312c056a
PP		 675
676static
677bt_bool bt_ctf_field_enumeration_is_set_recursive(
16ca5ff0 678 struct bt_ctf_field_common *field);
312c056a
PP		 679
680static
16ca5ff0 681void bt_ctf_field_enumeration_reset_recursive(struct bt_ctf_field_common *field);
312c056a 682
16ca5ff0 683static struct bt_ctf_field_common_methods bt_ctf_field_enumeration_methods = {
312c056a
PP		 684 .set_is_frozen = bt_ctf_field_enumeration_set_is_frozen_recursive,
685 .validate = bt_ctf_field_enumeration_validate_recursive,
3dca2276 686 .copy = NULL,
312c056a
PP		 687 .is_set = bt_ctf_field_enumeration_is_set_recursive,
688 .reset = bt_ctf_field_enumeration_reset_recursive,
3dca2276
PP		 689};
690
16ca5ff0
PP		 691static struct bt_ctf_field_common_methods bt_ctf_field_string_methods = {
692 .set_is_frozen = bt_ctf_field_common_generic_set_is_frozen,
693 .validate = bt_ctf_field_common_generic_validate,
3dca2276 694 .copy = NULL,
16ca5ff0
PP		 695 .is_set = bt_ctf_field_common_generic_is_set,
696 .reset = bt_ctf_field_common_generic_reset,
3dca2276
PP		 697};
698
16ca5ff0
PP		 699static struct bt_ctf_field_common_methods bt_ctf_field_structure_methods = {
700 .set_is_frozen = bt_ctf_field_common_structure_set_is_frozen_recursive,
701 .validate = bt_ctf_field_common_structure_validate_recursive,
3dca2276 702 .copy = NULL,
16ca5ff0
PP		 703 .is_set = bt_ctf_field_common_structure_is_set_recursive,
704 .reset = bt_ctf_field_common_structure_reset_recursive,
3dca2276
PP		 705};
706
16ca5ff0
PP		 707static struct bt_ctf_field_common_methods bt_ctf_field_sequence_methods = {
708 .set_is_frozen = bt_ctf_field_common_sequence_set_is_frozen_recursive,
709 .validate = bt_ctf_field_common_sequence_validate_recursive,
3dca2276 710 .copy = NULL,
16ca5ff0
PP		 711 .is_set = bt_ctf_field_common_sequence_is_set_recursive,
712 .reset = bt_ctf_field_common_sequence_reset_recursive,
3dca2276
PP		 713};
714
16ca5ff0
PP		 715static struct bt_ctf_field_common_methods bt_ctf_field_array_methods = {
716 .set_is_frozen = bt_ctf_field_common_array_set_is_frozen_recursive,
717 .validate = bt_ctf_field_common_array_validate_recursive,
3dca2276 718 .copy = NULL,
16ca5ff0
PP		 719 .is_set = bt_ctf_field_common_array_is_set_recursive,
720 .reset = bt_ctf_field_common_array_reset_recursive,
3dca2276
PP		 721};
722
312c056a 723static
16ca5ff0 724void bt_ctf_field_variant_set_is_frozen_recursive(struct bt_ctf_field_common *field,
312c056a
PP		 725 bool is_frozen);
726
727static
16ca5ff0 728int bt_ctf_field_variant_validate_recursive(struct bt_ctf_field_common *field);
312c056a
PP		 729
730static
16ca5ff0 731bt_bool bt_ctf_field_variant_is_set_recursive(struct bt_ctf_field_common *field);
312c056a
PP		 732
733static
16ca5ff0 734void bt_ctf_field_variant_reset_recursive(struct bt_ctf_field_common *field);
312c056a 735
16ca5ff0 736static struct bt_ctf_field_common_methods bt_ctf_field_variant_methods = {
312c056a
PP		 737 .set_is_frozen = bt_ctf_field_variant_set_is_frozen_recursive,
738 .validate = bt_ctf_field_variant_validate_recursive,
3dca2276 739 .copy = NULL,
312c056a
PP		 740 .is_set = bt_ctf_field_variant_is_set_recursive,
741 .reset = bt_ctf_field_variant_reset_recursive,
3dca2276
PP		 742};
743
744static
745struct bt_ctf_field *bt_ctf_field_integer_create(struct bt_ctf_field_type *);
746
747static
748struct bt_ctf_field *bt_ctf_field_enumeration_create(struct bt_ctf_field_type *);
749
750static
751struct bt_ctf_field *bt_ctf_field_floating_point_create(struct bt_ctf_field_type *);
752
753static
754struct bt_ctf_field *bt_ctf_field_structure_create(struct bt_ctf_field_type *);
755
756static
757struct bt_ctf_field *bt_ctf_field_variant_create(struct bt_ctf_field_type *);
758
759static
760struct bt_ctf_field *bt_ctf_field_array_create(struct bt_ctf_field_type *);
761
762static
763struct bt_ctf_field *bt_ctf_field_sequence_create(struct bt_ctf_field_type *);
764
765static
766struct bt_ctf_field *bt_ctf_field_string_create(struct bt_ctf_field_type *);
767
768static
769struct bt_ctf_field *(* const field_create_funcs[])(struct bt_ctf_field_type *) = {
16ca5ff0
PP		 770 [BT_CTF_FIELD_TYPE_ID_INTEGER] = bt_ctf_field_integer_create,
771 [BT_CTF_FIELD_TYPE_ID_ENUM] = bt_ctf_field_enumeration_create,
772 [BT_CTF_FIELD_TYPE_ID_FLOAT] = bt_ctf_field_floating_point_create,
773 [BT_CTF_FIELD_TYPE_ID_STRUCT] = bt_ctf_field_structure_create,
774 [BT_CTF_FIELD_TYPE_ID_VARIANT] = bt_ctf_field_variant_create,
775 [BT_CTF_FIELD_TYPE_ID_ARRAY] = bt_ctf_field_array_create,
776 [BT_CTF_FIELD_TYPE_ID_SEQUENCE] = bt_ctf_field_sequence_create,
777 [BT_CTF_FIELD_TYPE_ID_STRING] = bt_ctf_field_string_create,
3dca2276
PP		 778};
779
780typedef int (*bt_ctf_field_serialize_recursive_func)(
013f35c6 781 struct bt_ctf_field_common *, struct bt_ctfser *,
3dca2276
PP		 782 enum bt_ctf_byte_order);
783
312c056a
PP		 784static
785void bt_ctf_field_integer_destroy(struct bt_ctf_field *field)
786{
787 BT_LOGD("Destroying CTF writer integer field object: addr=%p", field);
16ca5ff0 788 bt_ctf_field_common_integer_finalize((void *) field);
312c056a
PP		 789 g_free(field);
790}
791
792static
793void bt_ctf_field_floating_point_destroy(struct bt_ctf_field *field)
794{
795 BT_LOGD("Destroying CTF writer floating point field object: addr=%p",
796 field);
16ca5ff0 797 bt_ctf_field_common_floating_point_finalize((void *) field);
312c056a
PP		 798 g_free(field);
799}
800
801static
802void bt_ctf_field_enumeration_destroy_recursive(struct bt_ctf_field *field)
803{
16ca5ff0 804 struct bt_ctf_field_enumeration *enumeration = BT_CTF_FROM_COMMON(field);
312c056a
PP		 805
806 BT_LOGD("Destroying CTF writer enumeration field object: addr=%p",
807 field);
808 BT_LOGD_STR("Putting container field.");
e1e02a22 809 bt_ctf_object_put_ref(enumeration->container);
16ca5ff0 810 bt_ctf_field_common_finalize((void *) field);
312c056a
PP		 811 g_free(field);
812}
813
814static
815void bt_ctf_field_structure_destroy_recursive(struct bt_ctf_field *field)
816{
817 BT_LOGD("Destroying CTF writer structure field object: addr=%p", field);
16ca5ff0 818 bt_ctf_field_common_structure_finalize_recursive((void *) field);
312c056a
PP		 819 g_free(field);
820}
821
822static
823void bt_ctf_field_variant_destroy_recursive(struct bt_ctf_field *field)
824{
16ca5ff0 825 struct bt_ctf_field_variant *variant = BT_CTF_FROM_COMMON(field);
312c056a
PP		 826
827 BT_LOGD("Destroying CTF writer variant field object: addr=%p", field);
828 BT_LOGD_STR("Putting tag field.");
e1e02a22 829 bt_ctf_object_put_ref(variant->tag);
16ca5ff0 830 bt_ctf_field_common_variant_finalize_recursive((void *) field);
312c056a
PP		 831 g_free(field);
832}
833
834static
835void bt_ctf_field_array_destroy_recursive(struct bt_ctf_field *field)
836{
837 BT_LOGD("Destroying CTF writer array field object: addr=%p", field);
16ca5ff0 838 bt_ctf_field_common_array_finalize_recursive((void *) field);
312c056a
PP		 839 g_free(field);
840}
841
842static
843void bt_ctf_field_sequence_destroy_recursive(struct bt_ctf_field *field)
844{
845 BT_LOGD("Destroying CTF writer sequence field object: addr=%p", field);
16ca5ff0 846 bt_ctf_field_common_sequence_finalize_recursive((void *) field);
312c056a
PP		 847 g_free(field);
848}
849
850static
851void bt_ctf_field_string_destroy(struct bt_ctf_field *field)
852{
853 BT_LOGD("Destroying CTF writer string field object: addr=%p", field);
16ca5ff0 854 bt_ctf_field_common_string_finalize((void *) field);
312c056a
PP		 855 g_free(field);
856}
857
3dca2276
PP		 858BT_HIDDEN
859int bt_ctf_field_serialize_recursive(struct bt_ctf_field *field,
013f35c6 860 struct bt_ctfser *ctfser,
3dca2276
PP		 861 enum bt_ctf_byte_order native_byte_order)
862{
16ca5ff0 863 struct bt_ctf_field_common *field_common = (void *) field;
3dca2276
PP		 864 bt_ctf_field_serialize_recursive_func serialize_func;
865
013f35c6 866 BT_ASSERT(ctfser);
3dca2276
PP		 867 BT_ASSERT_PRE_NON_NULL(field, "Field");
868 BT_ASSERT(field_common->spec.writer.serialize_func);
869 serialize_func = field_common->spec.writer.serialize_func;
013f35c6 870 return serialize_func(field_common, ctfser,
3dca2276
PP		 871 native_byte_order);
872}
873
874static
013f35c6
PP		 875int bt_ctf_field_integer_serialize(struct bt_ctf_field_common *field,
876 struct bt_ctfser *ctfser,
877 enum bt_ctf_byte_order native_byte_order)
3dca2276
PP		 878{
879 int ret;
013f35c6
PP		 880 struct bt_ctf_field_type_common_integer *int_type =
881 BT_CTF_FROM_COMMON(field->type);
882 struct bt_ctf_field_common_integer *int_field =
883 BT_CTF_FROM_COMMON(field);
884 enum bt_ctf_byte_order byte_order;
3dca2276 885
013f35c6
PP		 886 BT_ASSERT_PRE_CTF_FIELD_COMMON_IS_SET(field, "Integer field");
887 BT_LOGV("Serializing CTF writer integer field: addr=%p, native-bo=%s",
888 field,
889 bt_ctf_byte_order_string(native_byte_order));
890 byte_order = int_type->user_byte_order;
891 if (byte_order == BT_CTF_BYTE_ORDER_NATIVE) {
892 byte_order = native_byte_order;
3dca2276
PP		 893 }
894
d6981059
PP		 895 if (int_type->is_signed) {
896 ret = bt_ctfser_write_signed_int(ctfser,
897 int_field->payload.signd, int_type->common.alignment,
898 int_type->size,
899 byte_order == BT_CTF_BYTE_ORDER_LITTLE_ENDIAN ?
900 LITTLE_ENDIAN : BIG_ENDIAN);
901 } else {
902 ret = bt_ctfser_write_unsigned_int(ctfser,
903 int_field->payload.unsignd, int_type->common.alignment,
904 int_type->size,
905 byte_order == BT_CTF_BYTE_ORDER_LITTLE_ENDIAN ?
906 LITTLE_ENDIAN : BIG_ENDIAN);
907 }
908
013f35c6
PP		 909 if (unlikely(ret)) {
910 BT_LOGE("Cannot serialize integer field: ret=%d", ret);
3dca2276
PP		 911 goto end;
912 }
913
3dca2276
PP		 914end:
915 return ret;
916}
917
918static
013f35c6
PP		 919int bt_ctf_field_enumeration_serialize_recursive(
920 struct bt_ctf_field_common *field, struct bt_ctfser *ctfser,
3dca2276
PP		 921 enum bt_ctf_byte_order native_byte_order)
922{
312c056a 923 struct bt_ctf_field_enumeration *enumeration = (void *) field;
3dca2276 924
013f35c6
PP		 925 BT_LOGV("Serializing enumeration field: addr=%p, native-bo=%s",
926 field, bt_ctf_byte_order_string(native_byte_order));
3dca2276 927 BT_LOGV_STR("Serializing enumeration field's payload field.");
312c056a 928 return bt_ctf_field_serialize_recursive(
013f35c6 929 (void *) enumeration->container, ctfser, native_byte_order);
3dca2276
PP		 930}
931
932static
16ca5ff0 933int bt_ctf_field_floating_point_serialize(struct bt_ctf_field_common *field,
013f35c6 934 struct bt_ctfser *ctfser,
3dca2276
PP		 935 enum bt_ctf_byte_order native_byte_order)
936{
013f35c6
PP		 937 int ret = -1;
938 struct bt_ctf_field_type_common_floating_point *flt_type =
939 BT_CTF_FROM_COMMON(field->type);
940 struct bt_ctf_field_common_floating_point *flt_field = BT_CTF_FROM_COMMON(field);
941 enum bt_ctf_byte_order byte_order;
3dca2276 942
16ca5ff0 943 BT_ASSERT_PRE_CTF_FIELD_COMMON_IS_SET(field, "Floating point number field");
013f35c6
PP		 944 BT_LOGV("Serializing floating point number field: "
945 "addr=%p, native-bo=%s", field,
946 bt_ctf_byte_order_string(native_byte_order));
3dca2276 947
013f35c6
PP		 948 byte_order = flt_type->user_byte_order;
949 if (byte_order == BT_CTF_BYTE_ORDER_NATIVE) {
950 byte_order = native_byte_order;
951 }
952
953 if (flt_type->mant_dig == FLT_MANT_DIG) {
954 ret = bt_ctfser_write_float32(ctfser, flt_field->payload,
955 flt_type->common.alignment,
956 byte_order == BT_CTF_BYTE_ORDER_LITTLE_ENDIAN ?
957 LITTLE_ENDIAN : BIG_ENDIAN);
958 } else if (flt_type->mant_dig == DBL_MANT_DIG) {
959 ret = bt_ctfser_write_float64(ctfser, flt_field->payload,
960 flt_type->common.alignment,
961 byte_order == BT_CTF_BYTE_ORDER_LITTLE_ENDIAN ?
962 LITTLE_ENDIAN : BIG_ENDIAN);
963 } else {
964 abort();
965 }
966
967 if (unlikely(ret)) {
968 BT_LOGE("Cannot serialize floating point number field: "
969 "ret=%d", ret);
970 goto end;
3dca2276
PP		 971 }
972
973end:
974 return ret;
975}
976
977static
16ca5ff0 978int bt_ctf_field_structure_serialize_recursive(struct bt_ctf_field_common *field,
013f35c6 979 struct bt_ctfser *ctfser,
3dca2276
PP		 980 enum bt_ctf_byte_order native_byte_order)
981{
982 int64_t i;
013f35c6 983 int ret;
16ca5ff0 984 struct bt_ctf_field_common_structure *structure = BT_CTF_FROM_COMMON(field);
3dca2276 985
013f35c6
PP		 986 BT_LOGV("Serializing structure field: addr=%p, native-bo=%s",
987 field, bt_ctf_byte_order_string(native_byte_order));
988 ret = bt_ctfser_align_offset_in_current_packet(ctfser,
989 field->type->alignment);
990 if (unlikely(ret)) {
991 BT_LOGE("Cannot align offset before serializing structure field: "
992 "ret=%d", ret);
3dca2276
PP		 993 goto end;
994 }
995
996 for (i = 0; i < structure->fields->len; i++) {
16ca5ff0 997 struct bt_ctf_field_common *member = g_ptr_array_index(
3dca2276
PP		 998 structure->fields, i);
999 const char *field_name = NULL;
1000
013f35c6
PP		 1001 BT_LOGV("Serializing structure field's field: ser-offset=%" PRIu64 ", "
1002 "field-addr=%p, index=%" PRIu64,
1003 bt_ctfser_get_offset_in_current_packet_bits(ctfser),
1004 member, i);
3dca2276 1005
013f35c6 1006 if (unlikely(!member)) {
16ca5ff0 1007 ret = bt_ctf_field_type_common_structure_borrow_field_by_index(
3dca2276
PP		 1008 field->type, &field_name, NULL, i);
1009 BT_ASSERT(ret == 0);
1010 BT_LOGW("Cannot serialize structure field's field: field is not set: "
1011 "struct-field-addr=%p, "
1012 "field-name=\"%s\", index=%" PRId64,
1013 field, field_name, i);
1014 ret = -1;
1015 goto end;
1016 }
1017
013f35c6 1018 ret = bt_ctf_field_serialize_recursive((void *) member, ctfser,
3dca2276 1019 native_byte_order);
013f35c6 1020 if (unlikely(ret)) {
16ca5ff0 1021 ret = bt_ctf_field_type_common_structure_borrow_field_by_index(
3dca2276
PP		 1022 field->type, &field_name, NULL, i);
1023 BT_ASSERT(ret == 0);
1024 BT_LOGW("Cannot serialize structure field's field: "
1025 "struct-field-addr=%p, field-addr=%p, "
1026 "field-name=\"%s\", index=%" PRId64,
1027 field->type, member, field_name, i);
1028 break;
1029 }
1030 }
1031
1032end:
1033 return ret;
1034}
1035
1036static
16ca5ff0 1037int bt_ctf_field_variant_serialize_recursive(struct bt_ctf_field_common *field,
013f35c6 1038 struct bt_ctfser *ctfser,
3dca2276
PP		 1039 enum bt_ctf_byte_order native_byte_order)
1040{
16ca5ff0 1041 struct bt_ctf_field_common_variant *variant = BT_CTF_FROM_COMMON(field);
3dca2276 1042
013f35c6
PP		 1043 BT_LOGV("Serializing variant field: addr=%p, native-bo=%s",
1044 field, bt_ctf_byte_order_string(native_byte_order));
3dca2276
PP		 1045 BT_LOGV_STR("Serializing variant field's payload field.");
1046 return bt_ctf_field_serialize_recursive(
013f35c6 1047 (void *) variant->current_field, ctfser, native_byte_order);
3dca2276
PP		 1048}
1049
1050static
16ca5ff0 1051int bt_ctf_field_array_serialize_recursive(struct bt_ctf_field_common *field,
013f35c6 1052 struct bt_ctfser *ctfser,
3dca2276
PP		 1053 enum bt_ctf_byte_order native_byte_order)
1054{
1055 int64_t i;
1056 int ret = 0;
16ca5ff0 1057 struct bt_ctf_field_common_array *array = BT_CTF_FROM_COMMON(field);
3dca2276 1058
013f35c6
PP		 1059 BT_LOGV("Serializing array field: addr=%p, native-bo=%s",
1060 field, bt_ctf_byte_order_string(native_byte_order));
3dca2276
PP		 1061
1062 for (i = 0; i < array->elements->len; i++) {
16ca5ff0 1063 struct bt_ctf_field_common *elem_field =
3dca2276
PP		 1064 g_ptr_array_index(array->elements, i);
1065
1066 BT_LOGV("Serializing array field's element field: "
013f35c6
PP		 1067 "ser-offset=%" PRIu64 ", field-addr=%p, index=%" PRId64,
1068 bt_ctfser_get_offset_in_current_packet_bits(ctfser),
1069 elem_field, i);
3dca2276 1070 ret = bt_ctf_field_serialize_recursive(
013f35c6
PP		 1071 (void *) elem_field, ctfser, native_byte_order);
1072 if (unlikely(ret)) {
3dca2276
PP		 1073 BT_LOGW("Cannot serialize array field's element field: "
1074 "array-field-addr=%p, field-addr=%p, "
1075 "index=%" PRId64, field, elem_field, i);
1076 goto end;
1077 }
1078 }
1079
1080end:
1081 return ret;
1082}
1083
1084static
16ca5ff0 1085int bt_ctf_field_sequence_serialize_recursive(struct bt_ctf_field_common *field,
013f35c6 1086 struct bt_ctfser *ctfser,
3dca2276
PP		 1087 enum bt_ctf_byte_order native_byte_order)
1088{
1089 int64_t i;
1090 int ret = 0;
16ca5ff0 1091 struct bt_ctf_field_common_sequence *sequence = BT_CTF_FROM_COMMON(field);
3dca2276 1092
013f35c6
PP		 1093 BT_LOGV("Serializing sequence field: addr=%p, native-bo=%s",
1094 field, bt_ctf_byte_order_string(native_byte_order));
3dca2276
PP		 1095
1096 for (i = 0; i < sequence->elements->len; i++) {
16ca5ff0 1097 struct bt_ctf_field_common *elem_field =
3dca2276
PP		 1098 g_ptr_array_index(sequence->elements, i);
1099
1100 BT_LOGV("Serializing sequence field's element field: "
013f35c6
PP		 1101 "ser-offset=%" PRIu64 ", field-addr=%p, index=%" PRId64,
1102 bt_ctfser_get_offset_in_current_packet_bits(ctfser),
1103 elem_field, i);
3dca2276 1104 ret = bt_ctf_field_serialize_recursive(
013f35c6
PP		 1105 (void *) elem_field, ctfser, native_byte_order);
1106 if (unlikely(ret)) {
3dca2276
PP		 1107 BT_LOGW("Cannot serialize sequence field's element field: "
1108 "sequence-field-addr=%p, field-addr=%p, "
1109 "index=%" PRId64, field, elem_field, i);
1110 goto end;
1111 }
1112 }
1113
1114end:
1115 return ret;
1116}
1117
1118static
16ca5ff0 1119int bt_ctf_field_string_serialize(struct bt_ctf_field_common *field,
013f35c6 1120 struct bt_ctfser *ctfser,
3dca2276
PP		 1121 enum bt_ctf_byte_order native_byte_order)
1122{
013f35c6 1123 int ret;
16ca5ff0 1124 struct bt_ctf_field_common_string *string = BT_CTF_FROM_COMMON(field);
3dca2276 1125
16ca5ff0 1126 BT_ASSERT_PRE_CTF_FIELD_COMMON_IS_SET(field, "String field");
013f35c6
PP		 1127 BT_LOGV("Serializing string field: addr=%p, native-bo=%s",
1128 field, bt_ctf_byte_order_string((int) native_byte_order));
1129 ret = bt_ctfser_write_string(ctfser, (const char *) string->buf->data);
1130 if (unlikely(ret)) {
1131 BT_LOGE("Cannot serialize string field: ret=%d", ret);
1132 goto end;
3dca2276
PP		 1133 }
1134
1135end:
3dca2276
PP		 1136 return ret;
1137}
1138
1139struct bt_ctf_field *bt_ctf_field_create(struct bt_ctf_field_type *type)
1140{
1141 struct bt_ctf_field *field = NULL;
1142 enum bt_ctf_field_type_id type_id;
1143
1144 BT_ASSERT_PRE_NON_NULL(type, "Field type");
1145 BT_ASSERT(field_type_common_has_known_id((void *) type));
16ca5ff0
PP		 1146 BT_ASSERT_PRE(bt_ctf_field_type_common_validate((void *) type) == 0,
1147 "Field type is invalid: ft-addr=%p", type);
3dca2276
PP		 1148 type_id = bt_ctf_field_type_get_type_id(type);
1149 field = field_create_funcs[type_id](type);
1150 if (!field) {
1151 goto end;
1152 }
1153
16ca5ff0 1154 bt_ctf_field_type_common_freeze((void *) type);
3dca2276
PP		 1155
1156end:
1157 return field;
1158}
1159
1160struct bt_ctf_field_type *bt_ctf_field_get_type(struct bt_ctf_field *field)
1161{
e1e02a22 1162 return bt_ctf_object_get_ref(bt_ctf_field_common_borrow_type((void *) field));
3dca2276
PP		 1163}
1164
1165enum bt_ctf_field_type_id bt_ctf_field_get_type_id(struct bt_ctf_field *field)
1166{
16ca5ff0 1167 struct bt_ctf_field_common *field_common = (void *) field;
3dca2276
PP		 1168
1169 BT_ASSERT_PRE_NON_NULL(field, "Field");
1170 return (int) field_common->type->id;
1171}
1172
3dca2276
PP		 1173int bt_ctf_field_sequence_set_length(struct bt_ctf_field *field,
1174 struct bt_ctf_field *length_field)
1175{
312c056a 1176 int ret;
16ca5ff0 1177 struct bt_ctf_field_common *common_length_field = (void *) length_field;
312c056a
PP		 1178 uint64_t length;
1179
1180 BT_ASSERT_PRE_NON_NULL(length_field, "Length field");
16ca5ff0
PP		 1181 BT_ASSERT_PRE_CTF_FIELD_COMMON_IS_SET((void *) length_field, "Length field");
1182 BT_ASSERT_PRE(common_length_field->type->id == BT_CTF_FIELD_TYPE_ID_INTEGER ||
1183 common_length_field->type->id == BT_CTF_FIELD_TYPE_ID_ENUM,
1184 "Length field must be an integer or enumeration field: field-addr=%p",
312c056a
PP		 1185 length_field);
1186
16ca5ff0 1187 if (common_length_field->type->id == BT_CTF_FIELD_TYPE_ID_ENUM) {
312c056a
PP		 1188 struct bt_ctf_field_enumeration *enumeration = (void *)
1189 length_field;
1190
1191 length_field = (void *) enumeration->container;
1192 }
1193
1194 ret = bt_ctf_field_integer_unsigned_get_value(length_field, &length);
1195 BT_ASSERT(ret == 0);
16ca5ff0
PP		 1196 return bt_ctf_field_common_sequence_set_length((void *) field,
1197 length, (bt_ctf_field_common_create_func) bt_ctf_field_create);
3dca2276
PP		 1198}
1199
1200struct bt_ctf_field *bt_ctf_field_structure_get_field_by_index(
1201 struct bt_ctf_field *field, uint64_t index)
1202{
e1e02a22 1203 return bt_ctf_object_get_ref(bt_ctf_field_common_structure_borrow_field_by_index(
094ff7c0 1204 (void *) field, index));
3dca2276
PP		 1205}
1206
1207struct bt_ctf_field *bt_ctf_field_structure_get_field_by_name(
1208 struct bt_ctf_field *field, const char *name)
1209{
e1e02a22 1210 return bt_ctf_object_get_ref(bt_ctf_field_common_structure_borrow_field_by_name(
094ff7c0 1211 (void *) field, name));
3dca2276
PP		 1212}
1213
3dca2276
PP		 1214struct bt_ctf_field *bt_ctf_field_array_get_field(
1215 struct bt_ctf_field *field, uint64_t index)
1216{
e1e02a22 1217 return bt_ctf_object_get_ref(
16ca5ff0 1218 bt_ctf_field_common_array_borrow_field((void *) field, index));
3dca2276
PP		 1219}
1220
1221struct bt_ctf_field *bt_ctf_field_sequence_get_field(
1222 struct bt_ctf_field *field, uint64_t index)
1223{
e1e02a22 1224 return bt_ctf_object_get_ref(
16ca5ff0 1225 bt_ctf_field_common_sequence_borrow_field((void *) field, index));
3dca2276
PP		 1226}
1227
1228struct bt_ctf_field *bt_ctf_field_variant_get_field(struct bt_ctf_field *field,
1229 struct bt_ctf_field *tag_field)
1230{
312c056a
PP		 1231 struct bt_ctf_field_variant *variant_field = (void *) field;
1232 struct bt_ctf_field_enumeration *enum_field = (void *) tag_field;
16ca5ff0
PP		 1233 struct bt_ctf_field_type_common_variant *variant_ft;
1234 struct bt_ctf_field_type_common_enumeration *tag_ft;
312c056a
PP		 1235 struct bt_ctf_field *current_field = NULL;
1236 bt_bool is_signed;
1237 uint64_t tag_uval;
1238 int ret;
1239
1240 BT_ASSERT_PRE_NON_NULL(field, "Variant field");
1241 BT_ASSERT_PRE_NON_NULL(tag_field, "Tag field");
16ca5ff0
PP		 1242 BT_ASSERT_PRE_CTF_FIELD_COMMON_IS_SET((void *) tag_field, "Tag field");
1243 BT_ASSERT_PRE_CTF_FIELD_COMMON_HAS_TYPE_ID(
1244 (struct bt_ctf_field_common *) tag_field,
1245 BT_CTF_FIELD_TYPE_ID_ENUM, "Tag field");
1246 BT_ASSERT_PRE_CTF_FIELD_COMMON_HAS_TYPE_ID(
1247 (struct bt_ctf_field_common *) field,
1248 BT_CTF_FIELD_TYPE_ID_VARIANT, "Field");
312c056a 1249 BT_ASSERT_PRE(
16ca5ff0
PP		 1250 bt_ctf_field_common_validate_recursive((void *) tag_field) == 0,
1251 "Tag field is invalid: field-addr=%p", tag_field);
1252 variant_ft = BT_CTF_FROM_COMMON(variant_field->common.common.type);
1253 BT_ASSERT_PRE(bt_ctf_field_type_common_compare(
1254 BT_CTF_TO_COMMON(variant_ft->tag_ft), enum_field->common.type) == 0,
1255 "Unexpected tag field's type: expected-ft-addr=%p, "
1256 "tag-ft-addr=%p", variant_ft->tag_ft,
312c056a 1257 enum_field->common.type);
16ca5ff0 1258 tag_ft = BT_CTF_FROM_COMMON(enum_field->common.type);
312c056a
PP		 1259 is_signed = tag_ft->container_ft->is_signed;
1260
1261 if (is_signed) {
1262 int64_t tag_ival;
1263
1264 ret = bt_ctf_field_integer_signed_get_value(
1265 (void *) enum_field->container, &tag_ival);
1266 tag_uval = (uint64_t) tag_ival;
1267 } else {
1268 ret = bt_ctf_field_integer_unsigned_get_value(
1269 (void *) enum_field->container, &tag_uval);
1270 }
1271
1272 BT_ASSERT(ret == 0);
16ca5ff0 1273 ret = bt_ctf_field_common_variant_set_tag((void *) field, tag_uval,
312c056a
PP		 1274 is_signed);
1275 if (ret) {
1276 goto end;
1277 }
1278
e1e02a22
PP		 1279 bt_ctf_object_put_ref(variant_field->tag);
1280 variant_field->tag = bt_ctf_object_get_ref(tag_field);
312c056a
PP		 1281 current_field = bt_ctf_field_variant_get_current_field(field);
1282 BT_ASSERT(current_field);
1283
1284end:
1285 return current_field;
3dca2276
PP		 1286}
1287
1288struct bt_ctf_field *bt_ctf_field_variant_get_current_field(
1289 struct bt_ctf_field *variant_field)
1290{
e1e02a22 1291 return bt_ctf_object_get_ref(bt_ctf_field_common_variant_borrow_current_field(
094ff7c0 1292 (void *) variant_field));
3dca2276
PP		 1293}
1294
312c056a
PP		 1295BT_HIDDEN
1296struct bt_ctf_field *bt_ctf_field_enumeration_borrow_container(
1297 struct bt_ctf_field *field)
3dca2276 1298{
312c056a
PP		 1299 struct bt_ctf_field_enumeration *enumeration = (void *) field;
1300
1301 BT_ASSERT_PRE_NON_NULL(field, "Enumeration field");
16ca5ff0 1302 BT_ASSERT_PRE_CTF_FIELD_COMMON_HAS_TYPE_ID((struct bt_ctf_field_common *) field,
312c056a
PP		 1303 BT_CTF_FIELD_TYPE_ID_ENUM, "Field");
1304 BT_ASSERT(enumeration->container);
1305 return (void *) enumeration->container;
3dca2276
PP		 1306}
1307
312c056a
PP		 1308struct bt_ctf_field *bt_ctf_field_enumeration_get_container(
1309 struct bt_ctf_field *field)
3dca2276 1310{
e1e02a22 1311 return bt_ctf_object_get_ref(bt_ctf_field_enumeration_borrow_container(field));
3dca2276
PP		 1312}
1313
312c056a
PP		 1314int bt_ctf_field_integer_signed_get_value(struct bt_ctf_field *field,
1315 int64_t *value)
3dca2276 1316{
16ca5ff0 1317 struct bt_ctf_field_common_integer *integer = (void *) field;
312c056a
PP		 1318
1319 BT_ASSERT_PRE_NON_NULL(field, "Integer field");
1320 BT_ASSERT_PRE_NON_NULL(value, "Value");
16ca5ff0
PP		 1321 BT_ASSERT_PRE_CTF_FIELD_COMMON_IS_SET(BT_CTF_TO_COMMON(integer), "Integer field");
1322 BT_ASSERT_PRE_CTF_FIELD_COMMON_HAS_TYPE_ID(BT_CTF_TO_COMMON(integer),
1323 BT_CTF_FIELD_TYPE_ID_INTEGER, "Field");
1324 BT_ASSERT_PRE(bt_ctf_field_type_common_integer_is_signed(
312c056a 1325 integer->common.type),
16ca5ff0 1326 "Field's type is unsigned: field-addr=%p", field);
312c056a
PP		 1327 *value = integer->payload.signd;
1328 return 0;
3dca2276
PP		 1329}
1330
1331int bt_ctf_field_integer_signed_set_value(struct bt_ctf_field *field,
1332 int64_t value)
1333{
312c056a 1334 int ret = 0;
16ca5ff0
PP		 1335 struct bt_ctf_field_common_integer *integer = (void *) field;
1336 struct bt_ctf_field_type_common_integer *integer_type;
312c056a
PP		 1337
1338 BT_ASSERT_PRE_NON_NULL(field, "Integer field");
16ca5ff0
PP		 1339 BT_ASSERT_PRE_CTF_FIELD_COMMON_HOT(BT_CTF_TO_COMMON(integer), "Integer field");
1340 BT_ASSERT_PRE_CTF_FIELD_COMMON_HAS_TYPE_ID(BT_CTF_TO_COMMON(integer),
1341 BT_CTF_FIELD_TYPE_ID_INTEGER, "Field");
1342 integer_type = BT_CTF_FROM_COMMON(integer->common.type);
312c056a 1343 BT_ASSERT_PRE(
16ca5ff0
PP		 1344 bt_ctf_field_type_common_integer_is_signed(integer->common.type),
1345 "Field's type is unsigned: field-addr=%p", field);
312c056a 1346 BT_ASSERT_PRE(value_is_in_range_signed(integer_type->size, value),
16ca5ff0 1347 "Value is out of bounds: value=%" PRId64 ", field-addr=%p",
312c056a
PP		 1348 value, field);
1349 integer->payload.signd = value;
16ca5ff0 1350 bt_ctf_field_common_set(BT_CTF_TO_COMMON(integer), true);
312c056a 1351 return ret;
3dca2276
PP		 1352}
1353
1354int bt_ctf_field_integer_unsigned_get_value(struct bt_ctf_field *field,
1355 uint64_t *value)
1356{
16ca5ff0 1357 struct bt_ctf_field_common_integer *integer = (void *) field;
312c056a
PP		 1358
1359 BT_ASSERT_PRE_NON_NULL(field, "Integer field");
1360 BT_ASSERT_PRE_NON_NULL(value, "Value");
16ca5ff0
PP		 1361 BT_ASSERT_PRE_CTF_FIELD_COMMON_IS_SET(BT_CTF_TO_COMMON(integer), "Integer field");
1362 BT_ASSERT_PRE_CTF_FIELD_COMMON_HAS_TYPE_ID(BT_CTF_TO_COMMON(integer),
1363 BT_CTF_FIELD_TYPE_ID_INTEGER, "Field");
312c056a 1364 BT_ASSERT_PRE(
16ca5ff0
PP		 1365 !bt_ctf_field_type_common_integer_is_signed(integer->common.type),
1366 "Field's type is signed: field-addr=%p", field);
312c056a
PP		 1367 *value = integer->payload.unsignd;
1368 return 0;
3dca2276
PP		 1369}
1370
312c056a
PP		 1371int bt_ctf_field_integer_unsigned_set_value(struct bt_ctf_field *field,
1372 uint64_t value)
3dca2276 1373{
16ca5ff0
PP		 1374 struct bt_ctf_field_common_integer *integer = (void *) field;
1375 struct bt_ctf_field_type_common_integer *integer_type;
312c056a
PP		 1376
1377 BT_ASSERT_PRE_NON_NULL(field, "Integer field");
16ca5ff0
PP		 1378 BT_ASSERT_PRE_CTF_FIELD_COMMON_HOT(BT_CTF_TO_COMMON(integer), "Integer field");
1379 BT_ASSERT_PRE_CTF_FIELD_COMMON_HAS_TYPE_ID(BT_CTF_TO_COMMON(integer),
1380 BT_CTF_FIELD_TYPE_ID_INTEGER, "Field");
1381 integer_type = BT_CTF_FROM_COMMON(integer->common.type);
312c056a 1382 BT_ASSERT_PRE(
16ca5ff0
PP		 1383 !bt_ctf_field_type_common_integer_is_signed(integer->common.type),
1384 "Field's type is signed: field-addr=%p", field);
312c056a 1385 BT_ASSERT_PRE(value_is_in_range_unsigned(integer_type->size, value),
16ca5ff0 1386 "Value is out of bounds: value=%" PRIu64 ", field-addr=%p",
312c056a
PP		 1387 value, field);
1388 integer->payload.unsignd = value;
16ca5ff0 1389 bt_ctf_field_common_set(BT_CTF_TO_COMMON(integer), true);
312c056a 1390 return 0;
3dca2276
PP		 1391}
1392
1393int bt_ctf_field_floating_point_get_value(struct bt_ctf_field *field,
1394 double *value)
1395{
16ca5ff0 1396 return bt_ctf_field_common_floating_point_get_value((void *) field, value);
3dca2276
PP		 1397}
1398
1399int bt_ctf_field_floating_point_set_value(struct bt_ctf_field *field,
1400 double value)
1401{
16ca5ff0 1402 return bt_ctf_field_common_floating_point_set_value((void *) field, value);
3dca2276
PP		 1403}
1404
1405const char *bt_ctf_field_string_get_value(struct bt_ctf_field *field)
1406{
16ca5ff0 1407 return bt_ctf_field_common_string_get_value((void *) field);
3dca2276
PP		 1408}
1409
1410int bt_ctf_field_string_set_value(struct bt_ctf_field *field, const char *value)
1411{
16ca5ff0 1412 return bt_ctf_field_common_string_set_value((void *) field, value);
3dca2276
PP		 1413}
1414
1415int bt_ctf_field_string_append(struct bt_ctf_field *field, const char *value)
1416{
16ca5ff0 1417 return bt_ctf_field_common_string_append((void *) field, value);
3dca2276
PP		 1418}
1419
1420int bt_ctf_field_string_append_len(struct bt_ctf_field *field,
1421 const char *value, unsigned int length)
1422{
16ca5ff0 1423 return bt_ctf_field_common_string_append_len((void *) field, value, length);
3dca2276
PP		 1424}
1425
1426struct bt_ctf_field *bt_ctf_field_copy(struct bt_ctf_field *field)
1427{
16ca5ff0 1428 return (void *) bt_ctf_field_common_copy((void *) field);
3dca2276
PP		 1429}
1430
1431static
1432struct bt_ctf_field *bt_ctf_field_integer_create(struct bt_ctf_field_type *type)
1433{
16ca5ff0
PP		 1434 struct bt_ctf_field_common_integer *integer =
1435 g_new0(struct bt_ctf_field_common_integer, 1);
3dca2276
PP		 1436
1437 BT_LOGD("Creating CTF writer integer field object: ft-addr=%p", type);
1438
1439 if (integer) {
16ca5ff0 1440 bt_ctf_field_common_initialize(BT_CTF_TO_COMMON(integer), (void *) type,
3fea54f6 1441 true,
e1e02a22 1442 (bt_ctf_object_release_func) bt_ctf_field_integer_destroy,
3dca2276
PP		 1443 &bt_ctf_field_integer_methods);
1444 integer->common.spec.writer.serialize_func =
1445 (bt_ctf_field_serialize_recursive_func) bt_ctf_field_integer_serialize;
1446 BT_LOGD("Created CTF writer integer field object: addr=%p, ft-addr=%p",
1447 integer, type);
1448 } else {
1449 BT_LOGE_STR("Failed to allocate one integer field.");
1450 }
1451
1452 return (void *) integer;
1453}
1454
1455static
1456struct bt_ctf_field *bt_ctf_field_enumeration_create(
1457 struct bt_ctf_field_type *type)
1458{
16ca5ff0 1459 struct bt_ctf_field_type_common_enumeration *enum_ft = (void *) type;
312c056a
PP		 1460 struct bt_ctf_field_enumeration *enumeration = g_new0(
1461 struct bt_ctf_field_enumeration, 1);
3dca2276
PP		 1462
1463 BT_LOGD("Creating CTF writer enumeration field object: ft-addr=%p", type);
1464
312c056a 1465 if (!enumeration) {
3dca2276 1466 BT_LOGE_STR("Failed to allocate one enumeration field.");
312c056a 1467 goto end;
3dca2276
PP		 1468 }
1469
16ca5ff0 1470 bt_ctf_field_common_initialize(BT_CTF_TO_COMMON(enumeration),
312c056a 1471 (void *) type,
e1e02a22 1472 true, (bt_ctf_object_release_func)
312c056a
PP		 1473 bt_ctf_field_enumeration_destroy_recursive,
1474 &bt_ctf_field_enumeration_methods);
1475 enumeration->container = (void *) bt_ctf_field_create(
16ca5ff0 1476 BT_CTF_FROM_COMMON(enum_ft->container_ft));
312c056a 1477 if (!enumeration->container) {
e1e02a22 1478 BT_CTF_OBJECT_PUT_REF_AND_RESET(enumeration);
312c056a
PP		 1479 goto end;
1480 }
1481
1482 enumeration->common.spec.writer.serialize_func =
1483 (bt_ctf_field_serialize_recursive_func)
1484 bt_ctf_field_enumeration_serialize_recursive;
1485 BT_LOGD("Created CTF writer enumeration field object: addr=%p, ft-addr=%p",
1486 enumeration, type);
1487
1488end:
3dca2276
PP		 1489 return (void *) enumeration;
1490}
1491
1492static
1493struct bt_ctf_field *bt_ctf_field_floating_point_create(
1494 struct bt_ctf_field_type *type)
1495{
16ca5ff0 1496 struct bt_ctf_field_common_floating_point *floating_point;
3dca2276
PP		 1497
1498 BT_LOGD("Creating CTF writer floating point number field object: ft-addr=%p", type);
16ca5ff0 1499 floating_point = g_new0(struct bt_ctf_field_common_floating_point, 1);
3dca2276
PP		 1500
1501 if (floating_point) {
16ca5ff0 1502 bt_ctf_field_common_initialize(BT_CTF_TO_COMMON(floating_point),
3dca2276 1503 (void *) type,
e1e02a22 1504 true, (bt_ctf_object_release_func)
312c056a 1505 bt_ctf_field_floating_point_destroy,
3dca2276
PP		 1506 &bt_ctf_field_floating_point_methods);
1507 floating_point->common.spec.writer.serialize_func =
1508 (bt_ctf_field_serialize_recursive_func) bt_ctf_field_floating_point_serialize;
1509 BT_LOGD("Created CTF writer floating point number field object: addr=%p, ft-addr=%p",
1510 floating_point, type);
1511 } else {
1512 BT_LOGE_STR("Failed to allocate one floating point number field.");
1513 }
1514
1515 return (void *) floating_point;
1516}
1517
1518static
1519struct bt_ctf_field *bt_ctf_field_structure_create(
1520 struct bt_ctf_field_type *type)
1521{
16ca5ff0
PP		 1522 struct bt_ctf_field_common_structure *structure = g_new0(
1523 struct bt_ctf_field_common_structure, 1);
3dca2276
PP		 1524 int iret;
1525
1526 BT_LOGD("Creating CTF writer structure field object: ft-addr=%p", type);
1527
1528 if (!structure) {
1529 BT_LOGE_STR("Failed to allocate one structure field.");
1530 goto end;
1531 }
1532
16ca5ff0 1533 iret = bt_ctf_field_common_structure_initialize(BT_CTF_TO_COMMON(structure),
312c056a 1534 (void *) type,
e1e02a22 1535 true, (bt_ctf_object_release_func)
312c056a 1536 bt_ctf_field_structure_destroy_recursive,
3dca2276 1537 &bt_ctf_field_structure_methods,
16ca5ff0 1538 (bt_ctf_field_common_create_func) bt_ctf_field_create,
e1e02a22 1539 (GDestroyNotify) bt_ctf_object_put_ref);
3dca2276
PP		 1540 structure->common.spec.writer.serialize_func =
1541 (bt_ctf_field_serialize_recursive_func) bt_ctf_field_structure_serialize_recursive;
1542 if (iret) {
e1e02a22 1543 BT_CTF_OBJECT_PUT_REF_AND_RESET(structure);
3dca2276
PP		 1544 goto end;
1545 }
1546
1547 BT_LOGD("Created CTF writer structure field object: addr=%p, ft-addr=%p",
1548 structure, type);
1549
1550end:
1551 return (void *) structure;
1552}
1553
1554static
1555struct bt_ctf_field *bt_ctf_field_variant_create(struct bt_ctf_field_type *type)
1556{
16ca5ff0 1557 struct bt_ctf_field_type_common_variant *var_ft = (void *) type;
312c056a
PP		 1558 struct bt_ctf_field_variant *variant = g_new0(
1559 struct bt_ctf_field_variant, 1);
3dca2276
PP		 1560
1561 BT_LOGD("Creating CTF writer variant field object: ft-addr=%p", type);
1562
312c056a 1563 if (!variant) {
3dca2276 1564 BT_LOGE_STR("Failed to allocate one variant field.");
312c056a 1565 goto end;
3dca2276
PP		 1566 }
1567
16ca5ff0 1568 bt_ctf_field_common_variant_initialize(BT_CTF_TO_COMMON(BT_CTF_TO_COMMON(variant)),
312c056a 1569 (void *) type,
e1e02a22 1570 true, (bt_ctf_object_release_func)
312c056a
PP		 1571 bt_ctf_field_variant_destroy_recursive,
1572 &bt_ctf_field_variant_methods,
16ca5ff0 1573 (bt_ctf_field_common_create_func) bt_ctf_field_create,
e1e02a22 1574 (GDestroyNotify) bt_ctf_object_put_ref);
312c056a 1575 variant->tag = (void *) bt_ctf_field_create(
16ca5ff0 1576 BT_CTF_FROM_COMMON(var_ft->tag_ft));
312c056a
PP		 1577 variant->common.common.spec.writer.serialize_func =
1578 (bt_ctf_field_serialize_recursive_func) bt_ctf_field_variant_serialize_recursive;
1579 BT_LOGD("Created CTF writer variant field object: addr=%p, ft-addr=%p",
1580 variant, type);
1581
1582end:
3dca2276
PP		 1583 return (void *) variant;
1584}
1585
1586static
1587struct bt_ctf_field *bt_ctf_field_array_create(struct bt_ctf_field_type *type)
1588{
16ca5ff0
PP		 1589 struct bt_ctf_field_common_array *array =
1590 g_new0(struct bt_ctf_field_common_array, 1);
3dca2276
PP		 1591 int ret;
1592
1593 BT_LOGD("Creating CTF writer array field object: ft-addr=%p", type);
1594 BT_ASSERT(type);
1595
1596 if (!array) {
1597 BT_LOGE_STR("Failed to allocate one array field.");
1598 goto end;
1599 }
1600
16ca5ff0 1601 ret = bt_ctf_field_common_array_initialize(BT_CTF_TO_COMMON(array),
3dca2276 1602 (void *) type,
e1e02a22 1603 true, (bt_ctf_object_release_func)
312c056a
PP		 1604 bt_ctf_field_array_destroy_recursive,
1605 &bt_ctf_field_array_methods,
16ca5ff0 1606 (bt_ctf_field_common_create_func) bt_ctf_field_create,
e1e02a22 1607 (GDestroyNotify) bt_ctf_object_put_ref);
3dca2276
PP		 1608 array->common.spec.writer.serialize_func =
1609 (bt_ctf_field_serialize_recursive_func) bt_ctf_field_array_serialize_recursive;
1610 if (ret) {
e1e02a22 1611 BT_CTF_OBJECT_PUT_REF_AND_RESET(array);
3dca2276
PP		 1612 goto end;
1613 }
1614
1615 BT_LOGD("Created CTF writer array field object: addr=%p, ft-addr=%p",
1616 array, type);
1617
1618end:
1619 return (void *) array;
1620}
1621
1622static
1623struct bt_ctf_field *bt_ctf_field_sequence_create(struct bt_ctf_field_type *type)
1624{
16ca5ff0
PP		 1625 struct bt_ctf_field_common_sequence *sequence = g_new0(
1626 struct bt_ctf_field_common_sequence, 1);
3dca2276
PP		 1627
1628 BT_LOGD("Creating CTF writer sequence field object: ft-addr=%p", type);
1629
1630 if (sequence) {
16ca5ff0 1631 bt_ctf_field_common_sequence_initialize(BT_CTF_TO_COMMON(sequence),
3dca2276 1632 (void *) type,
e1e02a22 1633 true, (bt_ctf_object_release_func)
312c056a
PP		 1634 bt_ctf_field_sequence_destroy_recursive,
1635 &bt_ctf_field_sequence_methods,
e1e02a22 1636 (GDestroyNotify) bt_ctf_object_put_ref);
3dca2276
PP		 1637 sequence->common.spec.writer.serialize_func =
1638 (bt_ctf_field_serialize_recursive_func) bt_ctf_field_sequence_serialize_recursive;
1639 BT_LOGD("Created CTF writer sequence field object: addr=%p, ft-addr=%p",
1640 sequence, type);
1641 } else {
1642 BT_LOGE_STR("Failed to allocate one sequence field.");
1643 }
1644
1645 return (void *) sequence;
1646}
1647
1648static
1649struct bt_ctf_field *bt_ctf_field_string_create(struct bt_ctf_field_type *type)
1650{
16ca5ff0
PP		 1651 struct bt_ctf_field_common_string *string = g_new0(
1652 struct bt_ctf_field_common_string, 1);
3dca2276
PP		 1653
1654 BT_LOGD("Creating CTF writer string field object: ft-addr=%p", type);
1655
1656 if (string) {
16ca5ff0 1657 bt_ctf_field_common_string_initialize(BT_CTF_TO_COMMON(string),
3dca2276 1658 (void *) type,
e1e02a22 1659 true, (bt_ctf_object_release_func)
312c056a 1660 bt_ctf_field_string_destroy,
3dca2276
PP		 1661 &bt_ctf_field_string_methods);
1662 string->common.spec.writer.serialize_func =
1663 (bt_ctf_field_serialize_recursive_func) bt_ctf_field_string_serialize;
1664 BT_LOGD("Created CTF writer string field object: addr=%p, ft-addr=%p",
1665 string, type);
1666 } else {
1667 BT_LOGE_STR("Failed to allocate one string field.");
1668 }
1669
1670 return (void *) string;
1671}
312c056a
PP		 1672
1673static
1674void bt_ctf_field_enumeration_set_is_frozen_recursive(
16ca5ff0 1675 struct bt_ctf_field_common *field, bool is_frozen)
312c056a
PP		 1676{
1677 struct bt_ctf_field_enumeration *enumeration = (void *) field;
1678
1679 if (enumeration->container) {
16ca5ff0 1680 bt_ctf_field_common_set_is_frozen_recursive(
312c056a
PP		 1681 (void *) enumeration->container, is_frozen);
1682 }
1683
16ca5ff0 1684 bt_ctf_field_common_generic_set_is_frozen((void *) field, is_frozen);
312c056a
PP		 1685}
1686
1687static
16ca5ff0 1688int bt_ctf_field_enumeration_validate_recursive(struct bt_ctf_field_common *field)
312c056a
PP		 1689{
1690 int ret = -1;
1691 struct bt_ctf_field_enumeration *enumeration = (void *) field;
1692
1693 if (enumeration->container) {
16ca5ff0 1694 ret = bt_ctf_field_common_validate_recursive(
312c056a
PP		 1695 (void *) enumeration->container);
1696 }
1697
1698 return ret;
1699}
1700
1701static
16ca5ff0 1702bt_bool bt_ctf_field_enumeration_is_set_recursive(struct bt_ctf_field_common *field)
312c056a
PP		 1703{
1704 bt_bool is_set = BT_FALSE;
1705 struct bt_ctf_field_enumeration *enumeration = (void *) field;
1706
1707 if (enumeration->container) {
16ca5ff0 1708 is_set = bt_ctf_field_common_is_set_recursive(
312c056a
PP		 1709 (void *) enumeration->container);
1710 }
1711
1712 return is_set;
1713}
1714
1715static
16ca5ff0 1716void bt_ctf_field_enumeration_reset_recursive(struct bt_ctf_field_common *field)
312c056a
PP		 1717{
1718 struct bt_ctf_field_enumeration *enumeration = (void *) field;
1719
1720 if (enumeration->container) {
16ca5ff0 1721 bt_ctf_field_common_reset_recursive(
312c056a
PP		 1722 (void *) enumeration->container);
1723 }
1724
16ca5ff0 1725 bt_ctf_field_common_generic_reset((void *) field);
312c056a
PP		 1726}
1727
1728static
1729void bt_ctf_field_variant_set_is_frozen_recursive(
16ca5ff0 1730 struct bt_ctf_field_common *field, bool is_frozen)
312c056a
PP		 1731{
1732 struct bt_ctf_field_variant *variant = (void *) field;
1733
1734 if (variant->tag) {
16ca5ff0 1735 bt_ctf_field_common_set_is_frozen_recursive(
312c056a
PP		 1736 (void *) variant->tag, is_frozen);
1737 }
1738
16ca5ff0 1739 bt_ctf_field_common_variant_set_is_frozen_recursive((void *) field,
312c056a
PP		 1740 is_frozen);
1741}
1742
1743static
16ca5ff0 1744int bt_ctf_field_variant_validate_recursive(struct bt_ctf_field_common *field)
312c056a
PP		 1745{
1746 int ret;
1747 struct bt_ctf_field_variant *variant = (void *) field;
1748
1749 if (variant->tag) {
16ca5ff0 1750 ret = bt_ctf_field_common_validate_recursive(
312c056a
PP		 1751 (void *) variant->tag);
1752 if (ret) {
1753 goto end;
1754 }
1755 }
1756
16ca5ff0 1757 ret = bt_ctf_field_common_variant_validate_recursive((void *) field);
312c056a
PP		 1758
1759end:
1760 return ret;
1761}
1762
1763static
16ca5ff0 1764bt_bool bt_ctf_field_variant_is_set_recursive(struct bt_ctf_field_common *field)
312c056a
PP		 1765{
1766 bt_bool is_set;
1767 struct bt_ctf_field_variant *variant = (void *) field;
1768
1769 if (variant->tag) {
16ca5ff0 1770 is_set = bt_ctf_field_common_is_set_recursive(
312c056a
PP		 1771 (void *) variant->tag);
1772 if (is_set) {
1773 goto end;
1774 }
1775 }
1776
16ca5ff0 1777 is_set = bt_ctf_field_common_variant_is_set_recursive((void *) field);
312c056a
PP		 1778
1779end:
1780 return is_set;
1781}
1782
1783static
16ca5ff0 1784void bt_ctf_field_variant_reset_recursive(struct bt_ctf_field_common *field)
312c056a
PP		 1785{
1786 struct bt_ctf_field_variant *variant = (void *) field;
1787
1788 if (variant->tag) {
16ca5ff0 1789 bt_ctf_field_common_reset_recursive(
312c056a
PP		 1790 (void *) variant->tag);
1791 }
1792
16ca5ff0 1793 bt_ctf_field_common_variant_reset_recursive((void *) field);
312c056a
PP		 1794}
1795
1796BT_ASSERT_PRE_FUNC
1797static inline bool field_to_set_has_expected_type(
16ca5ff0
PP		 1798 struct bt_ctf_field_common *struct_field,
1799 const char *name, struct bt_ctf_field_common *value)
312c056a
PP		 1800{
1801 bool ret = true;
16ca5ff0 1802 struct bt_ctf_field_type_common *expected_field_type = NULL;
312c056a
PP		 1803
1804 expected_field_type =
16ca5ff0 1805 bt_ctf_field_type_common_structure_borrow_field_type_by_name(
312c056a
PP		 1806 struct_field->type, name);
1807
16ca5ff0 1808 if (bt_ctf_field_type_common_compare(expected_field_type, value->type)) {
312c056a 1809 BT_ASSERT_PRE_MSG("Value field's type is different from the expected field type: "
16ca5ff0 1810 "value-ft-addr=%p, expected-ft-addr=%p", value->type,
312c056a
PP		 1811 expected_field_type);
1812 ret = false;
1813 goto end;
1814 }
1815
1816end:
1817 return ret;
1818}
1819
1820BT_HIDDEN
1821int bt_ctf_field_structure_set_field_by_name(struct bt_ctf_field *field,
1822 const char *name, struct bt_ctf_field *value)
1823{
1824 int ret = 0;
1825 GQuark field_quark;
16ca5ff0
PP		 1826 struct bt_ctf_field_common *common_field = (void *) field;
1827 struct bt_ctf_field_common_structure *structure =
1828 BT_CTF_FROM_COMMON(common_field);
1829 struct bt_ctf_field_common *common_value = (void *) value;
312c056a
PP		 1830 size_t index;
1831 GHashTable *field_name_to_index;
16ca5ff0 1832 struct bt_ctf_field_type_common_structure *structure_ft;
312c056a
PP		 1833
1834 BT_ASSERT_PRE_NON_NULL(field, "Parent field");
1835 BT_ASSERT_PRE_NON_NULL(name, "Field name");
1836 BT_ASSERT_PRE_NON_NULL(value, "Value field");
16ca5ff0
PP		 1837 BT_ASSERT_PRE_CTF_FIELD_COMMON_HAS_TYPE_ID(common_field,
1838 BT_CTF_FIELD_TYPE_ID_STRUCT, "Parent field");
312c056a
PP		 1839 BT_ASSERT_PRE(field_to_set_has_expected_type(common_field,
1840 name, common_value),
1841 "Value field's type is different from the expected field type.");
1842 field_quark = g_quark_from_string(name);
16ca5ff0 1843 structure_ft = BT_CTF_FROM_COMMON(common_field->type);
312c056a
PP		 1844 field_name_to_index = structure_ft->field_name_to_index;
1845 if (!g_hash_table_lookup_extended(field_name_to_index,
1846 GUINT_TO_POINTER(field_quark), NULL,
1847 (gpointer *) &index)) {
1848 BT_LOGV("Invalid parameter: no such field in structure field's type: "
1849 "struct-field-addr=%p, struct-ft-addr=%p, "
1850 "field-ft-addr=%p, name=\"%s\"",
1851 field, common_field->type, common_value->type, name);
1852 ret = -1;
1853 goto end;
1854 }
e1e02a22
PP		 1855 bt_ctf_object_get_ref(value);
1856 BT_CTF_OBJECT_MOVE_REF(structure->fields->pdata[index], value);
312c056a
PP		 1857
1858end:
1859 return ret;
1860}
BabelTrace - Trace Format Babel Tower
This page took 0.109519 seconds and 4 git commands to generate.