projects / babeltrace.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
Field class API: use status
[babeltrace.git] / lib / trace-ir / field.c
... / ...
CommitLineData
1/*
2 * Copyright 2017-2018 Philippe Proulx <pproulx@efficios.com>
3 * Copyright 2013, 2014 Jérémie Galarneau <jeremie.galarneau@efficios.com>
4 *
5 * Permission is hereby granted, free of charge, to any person obtaining a copy
6 * of this software and associated documentation files (the "Software"), to deal
7 * in the Software without restriction, including without limitation the rights
8 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
9 * copies of the Software, and to permit persons to whom the Software is
10 * furnished to do so, subject to the following conditions:
11 *
12 * The above copyright notice and this permission notice shall be included in
13 * all copies or substantial portions of the Software.
14 *
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 * SOFTWARE.
22 */
23
24#define BT_LOG_TAG "FIELDS"
25#include <babeltrace/lib-logging-internal.h>
26
27#include <babeltrace/assert-pre-internal.h>
28#include <babeltrace/trace-ir/field.h>
29#include <babeltrace/trace-ir/field-const.h>
30#include <babeltrace/trace-ir/field-internal.h>
31#include <babeltrace/trace-ir/field-class-internal.h>
32#include <babeltrace/object-internal.h>
33#include <babeltrace/compiler-internal.h>
34#include <babeltrace/compat/fcntl-internal.h>
35#include <babeltrace/align-internal.h>
36#include <babeltrace/assert-internal.h>
37#include <inttypes.h>
38
39static
40void reset_single_field(struct bt_field *field);
41
42static
43void reset_array_field(struct bt_field *field);
44
45static
46void reset_structure_field(struct bt_field *field);
47
48static
49void reset_variant_field(struct bt_field *field);
50
51static
52void set_single_field_is_frozen(struct bt_field *field, bool is_frozen);
53
54static
55void set_array_field_is_frozen(struct bt_field *field, bool is_frozen);
56
57static
58void set_structure_field_is_frozen(struct bt_field *field, bool is_frozen);
59
60static
61void set_variant_field_is_frozen(struct bt_field *field, bool is_frozen);
62
63static
64bool single_field_is_set(const struct bt_field *field);
65
66static
67bool array_field_is_set(const struct bt_field *field);
68
69static
70bool structure_field_is_set(const struct bt_field *field);
71
72static
73bool variant_field_is_set(const struct bt_field *field);
74
75static
76struct bt_field_methods integer_field_methods = {
77 .set_is_frozen = set_single_field_is_frozen,
78 .is_set = single_field_is_set,
79 .reset = reset_single_field,
80};
81
82static
83struct bt_field_methods real_field_methods = {
84 .set_is_frozen = set_single_field_is_frozen,
85 .is_set = single_field_is_set,
86 .reset = reset_single_field,
87};
88
89static
90struct bt_field_methods string_field_methods = {
91 .set_is_frozen = set_single_field_is_frozen,
92 .is_set = single_field_is_set,
93 .reset = reset_single_field,
94};
95
96static
97struct bt_field_methods structure_field_methods = {
98 .set_is_frozen = set_structure_field_is_frozen,
99 .is_set = structure_field_is_set,
100 .reset = reset_structure_field,
101};
102
103static
104struct bt_field_methods array_field_methods = {
105 .set_is_frozen = set_array_field_is_frozen,
106 .is_set = array_field_is_set,
107 .reset = reset_array_field,
108};
109
110static
111struct bt_field_methods variant_field_methods = {
112 .set_is_frozen = set_variant_field_is_frozen,
113 .is_set = variant_field_is_set,
114 .reset = reset_variant_field,
115};
116
117static
118struct bt_field *create_integer_field(struct bt_field_class *);
119
120static
121struct bt_field *create_real_field(struct bt_field_class *);
122
123static
124struct bt_field *create_string_field(struct bt_field_class *);
125
126static
127struct bt_field *create_structure_field(struct bt_field_class *);
128
129static
130struct bt_field *create_static_array_field(struct bt_field_class *);
131
132static
133struct bt_field *create_dynamic_array_field(struct bt_field_class *);
134
135static
136struct bt_field *create_variant_field(struct bt_field_class *);
137
138static
139struct bt_field *(* const field_create_funcs[])(struct bt_field_class *) = {
140 [BT_FIELD_CLASS_TYPE_UNSIGNED_INTEGER] = create_integer_field,
141 [BT_FIELD_CLASS_TYPE_SIGNED_INTEGER] = create_integer_field,
142 [BT_FIELD_CLASS_TYPE_UNSIGNED_ENUMERATION] = create_integer_field,
143 [BT_FIELD_CLASS_TYPE_SIGNED_ENUMERATION] = create_integer_field,
144 [BT_FIELD_CLASS_TYPE_REAL] = create_real_field,
145 [BT_FIELD_CLASS_TYPE_STRING] = create_string_field,
146 [BT_FIELD_CLASS_TYPE_STRUCTURE] = create_structure_field,
147 [BT_FIELD_CLASS_TYPE_STATIC_ARRAY] = create_static_array_field,
148 [BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY] = create_dynamic_array_field,
149 [BT_FIELD_CLASS_TYPE_VARIANT] = create_variant_field,
150};
151
152static
153void destroy_integer_field(struct bt_field *field);
154
155static
156void destroy_real_field(struct bt_field *field);
157
158static
159void destroy_string_field(struct bt_field *field);
160
161static
162void destroy_structure_field(struct bt_field *field);
163
164static
165void destroy_array_field(struct bt_field *field);
166
167static
168void destroy_variant_field(struct bt_field *field);
169
170static
171void (* const field_destroy_funcs[])(struct bt_field *) = {
172 [BT_FIELD_CLASS_TYPE_UNSIGNED_INTEGER] = destroy_integer_field,
173 [BT_FIELD_CLASS_TYPE_SIGNED_INTEGER] = destroy_integer_field,
174 [BT_FIELD_CLASS_TYPE_UNSIGNED_ENUMERATION] = destroy_integer_field,
175 [BT_FIELD_CLASS_TYPE_SIGNED_ENUMERATION] = destroy_integer_field,
176 [BT_FIELD_CLASS_TYPE_REAL] = destroy_real_field,
177 [BT_FIELD_CLASS_TYPE_STRING] = destroy_string_field,
178 [BT_FIELD_CLASS_TYPE_STRUCTURE] = destroy_structure_field,
179 [BT_FIELD_CLASS_TYPE_STATIC_ARRAY] = destroy_array_field,
180 [BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY] = destroy_array_field,
181 [BT_FIELD_CLASS_TYPE_VARIANT] = destroy_variant_field,
182};
183
184struct bt_field_class *bt_field_borrow_class(const struct bt_field *field)
185{
186 BT_ASSERT_PRE_NON_NULL(field, "Field");
187 return field->class;
188}
189
190const struct bt_field_class *bt_field_borrow_class_const(
191 const struct bt_field *field)
192{
193 BT_ASSERT_PRE_NON_NULL(field, "Field");
194 return field->class;
195}
196
197enum bt_field_class_type bt_field_get_class_type(const struct bt_field *field)
198{
199 BT_ASSERT_PRE_NON_NULL(field, "Field");
200 return field->class->type;
201}
202
203BT_HIDDEN
204struct bt_field *bt_field_create(struct bt_field_class *fc)
205{
206 struct bt_field *field = NULL;
207
208 BT_ASSERT_PRE_NON_NULL(fc, "Field class");
209 BT_ASSERT(bt_field_class_has_known_type(fc));
210 field = field_create_funcs[fc->type](fc);
211 if (!field) {
212 BT_LIB_LOGE("Cannot create field object from field class: "
213 "%![fc-]+F", fc);
214 goto end;
215 }
216
217end:
218 return field;
219}
220
221static inline
222void init_field(struct bt_field *field, struct bt_field_class *fc,
223 struct bt_field_methods *methods)
224{
225 BT_ASSERT(field);
226 BT_ASSERT(fc);
227 bt_object_init_unique(&field->base);
228 field->methods = methods;
229 field->class = fc;
230 bt_object_get_no_null_check(fc);
231}
232
233static
234struct bt_field *create_integer_field(struct bt_field_class *fc)
235{
236 struct bt_field_integer *int_field;
237
238 BT_LIB_LOGD("Creating integer field object: %![fc-]+F", fc);
239 int_field = g_new0(struct bt_field_integer, 1);
240 if (!int_field) {
241 BT_LOGE_STR("Failed to allocate one integer field.");
242 goto end;
243 }
244
245 init_field((void *) int_field, fc, &integer_field_methods);
246 BT_LIB_LOGD("Created integer field object: %!+f", int_field);
247
248end:
249 return (void *) int_field;
250}
251
252static
253struct bt_field *create_real_field(struct bt_field_class *fc)
254{
255 struct bt_field_real *real_field;
256
257 BT_LIB_LOGD("Creating real field object: %![fc-]+F", fc);
258 real_field = g_new0(struct bt_field_real, 1);
259 if (!real_field) {
260 BT_LOGE_STR("Failed to allocate one real field.");
261 goto end;
262 }
263
264 init_field((void *) real_field, fc, &real_field_methods);
265 BT_LIB_LOGD("Created real field object: %!+f", real_field);
266
267end:
268 return (void *) real_field;
269}
270
271static
272struct bt_field *create_string_field(struct bt_field_class *fc)
273{
274 struct bt_field_string *string_field;
275
276 BT_LIB_LOGD("Creating string field object: %![fc-]+F", fc);
277 string_field = g_new0(struct bt_field_string, 1);
278 if (!string_field) {
279 BT_LOGE_STR("Failed to allocate one string field.");
280 goto end;
281 }
282
283 init_field((void *) string_field, fc, &string_field_methods);
284 string_field->buf = g_array_sized_new(FALSE, FALSE,
285 sizeof(char), 1);
286 if (!string_field->buf) {
287 BT_LOGE_STR("Failed to allocate a GArray.");
288 BT_OBJECT_PUT_REF_AND_RESET(string_field);
289 goto end;
290 }
291
292 g_array_index(string_field->buf, char, 0) = '\0';
293 BT_LIB_LOGD("Created string field object: %!+f", string_field);
294
295end:
296 return (void *) string_field;
297}
298
299static inline
300int create_fields_from_named_field_classes(
301 struct bt_field_class_named_field_class_container *fc,
302 GPtrArray **fields)
303{
304 int ret = 0;
305 uint64_t i;
306
307 *fields = g_ptr_array_new_with_free_func(
308 (GDestroyNotify) bt_field_destroy);
309 if (!*fields) {
310 BT_LOGE_STR("Failed to allocate a GPtrArray.");
311 ret = -1;
312 goto end;
313 }
314
315 g_ptr_array_set_size(*fields, fc->named_fcs->len);
316
317 for (i = 0; i < fc->named_fcs->len; i++) {
318 struct bt_field *field;
319 struct bt_named_field_class *named_fc =
320 BT_FIELD_CLASS_NAMED_FC_AT_INDEX(fc, i);
321
322 field = bt_field_create(named_fc->fc);
323 if (!field) {
324 BT_LIB_LOGE("Failed to create structure member or variant option field: "
325 "name=\"%s\", %![fc-]+F",
326 named_fc->name->str, named_fc->fc);
327 ret = -1;
328 goto end;
329 }
330
331 g_ptr_array_index(*fields, i) = field;
332 }
333
334end:
335 return ret;
336}
337
338static
339struct bt_field *create_structure_field(struct bt_field_class *fc)
340{
341 struct bt_field_structure *struct_field;
342
343 BT_LIB_LOGD("Creating structure field object: %![fc-]+F", fc);
344 struct_field = g_new0(struct bt_field_structure, 1);
345 if (!struct_field) {
346 BT_LOGE_STR("Failed to allocate one structure field.");
347 goto end;
348 }
349
350 init_field((void *) struct_field, fc, &structure_field_methods);
351
352 if (create_fields_from_named_field_classes((void *) fc,
353 &struct_field->fields)) {
354 BT_LIB_LOGE("Cannot create structure member fields: "
355 "%![fc-]+F", fc);
356 BT_OBJECT_PUT_REF_AND_RESET(struct_field);
357 goto end;
358 }
359
360 BT_LIB_LOGD("Created structure field object: %!+f", struct_field);
361
362end:
363 return (void *) struct_field;
364}
365
366static
367struct bt_field *create_variant_field(struct bt_field_class *fc)
368{
369 struct bt_field_variant *var_field;
370
371 BT_LIB_LOGD("Creating variant field object: %![fc-]+F", fc);
372 var_field = g_new0(struct bt_field_variant, 1);
373 if (!var_field) {
374 BT_LOGE_STR("Failed to allocate one variant field.");
375 goto end;
376 }
377
378 init_field((void *) var_field, fc, &variant_field_methods);
379
380 if (create_fields_from_named_field_classes((void *) fc,
381 &var_field->fields)) {
382 BT_LIB_LOGE("Cannot create variant member fields: "
383 "%![fc-]+F", fc);
384 BT_OBJECT_PUT_REF_AND_RESET(var_field);
385 goto end;
386 }
387
388 BT_LIB_LOGD("Created variant field object: %!+f", var_field);
389
390end:
391 return (void *) var_field;
392}
393
394static inline
395int init_array_field_fields(struct bt_field_array *array_field)
396{
397 int ret = 0;
398 uint64_t i;
399 struct bt_field_class_array *array_fc;
400
401 BT_ASSERT(array_field);
402 array_fc = (void *) array_field->common.class;
403 array_field->fields = g_ptr_array_sized_new(array_field->length);
404 if (!array_field->fields) {
405 BT_LOGE_STR("Failed to allocate a GPtrArray.");
406 ret = -1;
407 goto end;
408 }
409
410 g_ptr_array_set_free_func(array_field->fields,
411 (GDestroyNotify) bt_field_destroy);
412 g_ptr_array_set_size(array_field->fields, array_field->length);
413
414 for (i = 0; i < array_field->length; i++) {
415 array_field->fields->pdata[i] = bt_field_create(
416 array_fc->element_fc);
417 if (!array_field->fields->pdata[i]) {
418 BT_LIB_LOGE("Cannot create array field's element field: "
419 "index=%" PRIu64 ", %![fc-]+F", i, array_fc);
420 ret = -1;
421 goto end;
422 }
423 }
424
425end:
426 return ret;
427}
428
429static
430struct bt_field *create_static_array_field(struct bt_field_class *fc)
431{
432 struct bt_field_class_static_array *array_fc = (void *) fc;
433 struct bt_field_array *array_field;
434
435 BT_LIB_LOGD("Creating static array field object: %![fc-]+F", fc);
436 array_field = g_new0(struct bt_field_array, 1);
437 if (!array_field) {
438 BT_LOGE_STR("Failed to allocate one static array field.");
439 goto end;
440 }
441
442 init_field((void *) array_field, fc, &array_field_methods);
443 array_field->length = array_fc->length;
444
445 if (init_array_field_fields(array_field)) {
446 BT_LIB_LOGE("Cannot create static array fields: "
447 "%![fc-]+F", fc);
448 BT_OBJECT_PUT_REF_AND_RESET(array_field);
449 goto end;
450 }
451
452 BT_LIB_LOGD("Created static array field object: %!+f", array_field);
453
454end:
455 return (void *) array_field;
456}
457
458static
459struct bt_field *create_dynamic_array_field(struct bt_field_class *fc)
460{
461 struct bt_field_array *array_field;
462
463 BT_LIB_LOGD("Creating dynamic array field object: %![fc-]+F", fc);
464 array_field = g_new0(struct bt_field_array, 1);
465 if (!array_field) {
466 BT_LOGE_STR("Failed to allocate one dynamic array field.");
467 goto end;
468 }
469
470 init_field((void *) array_field, fc, &array_field_methods);
471
472 if (init_array_field_fields(array_field)) {
473 BT_LIB_LOGE("Cannot create dynamic array fields: "
474 "%![fc-]+F", fc);
475 BT_OBJECT_PUT_REF_AND_RESET(array_field);
476 goto end;
477 }
478
479 BT_LIB_LOGD("Created dynamic array field object: %!+f", array_field);
480
481end:
482 return (void *) array_field;
483}
484
485int64_t bt_field_signed_integer_get_value(const struct bt_field *field)
486{
487 const struct bt_field_integer *int_field = (const void *) field;
488
489 BT_ASSERT_PRE_NON_NULL(field, "Field");
490 BT_ASSERT_PRE_FIELD_IS_SET(field, "Field");
491 BT_ASSERT_PRE_FIELD_IS_SIGNED_INT(field, "Field");
492 return int_field->value.i;
493}
494
495void bt_field_signed_integer_set_value(struct bt_field *field, int64_t value)
496{
497 struct bt_field_integer *int_field = (void *) field;
498
499 BT_ASSERT_PRE_NON_NULL(field, "Field");
500 BT_ASSERT_PRE_FIELD_IS_SIGNED_INT(field, "Field");
501 BT_ASSERT_PRE_FIELD_HOT(field, "Field");
502 BT_ASSERT_PRE(bt_util_value_is_in_range_signed(
503 ((struct bt_field_class_integer *) field->class)->range, value),
504 "Value is out of bounds: value=%" PRId64 ", %![field-]+f, "
505 "%![fc-]+F", value, field, field->class);
506 int_field->value.i = value;
507 bt_field_set_single(field, true);
508}
509
510uint64_t bt_field_unsigned_integer_get_value(const struct bt_field *field)
511{
512 const struct bt_field_integer *int_field = (const void *) field;
513
514 BT_ASSERT_PRE_NON_NULL(field, "Field");
515 BT_ASSERT_PRE_FIELD_IS_SET(field, "Field");
516 BT_ASSERT_PRE_FIELD_IS_UNSIGNED_INT(field, "Field");
517 return int_field->value.u;
518}
519
520void bt_field_unsigned_integer_set_value(struct bt_field *field, uint64_t value)
521{
522 struct bt_field_integer *int_field = (void *) field;
523
524 BT_ASSERT_PRE_NON_NULL(field, "Field");
525 BT_ASSERT_PRE_FIELD_IS_UNSIGNED_INT(field, "Field");
526 BT_ASSERT_PRE_FIELD_HOT(field, "Field");
527 BT_ASSERT_PRE(bt_util_value_is_in_range_unsigned(
528 ((struct bt_field_class_integer *) field->class)->range, value),
529 "Value is out of bounds: value=%" PRIu64 ", %![field-]+f, "
530 "%![fc-]+F", value, field, field->class);
531 int_field->value.u = value;
532 bt_field_set_single(field, true);
533}
534
535double bt_field_real_get_value(const struct bt_field *field)
536{
537 const struct bt_field_real *real_field = (const void *) field;
538
539 BT_ASSERT_PRE_NON_NULL(field, "Field");
540 BT_ASSERT_PRE_FIELD_IS_SET(field, "Field");
541 BT_ASSERT_PRE_FIELD_HAS_CLASS_TYPE(field, BT_FIELD_CLASS_TYPE_REAL, "Field");
542 return real_field->value;
543}
544
545void bt_field_real_set_value(struct bt_field *field, double value)
546{
547 struct bt_field_real *real_field = (void *) field;
548
549 BT_ASSERT_PRE_NON_NULL(field, "Field");
550 BT_ASSERT_PRE_FIELD_HAS_CLASS_TYPE(field, BT_FIELD_CLASS_TYPE_REAL, "Field");
551 BT_ASSERT_PRE_FIELD_HOT(field, "Field");
552 BT_ASSERT_PRE(
553 !((struct bt_field_class_real *) field->class)->is_single_precision ||
554 (double) (float) value == value,
555 "Invalid value for a single-precision real number: value=%f, "
556 "%![fc-]+F", value, field->class);
557 real_field->value = value;
558 bt_field_set_single(field, true);
559}
560
561int bt_field_unsigned_enumeration_get_mapping_labels(
562 const struct bt_field *field,
563 bt_field_class_enumeration_mapping_label_array *label_array,
564 uint64_t *count)
565{
566 const struct bt_field_integer *int_field = (const void *) field;
567
568 BT_ASSERT_PRE_NON_NULL(field, "Field");
569 BT_ASSERT_PRE_NON_NULL(label_array, "Label array (output)");
570 BT_ASSERT_PRE_NON_NULL(label_array, "Count (output)");
571 BT_ASSERT_PRE_FIELD_IS_SET(field, "Field");
572 BT_ASSERT_PRE_FIELD_HAS_CLASS_TYPE(field,
573 BT_FIELD_CLASS_TYPE_UNSIGNED_ENUMERATION, "Field");
574 return bt_field_class_unsigned_enumeration_get_mapping_labels_by_value(
575 field->class, int_field->value.u, label_array, count);
576}
577
578int bt_field_signed_enumeration_get_mapping_labels(
579 const struct bt_field *field,
580 bt_field_class_enumeration_mapping_label_array *label_array,
581 uint64_t *count)
582{
583 const struct bt_field_integer *int_field = (const void *) field;
584
585 BT_ASSERT_PRE_NON_NULL(field, "Field");
586 BT_ASSERT_PRE_NON_NULL(label_array, "Label array (output)");
587 BT_ASSERT_PRE_NON_NULL(label_array, "Count (output)");
588 BT_ASSERT_PRE_FIELD_IS_SET(field, "Field");
589 BT_ASSERT_PRE_FIELD_HAS_CLASS_TYPE(field,
590 BT_FIELD_CLASS_TYPE_SIGNED_ENUMERATION, "Field");
591 return bt_field_class_signed_enumeration_get_mapping_labels_by_value(
592 field->class, int_field->value.i, label_array, count);
593}
594
595const char *bt_field_string_get_value(const struct bt_field *field)
596{
597 const struct bt_field_string *string_field = (const void *) field;
598
599 BT_ASSERT_PRE_NON_NULL(field, "Field");
600 BT_ASSERT_PRE_FIELD_IS_SET(field, "Field");
601 BT_ASSERT_PRE_FIELD_HAS_CLASS_TYPE(field, BT_FIELD_CLASS_TYPE_STRING,
602 "Field");
603 return (const char *) string_field->buf->data;
604}
605
606uint64_t bt_field_string_get_length(const struct bt_field *field)
607{
608 const struct bt_field_string *string_field = (const void *) field;
609
610 BT_ASSERT_PRE_NON_NULL(field, "Field");
611 BT_ASSERT_PRE_FIELD_IS_SET(field, "Field");
612 BT_ASSERT_PRE_FIELD_HAS_CLASS_TYPE(field, BT_FIELD_CLASS_TYPE_STRING,
613 "Field");
614 return string_field->length;
615}
616
617int bt_field_string_set_value(struct bt_field *field, const char *value)
618{
619 BT_ASSERT_PRE_NON_NULL(field, "Field");
620 BT_ASSERT_PRE_NON_NULL(value, "Value");
621 BT_ASSERT_PRE_FIELD_HOT(field, "Field");
622 BT_ASSERT_PRE_FIELD_HAS_CLASS_TYPE(field, BT_FIELD_CLASS_TYPE_STRING,
623 "Field");
624 bt_field_string_clear(field);
625 return bt_field_string_append_with_length(field, value,
626 (uint64_t) strlen(value));
627}
628
629int bt_field_string_append(struct bt_field *field, const char *value)
630{
631 return bt_field_string_append_with_length(field,
632 value, (uint64_t) strlen(value));
633}
634
635int bt_field_string_append_with_length(struct bt_field *field,
636 const char *value, uint64_t length)
637{
638 struct bt_field_string *string_field = (void *) field;
639 char *data;
640 uint64_t new_length;
641
642 BT_ASSERT_PRE_NON_NULL(field, "Field");
643 BT_ASSERT_PRE_NON_NULL(value, "Value");
644 BT_ASSERT_PRE_FIELD_HOT(field, "Field");
645 BT_ASSERT_PRE_FIELD_HAS_CLASS_TYPE(field,
646 BT_FIELD_CLASS_TYPE_STRING, "Field");
647
648 /* Make sure no null bytes are appended */
649 BT_ASSERT_PRE(memchr(value, '\0', length) == NULL,
650 "String value to append contains a null character: "
651 "partial-value=\"%.32s\", length=%" PRIu64, value, length);
652
653 new_length = length + string_field->length;
654
655 if (unlikely(new_length + 1 > string_field->buf->len)) {
656 g_array_set_size(string_field->buf, new_length + 1);
657 }
658
659 data = string_field->buf->data;
660 memcpy(data + string_field->length, value, length);
661 ((char *) string_field->buf->data)[new_length] = '\0';
662 string_field->length = new_length;
663 bt_field_set_single(field, true);
664 return 0;
665}
666
667int bt_field_string_clear(struct bt_field *field)
668{
669 struct bt_field_string *string_field = (void *) field;
670
671 BT_ASSERT_PRE_NON_NULL(field, "Field");
672 BT_ASSERT_PRE_FIELD_HOT(field, "Field");
673 BT_ASSERT_PRE_FIELD_HAS_CLASS_TYPE(field,
674 BT_FIELD_CLASS_TYPE_STRING, "Field");
675 string_field->length = 0;
676 bt_field_set_single(field, true);
677 return 0;
678}
679
680uint64_t bt_field_array_get_length(const struct bt_field *field)
681{
682 const struct bt_field_array *array_field = (const void *) field;
683
684 BT_ASSERT_PRE_NON_NULL(field, "Field");
685 BT_ASSERT_PRE_FIELD_IS_ARRAY(field, "Field");
686 return array_field->length;
687}
688
689int bt_field_dynamic_array_set_length(struct bt_field *field, uint64_t length)
690{
691 int ret = 0;
692 struct bt_field_array *array_field = (void *) field;
693
694 BT_ASSERT_PRE_NON_NULL(field, "Field");
695 BT_ASSERT_PRE_FIELD_HAS_CLASS_TYPE(field,
696 BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY, "Field");
697 BT_ASSERT_PRE_FIELD_HOT(field, "Field");
698
699 if (unlikely(length > array_field->fields->len)) {
700 /* Make more room */
701 struct bt_field_class_array *array_fc;
702 uint64_t cur_len = array_field->fields->len;
703 uint64_t i;
704
705 g_ptr_array_set_size(array_field->fields, length);
706 array_fc = (void *) field->class;
707
708 for (i = cur_len; i < array_field->fields->len; i++) {
709 struct bt_field *elem_field = bt_field_create(
710 array_fc->element_fc);
711
712 if (!elem_field) {
713 BT_LIB_LOGE("Cannot create element field for "
714 "dynamic array field: "
715 "index=%" PRIu64 ", "
716 "%![array-field-]+f", i, field);
717 ret = -1;
718 goto end;
719 }
720
721 BT_ASSERT(!array_field->fields->pdata[i]);
722 array_field->fields->pdata[i] = elem_field;
723 }
724 }
725
726 array_field->length = length;
727
728end:
729 return ret;
730}
731
732static inline
733struct bt_field *borrow_array_field_element_field_by_index(
734 struct bt_field *field, uint64_t index)
735{
736 struct bt_field_array *array_field = (void *) field;
737
738 BT_ASSERT_PRE_NON_NULL(field, "Field");
739 BT_ASSERT_PRE_FIELD_IS_ARRAY(field, "Field");
740 BT_ASSERT_PRE_VALID_INDEX(index, array_field->length);
741 return array_field->fields->pdata[index];
742}
743
744struct bt_field *bt_field_array_borrow_element_field_by_index(
745 struct bt_field *field, uint64_t index)
746{
747 return borrow_array_field_element_field_by_index(field, index);
748}
749
750const struct bt_field *
751bt_field_array_borrow_element_field_by_index_const(
752 const struct bt_field *field, uint64_t index)
753{
754 return borrow_array_field_element_field_by_index((void *) field, index);
755}
756
757static inline
758struct bt_field *borrow_structure_field_member_field_by_index(
759 struct bt_field *field, uint64_t index)
760{
761 struct bt_field_structure *struct_field = (void *) field;
762
763 BT_ASSERT_PRE_NON_NULL(field, "Field");
764 BT_ASSERT_PRE_FIELD_HAS_CLASS_TYPE(field,
765 BT_FIELD_CLASS_TYPE_STRUCTURE, "Field");
766 BT_ASSERT_PRE_VALID_INDEX(index, struct_field->fields->len);
767 return struct_field->fields->pdata[index];
768}
769
770struct bt_field *bt_field_structure_borrow_member_field_by_index(
771 struct bt_field *field, uint64_t index)
772{
773 return borrow_structure_field_member_field_by_index(field,
774 index);
775}
776
777const struct bt_field *
778bt_field_structure_borrow_member_field_by_index_const(
779 const struct bt_field *field, uint64_t index)
780{
781 return borrow_structure_field_member_field_by_index(
782 (void *) field, index);
783}
784
785static inline
786struct bt_field *borrow_structure_field_member_field_by_name(
787 struct bt_field *field, const char *name)
788{
789 struct bt_field *ret_field = NULL;
790 struct bt_field_class_structure *struct_fc;
791 struct bt_field_structure *struct_field = (void *) field;
792 gpointer orig_key;
793 gpointer index;
794
795 BT_ASSERT_PRE_NON_NULL(field, "Field");
796 BT_ASSERT_PRE_NON_NULL(name, "Field name");
797 BT_ASSERT_PRE_FIELD_HAS_CLASS_TYPE(field,
798 BT_FIELD_CLASS_TYPE_STRUCTURE, "Field");
799 struct_fc = (void *) field->class;
800
801 if (!g_hash_table_lookup_extended(struct_fc->common.name_to_index, name,
802 &orig_key, &index)) {
803 goto end;
804 }
805
806 ret_field = struct_field->fields->pdata[GPOINTER_TO_UINT(index)];
807 BT_ASSERT(ret_field);
808
809end:
810 return ret_field;
811}
812
813struct bt_field *bt_field_structure_borrow_member_field_by_name(
814 struct bt_field *field, const char *name)
815{
816 return borrow_structure_field_member_field_by_name(field, name);
817}
818
819const struct bt_field *bt_field_structure_borrow_member_field_by_name_const(
820 const struct bt_field *field, const char *name)
821{
822 return borrow_structure_field_member_field_by_name(
823 (void *) field, name);
824}
825
826static inline
827struct bt_field *borrow_variant_field_selected_option_field(
828 struct bt_field *field)
829{
830 struct bt_field_variant *var_field = (void *) field;
831
832 BT_ASSERT_PRE_NON_NULL(field, "Field");
833 BT_ASSERT_PRE_FIELD_HAS_CLASS_TYPE(field,
834 BT_FIELD_CLASS_TYPE_VARIANT, "Field");
835 BT_ASSERT_PRE(var_field->selected_field,
836 "Variant field has no selected field: %!+f", field);
837 return var_field->selected_field;
838}
839
840struct bt_field *bt_field_variant_borrow_selected_option_field(
841 struct bt_field *field)
842{
843 return borrow_variant_field_selected_option_field(field);
844}
845
846const struct bt_field *bt_field_variant_borrow_selected_option_field_const(
847 const struct bt_field *field)
848{
849 return borrow_variant_field_selected_option_field((void *) field);
850}
851
852int bt_field_variant_select_option_field(
853 struct bt_field *field, uint64_t index)
854{
855 struct bt_field_variant *var_field = (void *) field;
856
857 BT_ASSERT_PRE_NON_NULL(field, "Field");
858 BT_ASSERT_PRE_FIELD_HAS_CLASS_TYPE(field,
859 BT_FIELD_CLASS_TYPE_VARIANT, "Field");
860 BT_ASSERT_PRE_FIELD_HOT(field, "Field");
861 BT_ASSERT_PRE_VALID_INDEX(index, var_field->fields->len);
862 var_field->selected_field = var_field->fields->pdata[index];
863 var_field->selected_index = index;
864 return 0;
865}
866
867uint64_t bt_field_variant_get_selected_option_field_index(
868 const struct bt_field *field)
869{
870 const struct bt_field_variant *var_field = (const void *) field;
871
872 BT_ASSERT_PRE_NON_NULL(field, "Field");
873 BT_ASSERT_PRE_FIELD_HAS_CLASS_TYPE(field,
874 BT_FIELD_CLASS_TYPE_VARIANT, "Field");
875 BT_ASSERT_PRE(var_field->selected_field,
876 "Variant field has no selected field: %!+f", field);
877 return var_field->selected_index;
878}
879
880static inline
881void bt_field_finalize(struct bt_field *field)
882{
883 BT_ASSERT(field);
884 BT_LOGD_STR("Putting field's class.");
885 BT_OBJECT_PUT_REF_AND_RESET(field->class);
886}
887
888static
889void destroy_integer_field(struct bt_field *field)
890{
891 BT_ASSERT(field);
892 BT_LIB_LOGD("Destroying integer field object: %!+f", field);
893 bt_field_finalize(field);
894 g_free(field);
895}
896
897static
898void destroy_real_field(struct bt_field *field)
899{
900 BT_ASSERT(field);
901 BT_LIB_LOGD("Destroying real field object: %!+f", field);
902 bt_field_finalize(field);
903 g_free(field);
904}
905
906static
907void destroy_structure_field(struct bt_field *field)
908{
909 struct bt_field_structure *struct_field = (void *) field;
910
911 BT_ASSERT(field);
912 BT_LIB_LOGD("Destroying structure field object: %!+f", field);
913 bt_field_finalize(field);
914
915 if (struct_field->fields) {
916 g_ptr_array_free(struct_field->fields, TRUE);
917 struct_field->fields = NULL;
918 }
919
920 g_free(field);
921}
922
923static
924void destroy_variant_field(struct bt_field *field)
925{
926 struct bt_field_variant *var_field = (void *) field;
927
928 BT_ASSERT(field);
929 BT_LIB_LOGD("Destroying variant field object: %!+f", field);
930 bt_field_finalize(field);
931
932 if (var_field->fields) {
933 g_ptr_array_free(var_field->fields, TRUE);
934 var_field->fields = NULL;
935 }
936
937 g_free(field);
938}
939
940static
941void destroy_array_field(struct bt_field *field)
942{
943 struct bt_field_array *array_field = (void *) field;
944
945 BT_ASSERT(field);
946 BT_LIB_LOGD("Destroying array field object: %!+f", field);
947 bt_field_finalize(field);
948
949 if (array_field->fields) {
950 g_ptr_array_free(array_field->fields, TRUE);
951 array_field->fields = NULL;
952 }
953
954 g_free(field);
955}
956
957static
958void destroy_string_field(struct bt_field *field)
959{
960 struct bt_field_string *string_field = (void *) field;
961
962 BT_ASSERT(field);
963 BT_LIB_LOGD("Destroying string field object: %!+f", field);
964 bt_field_finalize(field);
965
966 if (string_field->buf) {
967 g_array_free(string_field->buf, TRUE);
968 string_field->buf = NULL;
969 }
970
971 g_free(field);
972}
973
974BT_HIDDEN
975void bt_field_destroy(struct bt_field *field)
976{
977 BT_ASSERT(field);
978 BT_ASSERT(bt_field_class_has_known_type(field->class));
979 field_destroy_funcs[field->class->type](field);
980}
981
982static
983void reset_single_field(struct bt_field *field)
984{
985 BT_ASSERT(field);
986 field->is_set = false;
987}
988
989static
990void reset_structure_field(struct bt_field *field)
991{
992 uint64_t i;
993 struct bt_field_structure *struct_field = (void *) field;
994
995 BT_ASSERT(field);
996
997 for (i = 0; i < struct_field->fields->len; i++) {
998 bt_field_reset(struct_field->fields->pdata[i]);
999 }
1000}
1001
1002static
1003void reset_variant_field(struct bt_field *field)
1004{
1005 uint64_t i;
1006 struct bt_field_variant *var_field = (void *) field;
1007
1008 BT_ASSERT(field);
1009
1010 for (i = 0; i < var_field->fields->len; i++) {
1011 bt_field_reset(var_field->fields->pdata[i]);
1012 }
1013}
1014
1015static
1016void reset_array_field(struct bt_field *field)
1017{
1018 uint64_t i;
1019 struct bt_field_array *array_field = (void *) field;
1020
1021 BT_ASSERT(field);
1022
1023 for (i = 0; i < array_field->fields->len; i++) {
1024 bt_field_reset(array_field->fields->pdata[i]);
1025 }
1026}
1027
1028static
1029void set_single_field_is_frozen(struct bt_field *field, bool is_frozen)
1030{
1031 field->frozen = is_frozen;
1032}
1033
1034static
1035void set_structure_field_is_frozen(struct bt_field *field, bool is_frozen)
1036{
1037 uint64_t i;
1038 struct bt_field_structure *struct_field = (void *) field;
1039
1040 BT_LIB_LOGD("Setting structure field's frozen state: "
1041 "%![field-]+f, is-frozen=%d", field, is_frozen);
1042
1043 for (i = 0; i < struct_field->fields->len; i++) {
1044 struct bt_field *member_field = struct_field->fields->pdata[i];
1045
1046 BT_LIB_LOGD("Setting structure field's member field's "
1047 "frozen state: %![field-]+f, index=%" PRIu64,
1048 member_field, i);
1049 bt_field_set_is_frozen(member_field, is_frozen);
1050 }
1051
1052 set_single_field_is_frozen(field, is_frozen);
1053}
1054
1055static
1056void set_variant_field_is_frozen(struct bt_field *field, bool is_frozen)
1057{
1058 uint64_t i;
1059 struct bt_field_variant *var_field = (void *) field;
1060
1061 BT_LIB_LOGD("Setting variant field's frozen state: "
1062 "%![field-]+f, is-frozen=%d", field, is_frozen);
1063
1064 for (i = 0; i < var_field->fields->len; i++) {
1065 struct bt_field *option_field = var_field->fields->pdata[i];
1066
1067 BT_LIB_LOGD("Setting variant field's option field's "
1068 "frozen state: %![field-]+f, index=%" PRIu64,
1069 option_field, i);
1070 bt_field_set_is_frozen(option_field, is_frozen);
1071 }
1072
1073 set_single_field_is_frozen(field, is_frozen);
1074}
1075
1076static
1077void set_array_field_is_frozen(struct bt_field *field, bool is_frozen)
1078{
1079 uint64_t i;
1080 struct bt_field_array *array_field = (void *) field;
1081
1082 BT_LIB_LOGD("Setting array field's frozen state: "
1083 "%![field-]+f, is-frozen=%d", field, is_frozen);
1084
1085 for (i = 0; i < array_field->fields->len; i++) {
1086 struct bt_field *elem_field = array_field->fields->pdata[i];
1087
1088 BT_LIB_LOGD("Setting array field's element field's "
1089 "frozen state: %![field-]+f, index=%" PRIu64,
1090 elem_field, i);
1091 bt_field_set_is_frozen(elem_field, is_frozen);
1092 }
1093
1094 set_single_field_is_frozen(field, is_frozen);
1095}
1096
1097BT_HIDDEN
1098void _bt_field_set_is_frozen(const struct bt_field *field,
1099 bool is_frozen)
1100{
1101 BT_ASSERT(field);
1102 BT_LIB_LOGD("Setting field object's frozen state: %!+f, is-frozen=%d",
1103 field, is_frozen);
1104 BT_ASSERT(field->methods->set_is_frozen);
1105 field->methods->set_is_frozen((void *) field, is_frozen);
1106}
1107
1108static
1109bool single_field_is_set(const struct bt_field *field)
1110{
1111 BT_ASSERT(field);
1112 return field->is_set;
1113}
1114
1115static
1116bool structure_field_is_set(const struct bt_field *field)
1117{
1118 bool is_set = true;
1119 uint64_t i;
1120 const struct bt_field_structure *struct_field = (const void *) field;
1121
1122 BT_ASSERT(field);
1123
1124 for (i = 0; i < struct_field->fields->len; i++) {
1125 is_set = bt_field_is_set(struct_field->fields->pdata[i]);
1126 if (!is_set) {
1127 goto end;
1128 }
1129 }
1130
1131end:
1132 return is_set;
1133}
1134
1135static
1136bool variant_field_is_set(const struct bt_field *field)
1137{
1138 const struct bt_field_variant *var_field = (const void *) field;
1139 bool is_set = false;
1140
1141 BT_ASSERT(field);
1142
1143 if (var_field->selected_field) {
1144 is_set = bt_field_is_set(var_field->selected_field);
1145 }
1146
1147 return is_set;
1148}
1149
1150static
1151bool array_field_is_set(const struct bt_field *field)
1152{
1153 bool is_set = true;
1154 uint64_t i;
1155 const struct bt_field_array *array_field = (const void *) field;
1156
1157 BT_ASSERT(field);
1158
1159 for (i = 0; i < array_field->length; i++) {
1160 is_set = bt_field_is_set(array_field->fields->pdata[i]);
1161 if (!is_set) {
1162 goto end;
1163 }
1164 }
1165
1166end:
1167 return is_set;
1168}
BabelTrace - Trace Format Babel Tower
This page took 0.026808 seconds and 4 git commands to generate.