lib, bt2: rename "signed/unsigned sel." -> "integer signed/unsigned sel."
[babeltrace.git] / src / lib / trace-ir / field.c
CommitLineData
273b65be 1/*
f2b0325d 2 * Copyright 2017-2018 Philippe Proulx <pproulx@efficios.com>
de9dd397 3 * Copyright 2013, 2014 Jérémie Galarneau <jeremie.galarneau@efficios.com>
273b65be
JG
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
b03487ab 24#define BT_LOG_TAG "LIB/FIELD"
1633ef46 25#include "lib/logging.h"
fc25abce 26
57952005 27#include "lib/assert-pre.h"
71c5da58
MJ
28#include <babeltrace2/trace-ir/field.h>
29#include <babeltrace2/trace-ir/field-const.h>
57952005
MJ
30#include "lib/object.h"
31#include "compat/compiler.h"
32#include "compat/fcntl.h"
33#include "common/align.h"
34#include "common/assert.h"
fc25abce 35#include <inttypes.h>
273b65be 36
57952005
MJ
37#include "field.h"
38#include "field-class.h"
fb25b9e3 39#include "lib/func-status.h"
57952005 40
18acc6f8 41static
7b33a0e0 42void reset_single_field(struct bt_field *field);
18acc6f8
PP
43
44static
7b33a0e0 45void reset_array_field(struct bt_field *field);
18acc6f8
PP
46
47static
7b33a0e0 48void reset_structure_field(struct bt_field *field);
18acc6f8 49
247fa9e3
PP
50static
51void reset_option_field(struct bt_field *field);
52
18acc6f8 53static
7b33a0e0 54void reset_variant_field(struct bt_field *field);
18acc6f8
PP
55
56static
7b33a0e0 57void set_single_field_is_frozen(struct bt_field *field, bool is_frozen);
18acc6f8
PP
58
59static
7b33a0e0 60void set_array_field_is_frozen(struct bt_field *field, bool is_frozen);
18acc6f8
PP
61
62static
7b33a0e0 63void set_structure_field_is_frozen(struct bt_field *field, bool is_frozen);
18acc6f8 64
247fa9e3
PP
65static
66void set_option_field_is_frozen(struct bt_field *field, bool is_frozen);
67
18acc6f8 68static
7b33a0e0 69void set_variant_field_is_frozen(struct bt_field *field, bool is_frozen);
18acc6f8
PP
70
71static
78cf9df6 72bool single_field_is_set(const struct bt_field *field);
18acc6f8
PP
73
74static
78cf9df6 75bool array_field_is_set(const struct bt_field *field);
18acc6f8
PP
76
77static
78cf9df6 78bool structure_field_is_set(const struct bt_field *field);
18acc6f8 79
247fa9e3
PP
80static
81bool option_field_is_set(const struct bt_field *field);
82
18acc6f8 83static
78cf9df6 84bool variant_field_is_set(const struct bt_field *field);
18acc6f8 85
9414b439
PP
86static
87struct bt_field_methods bool_field_methods = {
88 .set_is_frozen = set_single_field_is_frozen,
89 .is_set = single_field_is_set,
90 .reset = reset_single_field,
91};
92
6943da6a
PP
93static
94struct bt_field_methods bit_array_field_methods = {
95 .set_is_frozen = set_single_field_is_frozen,
96 .is_set = single_field_is_set,
97 .reset = reset_single_field,
98};
99
18acc6f8 100static
7b33a0e0
PP
101struct bt_field_methods integer_field_methods = {
102 .set_is_frozen = set_single_field_is_frozen,
103 .is_set = single_field_is_set,
104 .reset = reset_single_field,
8deee039 105};
273b65be 106
7b33a0e0
PP
107static
108struct bt_field_methods real_field_methods = {
109 .set_is_frozen = set_single_field_is_frozen,
110 .is_set = single_field_is_set,
111 .reset = reset_single_field,
12c8a1a3
JG
112};
113
7b33a0e0
PP
114static
115struct bt_field_methods string_field_methods = {
116 .set_is_frozen = set_single_field_is_frozen,
117 .is_set = single_field_is_set,
118 .reset = reset_single_field,
273b65be
JG
119};
120
7b33a0e0
PP
121static
122struct bt_field_methods structure_field_methods = {
123 .set_is_frozen = set_structure_field_is_frozen,
124 .is_set = structure_field_is_set,
125 .reset = reset_structure_field,
87d43dc1
JG
126};
127
7b33a0e0
PP
128static
129struct bt_field_methods array_field_methods = {
130 .set_is_frozen = set_array_field_is_frozen,
131 .is_set = array_field_is_set,
132 .reset = reset_array_field,
918be005
PP
133};
134
247fa9e3
PP
135static
136struct bt_field_methods option_field_methods = {
137 .set_is_frozen = set_option_field_is_frozen,
138 .is_set = option_field_is_set,
139 .reset = reset_option_field,
140};
141
76f869ab 142static
7b33a0e0
PP
143struct bt_field_methods variant_field_methods = {
144 .set_is_frozen = set_variant_field_is_frozen,
145 .is_set = variant_field_is_set,
146 .reset = reset_variant_field,
147};
76f869ab 148
9414b439
PP
149static
150struct bt_field *create_bool_field(struct bt_field_class *);
151
6943da6a
PP
152static
153struct bt_field *create_bit_array_field(struct bt_field_class *);
154
8deee039 155static
939190b3 156struct bt_field *create_integer_field(struct bt_field_class *);
8deee039
PP
157
158static
939190b3 159struct bt_field *create_real_field(struct bt_field_class *);
8deee039
PP
160
161static
939190b3 162struct bt_field *create_string_field(struct bt_field_class *);
8deee039
PP
163
164static
939190b3 165struct bt_field *create_structure_field(struct bt_field_class *);
8deee039 166static
939190b3 167struct bt_field *create_static_array_field(struct bt_field_class *);
8b45963b 168
8deee039 169static
939190b3 170struct bt_field *create_dynamic_array_field(struct bt_field_class *);
8b45963b 171
247fa9e3
PP
172static
173struct bt_field *create_option_field(struct bt_field_class *);
174
8deee039 175static
939190b3 176struct bt_field *create_variant_field(struct bt_field_class *);
8b45963b 177
8deee039 178static
939190b3 179struct bt_field *(* const field_create_funcs[])(struct bt_field_class *) = {
467673c1
PP
180 [BT_FIELD_CLASS_TYPE_BOOL] = create_bool_field,
181 [BT_FIELD_CLASS_TYPE_BIT_ARRAY] = create_bit_array_field,
182 [BT_FIELD_CLASS_TYPE_UNSIGNED_INTEGER] = create_integer_field,
183 [BT_FIELD_CLASS_TYPE_SIGNED_INTEGER] = create_integer_field,
184 [BT_FIELD_CLASS_TYPE_UNSIGNED_ENUMERATION] = create_integer_field,
185 [BT_FIELD_CLASS_TYPE_SIGNED_ENUMERATION] = create_integer_field,
186 [BT_FIELD_CLASS_TYPE_SINGLE_PRECISION_REAL] = create_real_field,
187 [BT_FIELD_CLASS_TYPE_DOUBLE_PRECISION_REAL] = create_real_field,
188 [BT_FIELD_CLASS_TYPE_STRING] = create_string_field,
189 [BT_FIELD_CLASS_TYPE_STRUCTURE] = create_structure_field,
190 [BT_FIELD_CLASS_TYPE_STATIC_ARRAY] = create_static_array_field,
191 [BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY] = create_dynamic_array_field,
192 [BT_FIELD_CLASS_TYPE_OPTION_WITHOUT_SELECTOR] = create_option_field,
193 [BT_FIELD_CLASS_TYPE_OPTION_WITH_BOOL_SELECTOR] = create_option_field,
194 [BT_FIELD_CLASS_TYPE_OPTION_WITH_UNSIGNED_INTEGER_SELECTOR] = create_option_field,
195 [BT_FIELD_CLASS_TYPE_OPTION_WITH_SIGNED_INTEGER_SELECTOR] = create_option_field,
196 [BT_FIELD_CLASS_TYPE_VARIANT_WITHOUT_SELECTOR] = create_variant_field,
0822832b
PP
197 [BT_FIELD_CLASS_TYPE_VARIANT_WITH_UNSIGNED_INTEGER_SELECTOR] = create_variant_field,
198 [BT_FIELD_CLASS_TYPE_VARIANT_WITH_SIGNED_INTEGER_SELECTOR] = create_variant_field,
8deee039 199};
8b45963b 200
9414b439
PP
201static
202void destroy_bool_field(struct bt_field *field);
203
6943da6a
PP
204static
205void destroy_bit_array_field(struct bt_field *field);
206
a6918753 207static
7b33a0e0 208void destroy_integer_field(struct bt_field *field);
a6918753
PP
209
210static
7b33a0e0 211void destroy_real_field(struct bt_field *field);
a6918753
PP
212
213static
7b33a0e0 214void destroy_string_field(struct bt_field *field);
a6918753
PP
215
216static
7b33a0e0 217void destroy_structure_field(struct bt_field *field);
a6918753
PP
218
219static
7b33a0e0 220void destroy_array_field(struct bt_field *field);
a6918753 221
247fa9e3
PP
222static
223void destroy_option_field(struct bt_field *field);
224
a6918753 225static
7b33a0e0 226void destroy_variant_field(struct bt_field *field);
a6918753
PP
227
228static
229void (* const field_destroy_funcs[])(struct bt_field *) = {
467673c1
PP
230 [BT_FIELD_CLASS_TYPE_BOOL] = destroy_bool_field,
231 [BT_FIELD_CLASS_TYPE_BIT_ARRAY] = destroy_bit_array_field,
232 [BT_FIELD_CLASS_TYPE_UNSIGNED_INTEGER] = destroy_integer_field,
233 [BT_FIELD_CLASS_TYPE_SIGNED_INTEGER] = destroy_integer_field,
234 [BT_FIELD_CLASS_TYPE_UNSIGNED_ENUMERATION] = destroy_integer_field,
235 [BT_FIELD_CLASS_TYPE_SIGNED_ENUMERATION] = destroy_integer_field,
236 [BT_FIELD_CLASS_TYPE_SINGLE_PRECISION_REAL] = destroy_real_field,
237 [BT_FIELD_CLASS_TYPE_DOUBLE_PRECISION_REAL] = destroy_real_field,
238 [BT_FIELD_CLASS_TYPE_STRING] = destroy_string_field,
239 [BT_FIELD_CLASS_TYPE_STRUCTURE] = destroy_structure_field,
240 [BT_FIELD_CLASS_TYPE_STATIC_ARRAY] = destroy_array_field,
241 [BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY] = destroy_array_field,
242 [BT_FIELD_CLASS_TYPE_OPTION_WITHOUT_SELECTOR] = destroy_option_field,
243 [BT_FIELD_CLASS_TYPE_OPTION_WITH_BOOL_SELECTOR] = destroy_option_field,
244 [BT_FIELD_CLASS_TYPE_OPTION_WITH_UNSIGNED_INTEGER_SELECTOR] = destroy_option_field,
245 [BT_FIELD_CLASS_TYPE_OPTION_WITH_SIGNED_INTEGER_SELECTOR] = destroy_option_field,
246 [BT_FIELD_CLASS_TYPE_VARIANT_WITHOUT_SELECTOR] = destroy_variant_field,
0822832b
PP
247 [BT_FIELD_CLASS_TYPE_VARIANT_WITH_UNSIGNED_INTEGER_SELECTOR] = destroy_variant_field,
248 [BT_FIELD_CLASS_TYPE_VARIANT_WITH_SIGNED_INTEGER_SELECTOR] = destroy_variant_field,
a6918753
PP
249};
250
844d5df6 251struct bt_field_class *bt_field_borrow_class(struct bt_field *field)
18acc6f8 252{
fa6cfec3 253 BT_ASSERT_PRE_DEV_NON_NULL(field, "Field");
939190b3 254 return field->class;
18acc6f8
PP
255}
256
78cf9df6
PP
257const struct bt_field_class *bt_field_borrow_class_const(
258 const struct bt_field *field)
9e550e5f 259{
fa6cfec3 260 BT_ASSERT_PRE_DEV_NON_NULL(field, "Field");
78cf9df6 261 return field->class;
9e550e5f
PP
262}
263
78cf9df6 264enum bt_field_class_type bt_field_get_class_type(const struct bt_field *field)
18acc6f8 265{
fa6cfec3 266 BT_ASSERT_PRE_DEV_NON_NULL(field, "Field");
af0c18e3 267 return field->class->type;
18acc6f8
PP
268}
269
a6918753 270BT_HIDDEN
939190b3 271struct bt_field *bt_field_create(struct bt_field_class *fc)
273b65be 272{
839d52a5 273 struct bt_field *field = NULL;
7b33a0e0 274
fa6cfec3 275 BT_ASSERT(fc);
af0c18e3 276 field = field_create_funcs[fc->type](fc);
273b65be 277 if (!field) {
a8f90e5d 278 BT_LIB_LOGE_APPEND_CAUSE("Cannot create field object from field class: "
939190b3 279 "%![fc-]+F", fc);
8deee039 280 goto end;
273b65be
JG
281 }
282
8deee039
PP
283end:
284 return field;
273b65be
JG
285}
286
7b33a0e0 287static inline
939190b3 288void init_field(struct bt_field *field, struct bt_field_class *fc,
7b33a0e0 289 struct bt_field_methods *methods)
cd95e351 290{
7b33a0e0 291 BT_ASSERT(field);
939190b3 292 BT_ASSERT(fc);
7b33a0e0
PP
293 bt_object_init_unique(&field->base);
294 field->methods = methods;
4b70020d
PP
295 field->class = fc;
296 bt_object_get_no_null_check(fc);
cd95e351
JG
297}
298
9414b439
PP
299static
300struct bt_field *create_bool_field(struct bt_field_class *fc)
301{
302 struct bt_field_bool *bool_field;
303
304 BT_LIB_LOGD("Creating boolean field object: %![fc-]+F", fc);
305 bool_field = g_new0(struct bt_field_bool, 1);
306 if (!bool_field) {
307 BT_LIB_LOGE_APPEND_CAUSE(
308 "Failed to allocate one boolean field.");
309 goto end;
310 }
311
312 init_field((void *) bool_field, fc, &bool_field_methods);
313 BT_LIB_LOGD("Created boolean field object: %!+f", bool_field);
314
315end:
316 return (void *) bool_field;
317}
318
6943da6a
PP
319static
320struct bt_field *create_bit_array_field(struct bt_field_class *fc)
321{
322 struct bt_field_bit_array *ba_field;
323
324 BT_LIB_LOGD("Creating bit array field object: %![fc-]+F", fc);
325 ba_field = g_new0(struct bt_field_bit_array, 1);
326 if (!ba_field) {
327 BT_LIB_LOGE_APPEND_CAUSE(
328 "Failed to allocate one bit array field.");
329 goto end;
330 }
331
332 init_field((void *) ba_field, fc, &bit_array_field_methods);
333 BT_LIB_LOGD("Created bit array field object: %!+f", ba_field);
334
335end:
336 return (void *) ba_field;
337}
338
7b33a0e0 339static
939190b3 340struct bt_field *create_integer_field(struct bt_field_class *fc)
4ebcc695 341{
7b33a0e0
PP
342 struct bt_field_integer *int_field;
343
939190b3 344 BT_LIB_LOGD("Creating integer field object: %![fc-]+F", fc);
7b33a0e0
PP
345 int_field = g_new0(struct bt_field_integer, 1);
346 if (!int_field) {
a8f90e5d
PP
347 BT_LIB_LOGE_APPEND_CAUSE(
348 "Failed to allocate one integer field.");
7b33a0e0
PP
349 goto end;
350 }
351
939190b3 352 init_field((void *) int_field, fc, &integer_field_methods);
7b33a0e0
PP
353 BT_LIB_LOGD("Created integer field object: %!+f", int_field);
354
355end:
356 return (void *) int_field;
4ebcc695
PP
357}
358
7b33a0e0 359static
939190b3 360struct bt_field *create_real_field(struct bt_field_class *fc)
fea75608 361{
7b33a0e0 362 struct bt_field_real *real_field;
18acc6f8 363
939190b3 364 BT_LIB_LOGD("Creating real field object: %![fc-]+F", fc);
7b33a0e0
PP
365 real_field = g_new0(struct bt_field_real, 1);
366 if (!real_field) {
a8f90e5d 367 BT_LIB_LOGE_APPEND_CAUSE("Failed to allocate one real field.");
7b33a0e0
PP
368 goto end;
369 }
370
939190b3 371 init_field((void *) real_field, fc, &real_field_methods);
7b33a0e0
PP
372 BT_LIB_LOGD("Created real field object: %!+f", real_field);
373
374end:
375 return (void *) real_field;
fea75608
PP
376}
377
7b33a0e0 378static
939190b3 379struct bt_field *create_string_field(struct bt_field_class *fc)
273b65be 380{
7b33a0e0 381 struct bt_field_string *string_field;
18acc6f8 382
939190b3 383 BT_LIB_LOGD("Creating string field object: %![fc-]+F", fc);
7b33a0e0
PP
384 string_field = g_new0(struct bt_field_string, 1);
385 if (!string_field) {
a8f90e5d
PP
386 BT_LIB_LOGE_APPEND_CAUSE(
387 "Failed to allocate one string field.");
7b33a0e0
PP
388 goto end;
389 }
18acc6f8 390
939190b3 391 init_field((void *) string_field, fc, &string_field_methods);
7b33a0e0
PP
392 string_field->buf = g_array_sized_new(FALSE, FALSE,
393 sizeof(char), 1);
394 if (!string_field->buf) {
a8f90e5d 395 BT_LIB_LOGE_APPEND_CAUSE("Failed to allocate a GArray.");
8138bfe1 396 BT_OBJECT_PUT_REF_AND_RESET(string_field);
7b33a0e0
PP
397 goto end;
398 }
18acc6f8 399
7b33a0e0
PP
400 g_array_index(string_field->buf, char, 0) = '\0';
401 BT_LIB_LOGD("Created string field object: %!+f", string_field);
18acc6f8 402
7b33a0e0
PP
403end:
404 return (void *) string_field;
405}
18acc6f8 406
7b33a0e0 407static inline
939190b3
PP
408int create_fields_from_named_field_classes(
409 struct bt_field_class_named_field_class_container *fc,
7b33a0e0
PP
410 GPtrArray **fields)
411{
412 int ret = 0;
413 uint64_t i;
18acc6f8 414
7b33a0e0
PP
415 *fields = g_ptr_array_new_with_free_func(
416 (GDestroyNotify) bt_field_destroy);
417 if (!*fields) {
a8f90e5d 418 BT_LIB_LOGE_APPEND_CAUSE("Failed to allocate a GPtrArray.");
7b33a0e0
PP
419 ret = -1;
420 goto end;
18acc6f8
PP
421 }
422
939190b3 423 g_ptr_array_set_size(*fields, fc->named_fcs->len);
7b33a0e0 424
939190b3 425 for (i = 0; i < fc->named_fcs->len; i++) {
7b33a0e0 426 struct bt_field *field;
02b61fe0 427 struct bt_named_field_class *named_fc = fc->named_fcs->pdata[i];
7b33a0e0 428
939190b3 429 field = bt_field_create(named_fc->fc);
7b33a0e0 430 if (!field) {
a8f90e5d
PP
431 BT_LIB_LOGE_APPEND_CAUSE(
432 "Failed to create structure member or variant option field: "
939190b3
PP
433 "name=\"%s\", %![fc-]+F",
434 named_fc->name->str, named_fc->fc);
7b33a0e0
PP
435 ret = -1;
436 goto end;
437 }
438
439 g_ptr_array_index(*fields, i) = field;
440 }
18acc6f8
PP
441
442end:
443 return ret;
273b65be
JG
444}
445
7b33a0e0 446static
939190b3 447struct bt_field *create_structure_field(struct bt_field_class *fc)
cd95e351 448{
7b33a0e0 449 struct bt_field_structure *struct_field;
18acc6f8 450
939190b3 451 BT_LIB_LOGD("Creating structure field object: %![fc-]+F", fc);
7b33a0e0
PP
452 struct_field = g_new0(struct bt_field_structure, 1);
453 if (!struct_field) {
a8f90e5d
PP
454 BT_LIB_LOGE_APPEND_CAUSE(
455 "Failed to allocate one structure field.");
7b33a0e0
PP
456 goto end;
457 }
fc25abce 458
939190b3 459 init_field((void *) struct_field, fc, &structure_field_methods);
7b33a0e0 460
939190b3 461 if (create_fields_from_named_field_classes((void *) fc,
7b33a0e0 462 &struct_field->fields)) {
a8f90e5d
PP
463 BT_LIB_LOGE_APPEND_CAUSE(
464 "Cannot create structure member fields: %![fc-]+F", fc);
8138bfe1 465 BT_OBJECT_PUT_REF_AND_RESET(struct_field);
7b33a0e0 466 goto end;
18acc6f8
PP
467 }
468
7b33a0e0 469 BT_LIB_LOGD("Created structure field object: %!+f", struct_field);
18acc6f8 470
7b33a0e0
PP
471end:
472 return (void *) struct_field;
cd95e351
JG
473}
474
247fa9e3
PP
475static
476struct bt_field *create_option_field(struct bt_field_class *fc)
477{
478 struct bt_field_option *opt_field;
479 struct bt_field_class_option *opt_fc = (void *) fc;
480
481 BT_LIB_LOGD("Creating option field object: %![fc-]+F", fc);
482 opt_field = g_new0(struct bt_field_option, 1);
483 if (!opt_field) {
484 BT_LIB_LOGE_APPEND_CAUSE(
485 "Failed to allocate one option field.");
486 goto end;
487 }
488
489 init_field((void *) opt_field, fc, &option_field_methods);
490 opt_field->content_field = bt_field_create(opt_fc->content_fc);
491 if (!opt_field->content_field) {
492 BT_LIB_LOGE_APPEND_CAUSE(
493 "Failed to create option field's content field: "
494 "%![opt-fc-]+F, %![content-fc-]+F",
495 opt_fc, opt_fc->content_fc);
496 BT_OBJECT_PUT_REF_AND_RESET(opt_field);
497 goto end;
498 }
499
500 BT_LIB_LOGD("Created option field object: %!+f", opt_field);
501
502end:
503 return (void *) opt_field;
504}
505
7b33a0e0 506static
939190b3 507struct bt_field *create_variant_field(struct bt_field_class *fc)
273b65be 508{
7b33a0e0 509 struct bt_field_variant *var_field;
18acc6f8 510
939190b3 511 BT_LIB_LOGD("Creating variant field object: %![fc-]+F", fc);
7b33a0e0
PP
512 var_field = g_new0(struct bt_field_variant, 1);
513 if (!var_field) {
a8f90e5d
PP
514 BT_LIB_LOGE_APPEND_CAUSE(
515 "Failed to allocate one variant field.");
7b33a0e0
PP
516 goto end;
517 }
8b45963b 518
939190b3 519 init_field((void *) var_field, fc, &variant_field_methods);
18acc6f8 520
939190b3 521 if (create_fields_from_named_field_classes((void *) fc,
7b33a0e0 522 &var_field->fields)) {
a8f90e5d 523 BT_LIB_LOGE_APPEND_CAUSE("Cannot create variant member fields: "
939190b3 524 "%![fc-]+F", fc);
8138bfe1 525 BT_OBJECT_PUT_REF_AND_RESET(var_field);
7b33a0e0
PP
526 goto end;
527 }
273b65be 528
7b33a0e0 529 BT_LIB_LOGD("Created variant field object: %!+f", var_field);
18acc6f8 530
7b33a0e0
PP
531end:
532 return (void *) var_field;
18acc6f8
PP
533}
534
535static inline
7b33a0e0 536int init_array_field_fields(struct bt_field_array *array_field)
18acc6f8
PP
537{
538 int ret = 0;
7b33a0e0 539 uint64_t i;
939190b3 540 struct bt_field_class_array *array_fc;
18acc6f8 541
7b33a0e0 542 BT_ASSERT(array_field);
939190b3 543 array_fc = (void *) array_field->common.class;
7b33a0e0
PP
544 array_field->fields = g_ptr_array_sized_new(array_field->length);
545 if (!array_field->fields) {
a8f90e5d 546 BT_LIB_LOGE_APPEND_CAUSE("Failed to allocate a GPtrArray.");
18acc6f8
PP
547 ret = -1;
548 goto end;
549 }
550
7b33a0e0
PP
551 g_ptr_array_set_free_func(array_field->fields,
552 (GDestroyNotify) bt_field_destroy);
553 g_ptr_array_set_size(array_field->fields, array_field->length);
554
555 for (i = 0; i < array_field->length; i++) {
556 array_field->fields->pdata[i] = bt_field_create(
939190b3 557 array_fc->element_fc);
7b33a0e0 558 if (!array_field->fields->pdata[i]) {
a8f90e5d
PP
559 BT_LIB_LOGE_APPEND_CAUSE(
560 "Cannot create array field's element field: "
939190b3 561 "index=%" PRIu64 ", %![fc-]+F", i, array_fc);
7b33a0e0
PP
562 ret = -1;
563 goto end;
564 }
565 }
18acc6f8
PP
566
567end:
568 return ret;
3f4a108d
PP
569}
570
7b33a0e0 571static
939190b3 572struct bt_field *create_static_array_field(struct bt_field_class *fc)
f78d67fb 573{
60bbfc7c 574 struct bt_field_class_array_static *array_fc = (void *) fc;
7b33a0e0 575 struct bt_field_array *array_field;
a6918753 576
939190b3 577 BT_LIB_LOGD("Creating static array field object: %![fc-]+F", fc);
7b33a0e0
PP
578 array_field = g_new0(struct bt_field_array, 1);
579 if (!array_field) {
a8f90e5d
PP
580 BT_LIB_LOGE_APPEND_CAUSE(
581 "Failed to allocate one static array field.");
7b33a0e0
PP
582 goto end;
583 }
f78d67fb 584
939190b3
PP
585 init_field((void *) array_field, fc, &array_field_methods);
586 array_field->length = array_fc->length;
18acc6f8 587
7b33a0e0 588 if (init_array_field_fields(array_field)) {
a8f90e5d 589 BT_LIB_LOGE_APPEND_CAUSE("Cannot create static array fields: "
939190b3 590 "%![fc-]+F", fc);
8138bfe1 591 BT_OBJECT_PUT_REF_AND_RESET(array_field);
7b33a0e0
PP
592 goto end;
593 }
a6918753 594
7b33a0e0 595 BT_LIB_LOGD("Created static array field object: %!+f", array_field);
18acc6f8 596
7b33a0e0
PP
597end:
598 return (void *) array_field;
273b65be
JG
599}
600
7b33a0e0 601static
939190b3 602struct bt_field *create_dynamic_array_field(struct bt_field_class *fc)
cd95e351 603{
7b33a0e0 604 struct bt_field_array *array_field;
a6918753 605
939190b3 606 BT_LIB_LOGD("Creating dynamic array field object: %![fc-]+F", fc);
7b33a0e0
PP
607 array_field = g_new0(struct bt_field_array, 1);
608 if (!array_field) {
a8f90e5d
PP
609 BT_LIB_LOGE_APPEND_CAUSE(
610 "Failed to allocate one dynamic array field.");
7b33a0e0
PP
611 goto end;
612 }
613
939190b3 614 init_field((void *) array_field, fc, &array_field_methods);
7b33a0e0
PP
615
616 if (init_array_field_fields(array_field)) {
a8f90e5d 617 BT_LIB_LOGE_APPEND_CAUSE("Cannot create dynamic array fields: "
939190b3 618 "%![fc-]+F", fc);
8138bfe1 619 BT_OBJECT_PUT_REF_AND_RESET(array_field);
7b33a0e0 620 goto end;
18acc6f8
PP
621 }
622
7b33a0e0
PP
623 BT_LIB_LOGD("Created dynamic array field object: %!+f", array_field);
624
625end:
626 return (void *) array_field;
a6918753
PP
627}
628
9414b439
PP
629bt_bool bt_field_bool_get_value(const struct bt_field *field)
630{
631 const struct bt_field_bool *bool_field = (const void *) field;
632
633 BT_ASSERT_PRE_DEV_NON_NULL(field, "Field");
634 BT_ASSERT_PRE_DEV_FIELD_IS_SET(field, "Field");
635 BT_ASSERT_PRE_DEV_FIELD_HAS_CLASS_TYPE(field, BT_FIELD_CLASS_TYPE_BOOL,
636 "Field");
637 return (bt_bool) bool_field->value;
638}
639
640void bt_field_bool_set_value(struct bt_field *field, bt_bool value)
641{
642 struct bt_field_bool *bool_field = (void *) field;
643
644 BT_ASSERT_PRE_DEV_NON_NULL(field, "Field");
645 BT_ASSERT_PRE_DEV_FIELD_HAS_CLASS_TYPE(field, BT_FIELD_CLASS_TYPE_BOOL,
646 "Field");
647 BT_ASSERT_PRE_DEV_FIELD_HOT(field, "Field");
648 bool_field->value = (bool) value;
649 bt_field_set_single(field, true);
650}
651
6943da6a
PP
652uint64_t bt_field_bit_array_get_value_as_integer(const struct bt_field *field)
653{
654 const struct bt_field_bit_array *ba_field = (const void *) field;
655
656 BT_ASSERT_PRE_DEV_NON_NULL(field, "Field");
657 BT_ASSERT_PRE_DEV_FIELD_IS_SET(field, "Field");
658 BT_ASSERT_PRE_DEV_FIELD_HAS_CLASS_TYPE(field,
659 BT_FIELD_CLASS_TYPE_BIT_ARRAY, "Field");
660 return ba_field->value_as_int;
661}
662
663void bt_field_bit_array_set_value_as_integer(struct bt_field *field,
664 uint64_t value)
665{
666 struct bt_field_bit_array *ba_field = (void *) field;
667 struct bt_field_class_bit_array *ba_fc;
668
669 BT_ASSERT_PRE_DEV_NON_NULL(field, "Field");
670 BT_ASSERT_PRE_DEV_FIELD_HAS_CLASS_TYPE(field,
671 BT_FIELD_CLASS_TYPE_BIT_ARRAY, "Field");
672 BT_ASSERT_PRE_DEV_FIELD_HOT(field, "Field");
673 ba_fc = (void *) field->class;
674 ba_field->value_as_int = value;
675
676 if (ba_fc->length < 64) {
677 /* Apply mask */
678 ba_field->value_as_int &= ((UINT64_C(1) << ba_fc->length) - 1);
679 }
680
681 bt_field_set_single(field, true);
682}
683
60bbfc7c 684int64_t bt_field_integer_signed_get_value(const struct bt_field *field)
a6918753 685{
78cf9df6 686 const struct bt_field_integer *int_field = (const void *) field;
a6918753 687
fa6cfec3
PP
688 BT_ASSERT_PRE_DEV_NON_NULL(field, "Field");
689 BT_ASSERT_PRE_DEV_FIELD_IS_SET(field, "Field");
690 BT_ASSERT_PRE_DEV_FIELD_IS_SIGNED_INT(field, "Field");
7b33a0e0 691 return int_field->value.i;
cd95e351
JG
692}
693
60bbfc7c 694void bt_field_integer_signed_set_value(struct bt_field *field, int64_t value)
cd95e351 695{
7b33a0e0 696 struct bt_field_integer *int_field = (void *) field;
a6918753 697
fa6cfec3
PP
698 BT_ASSERT_PRE_DEV_NON_NULL(field, "Field");
699 BT_ASSERT_PRE_DEV_FIELD_IS_SIGNED_INT(field, "Field");
700 BT_ASSERT_PRE_DEV_FIELD_HOT(field, "Field");
701 BT_ASSERT_PRE_DEV(bt_util_value_is_in_range_signed(
939190b3 702 ((struct bt_field_class_integer *) field->class)->range, value),
7b33a0e0 703 "Value is out of bounds: value=%" PRId64 ", %![field-]+f, "
939190b3 704 "%![fc-]+F", value, field, field->class);
7b33a0e0
PP
705 int_field->value.i = value;
706 bt_field_set_single(field, true);
cd95e351
JG
707}
708
60bbfc7c 709uint64_t bt_field_integer_unsigned_get_value(const struct bt_field *field)
273b65be 710{
78cf9df6 711 const struct bt_field_integer *int_field = (const void *) field;
7b33a0e0 712
fa6cfec3
PP
713 BT_ASSERT_PRE_DEV_NON_NULL(field, "Field");
714 BT_ASSERT_PRE_DEV_FIELD_IS_SET(field, "Field");
715 BT_ASSERT_PRE_DEV_FIELD_IS_UNSIGNED_INT(field, "Field");
7b33a0e0 716 return int_field->value.u;
273b65be
JG
717}
718
60bbfc7c 719void bt_field_integer_unsigned_set_value(struct bt_field *field, uint64_t value)
cd95e351 720{
7b33a0e0 721 struct bt_field_integer *int_field = (void *) field;
a6918753 722
fa6cfec3
PP
723 BT_ASSERT_PRE_DEV_NON_NULL(field, "Field");
724 BT_ASSERT_PRE_DEV_FIELD_IS_UNSIGNED_INT(field, "Field");
725 BT_ASSERT_PRE_DEV_FIELD_HOT(field, "Field");
726 BT_ASSERT_PRE_DEV(bt_util_value_is_in_range_unsigned(
939190b3 727 ((struct bt_field_class_integer *) field->class)->range, value),
7b33a0e0 728 "Value is out of bounds: value=%" PRIu64 ", %![field-]+f, "
939190b3 729 "%![fc-]+F", value, field, field->class);
7b33a0e0
PP
730 int_field->value.u = value;
731 bt_field_set_single(field, true);
cd95e351
JG
732}
733
76276a81
FD
734float bt_field_real_single_precision_get_value(const struct bt_field *field)
735{
736 const struct bt_field_real *real_field = (const void *) field;
737
738 BT_ASSERT_PRE_DEV_NON_NULL(field, "Field");
739 BT_ASSERT_PRE_DEV_FIELD_IS_SET(field, "Field");
740 BT_ASSERT_PRE_DEV_FIELD_HAS_CLASS_TYPE(field,
741 BT_FIELD_CLASS_TYPE_SINGLE_PRECISION_REAL, "Field");
742 return (float) real_field->value;
743}
744
745double bt_field_real_double_precision_get_value(const struct bt_field *field)
273b65be 746{
78cf9df6 747 const struct bt_field_real *real_field = (const void *) field;
7b33a0e0 748
fa6cfec3
PP
749 BT_ASSERT_PRE_DEV_NON_NULL(field, "Field");
750 BT_ASSERT_PRE_DEV_FIELD_IS_SET(field, "Field");
76276a81
FD
751 BT_ASSERT_PRE_DEV_FIELD_HAS_CLASS_TYPE(field,
752 BT_FIELD_CLASS_TYPE_DOUBLE_PRECISION_REAL, "Field");
753
7b33a0e0 754 return real_field->value;
8b45963b
PP
755}
756
76276a81
FD
757void bt_field_real_single_precision_set_value(struct bt_field *field,
758 float value)
8b45963b 759{
7b33a0e0 760 struct bt_field_real *real_field = (void *) field;
18acc6f8 761
fa6cfec3 762 BT_ASSERT_PRE_DEV_NON_NULL(field, "Field");
76276a81
FD
763 BT_ASSERT_PRE_DEV_FIELD_HAS_CLASS_TYPE(field,
764 BT_FIELD_CLASS_TYPE_SINGLE_PRECISION_REAL, "Field");
fa6cfec3 765 BT_ASSERT_PRE_DEV_FIELD_HOT(field, "Field");
76276a81
FD
766
767 real_field->value = (double) value;
768 bt_field_set_single(field, true);
769}
770
771void bt_field_real_double_precision_set_value(struct bt_field *field,
772 double value)
773{
774 struct bt_field_real *real_field = (void *) field;
775
776 BT_ASSERT_PRE_DEV_NON_NULL(field, "Field");
777 BT_ASSERT_PRE_DEV_FIELD_HAS_CLASS_TYPE(field,
778 BT_FIELD_CLASS_TYPE_DOUBLE_PRECISION_REAL, "Field");
779 BT_ASSERT_PRE_DEV_FIELD_HOT(field, "Field");
780
7b33a0e0
PP
781 real_field->value = value;
782 bt_field_set_single(field, true);
783}
784
fb25b9e3 785enum bt_field_enumeration_get_mapping_labels_status
60bbfc7c 786bt_field_enumeration_unsigned_get_mapping_labels(
78cf9df6 787 const struct bt_field *field,
939190b3 788 bt_field_class_enumeration_mapping_label_array *label_array,
7b33a0e0
PP
789 uint64_t *count)
790{
78cf9df6 791 const struct bt_field_integer *int_field = (const void *) field;
7b33a0e0 792
fa6cfec3
PP
793 BT_ASSERT_PRE_DEV_NON_NULL(field, "Field");
794 BT_ASSERT_PRE_DEV_NON_NULL(label_array, "Label array (output)");
795 BT_ASSERT_PRE_DEV_NON_NULL(label_array, "Count (output)");
796 BT_ASSERT_PRE_DEV_FIELD_IS_SET(field, "Field");
797 BT_ASSERT_PRE_DEV_FIELD_HAS_CLASS_TYPE(field,
af0c18e3 798 BT_FIELD_CLASS_TYPE_UNSIGNED_ENUMERATION, "Field");
937c4e48 799 return (int)
60bbfc7c 800 bt_field_class_enumeration_unsigned_get_mapping_labels_for_value(
937c4e48 801 field->class, int_field->value.u, label_array, count);
273b65be
JG
802}
803
fb25b9e3 804enum bt_field_enumeration_get_mapping_labels_status
60bbfc7c 805bt_field_enumeration_signed_get_mapping_labels(
78cf9df6 806 const struct bt_field *field,
939190b3 807 bt_field_class_enumeration_mapping_label_array *label_array,
7b33a0e0 808 uint64_t *count)
cd95e351 809{
78cf9df6 810 const struct bt_field_integer *int_field = (const void *) field;
18acc6f8 811
fa6cfec3
PP
812 BT_ASSERT_PRE_DEV_NON_NULL(field, "Field");
813 BT_ASSERT_PRE_DEV_NON_NULL(label_array, "Label array (output)");
814 BT_ASSERT_PRE_DEV_NON_NULL(label_array, "Count (output)");
815 BT_ASSERT_PRE_DEV_FIELD_IS_SET(field, "Field");
816 BT_ASSERT_PRE_DEV_FIELD_HAS_CLASS_TYPE(field,
af0c18e3 817 BT_FIELD_CLASS_TYPE_SIGNED_ENUMERATION, "Field");
937c4e48 818 return (int)
60bbfc7c 819 bt_field_class_enumeration_signed_get_mapping_labels_for_value(
937c4e48 820 field->class, int_field->value.i, label_array, count);
8b45963b 821}
fc25abce 822
78cf9df6 823const char *bt_field_string_get_value(const struct bt_field *field)
8b45963b 824{
78cf9df6 825 const struct bt_field_string *string_field = (const void *) field;
7b33a0e0 826
fa6cfec3
PP
827 BT_ASSERT_PRE_DEV_NON_NULL(field, "Field");
828 BT_ASSERT_PRE_DEV_FIELD_IS_SET(field, "Field");
829 BT_ASSERT_PRE_DEV_FIELD_HAS_CLASS_TYPE(field, BT_FIELD_CLASS_TYPE_STRING,
7b33a0e0
PP
830 "Field");
831 return (const char *) string_field->buf->data;
832}
833
78cf9df6 834uint64_t bt_field_string_get_length(const struct bt_field *field)
7b33a0e0 835{
78cf9df6 836 const struct bt_field_string *string_field = (const void *) field;
18acc6f8 837
fa6cfec3
PP
838 BT_ASSERT_PRE_DEV_NON_NULL(field, "Field");
839 BT_ASSERT_PRE_DEV_FIELD_IS_SET(field, "Field");
840 BT_ASSERT_PRE_DEV_FIELD_HAS_CLASS_TYPE(field, BT_FIELD_CLASS_TYPE_STRING,
7b33a0e0
PP
841 "Field");
842 return string_field->length;
cd95e351
JG
843}
844
937c4e48
PP
845static inline
846void clear_string_field(struct bt_field *field)
847{
848 struct bt_field_string *string_field = (void *) field;
849
850 BT_ASSERT(field);
851 string_field->length = 0;
852 bt_field_set_single(field, true);
853}
854
fb25b9e3
PP
855enum bt_field_string_set_value_status bt_field_string_set_value(
856 struct bt_field *field, const char *value)
273b65be 857{
fa6cfec3
PP
858 BT_ASSERT_PRE_DEV_NON_NULL(field, "Field");
859 BT_ASSERT_PRE_DEV_NON_NULL(value, "Value");
860 BT_ASSERT_PRE_DEV_FIELD_HOT(field, "Field");
861 BT_ASSERT_PRE_DEV_FIELD_HAS_CLASS_TYPE(field, BT_FIELD_CLASS_TYPE_STRING,
7b33a0e0 862 "Field");
937c4e48 863 clear_string_field(field);
fb25b9e3 864 return (int) bt_field_string_append_with_length(field, value,
7b33a0e0 865 (uint64_t) strlen(value));
273b65be
JG
866}
867
fb25b9e3
PP
868enum bt_field_string_append_status bt_field_string_append(
869 struct bt_field *field, const char *value)
cd95e351 870{
78cf9df6 871 return bt_field_string_append_with_length(field,
9e550e5f 872 value, (uint64_t) strlen(value));
cd95e351
JG
873}
874
fb25b9e3
PP
875enum bt_field_string_append_status bt_field_string_append_with_length(
876 struct bt_field *field, const char *value, uint64_t length)
273b65be 877{
18acc6f8
PP
878 struct bt_field_string *string_field = (void *) field;
879 char *data;
7b33a0e0 880 uint64_t new_length;
273b65be 881
fa6cfec3
PP
882 BT_ASSERT_PRE_DEV_NON_NULL(field, "Field");
883 BT_ASSERT_PRE_DEV_NON_NULL(value, "Value");
884 BT_ASSERT_PRE_DEV_FIELD_HOT(field, "Field");
885 BT_ASSERT_PRE_DEV_FIELD_HAS_CLASS_TYPE(field,
af0c18e3 886 BT_FIELD_CLASS_TYPE_STRING, "Field");
a6918753 887
18acc6f8 888 /* Make sure no null bytes are appended */
8e01f2d9 889 BT_ASSERT_PRE_DEV(!memchr(value, '\0', length),
18acc6f8 890 "String value to append contains a null character: "
7b33a0e0 891 "partial-value=\"%.32s\", length=%" PRIu64, value, length);
c6f9c5a3 892
7b33a0e0 893 new_length = length + string_field->length;
18acc6f8 894
85e7137b 895 if (G_UNLIKELY(new_length + 1 > string_field->buf->len)) {
7b33a0e0 896 g_array_set_size(string_field->buf, new_length + 1);
c6f9c5a3
PP
897 }
898
18acc6f8 899 data = string_field->buf->data;
7b33a0e0
PP
900 memcpy(data + string_field->length, value, length);
901 ((char *) string_field->buf->data)[new_length] = '\0';
902 string_field->length = new_length;
903 bt_field_set_single(field, true);
fb25b9e3 904 return BT_FUNC_STATUS_OK;
18acc6f8 905}
8deee039 906
fb25b9e3 907void bt_field_string_clear(struct bt_field *field)
18acc6f8 908{
fa6cfec3
PP
909 BT_ASSERT_PRE_DEV_NON_NULL(field, "Field");
910 BT_ASSERT_PRE_DEV_FIELD_HOT(field, "Field");
911 BT_ASSERT_PRE_DEV_FIELD_HAS_CLASS_TYPE(field,
af0c18e3 912 BT_FIELD_CLASS_TYPE_STRING, "Field");
937c4e48 913 clear_string_field(field);
18acc6f8
PP
914}
915
78cf9df6 916uint64_t bt_field_array_get_length(const struct bt_field *field)
18acc6f8 917{
78cf9df6 918 const struct bt_field_array *array_field = (const void *) field;
c6f9c5a3 919
fa6cfec3
PP
920 BT_ASSERT_PRE_DEV_NON_NULL(field, "Field");
921 BT_ASSERT_PRE_DEV_FIELD_IS_ARRAY(field, "Field");
7b33a0e0 922 return array_field->length;
8deee039 923}
f98c6554 924
60bbfc7c 925enum bt_field_array_dynamic_set_length_status bt_field_array_dynamic_set_length(
fb25b9e3 926 struct bt_field *field, uint64_t length)
8deee039 927{
fb25b9e3 928 int ret = BT_FUNC_STATUS_OK;
7b33a0e0 929 struct bt_field_array *array_field = (void *) field;
f98c6554 930
fa6cfec3
PP
931 BT_ASSERT_PRE_DEV_NON_NULL(field, "Field");
932 BT_ASSERT_PRE_DEV_FIELD_HAS_CLASS_TYPE(field,
af0c18e3 933 BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY, "Field");
fa6cfec3 934 BT_ASSERT_PRE_DEV_FIELD_HOT(field, "Field");
273b65be 935
85e7137b 936 if (G_UNLIKELY(length > array_field->fields->len)) {
7b33a0e0 937 /* Make more room */
939190b3 938 struct bt_field_class_array *array_fc;
7b33a0e0
PP
939 uint64_t cur_len = array_field->fields->len;
940 uint64_t i;
18acc6f8 941
7b33a0e0 942 g_ptr_array_set_size(array_field->fields, length);
939190b3 943 array_fc = (void *) field->class;
18acc6f8 944
7b33a0e0
PP
945 for (i = cur_len; i < array_field->fields->len; i++) {
946 struct bt_field *elem_field = bt_field_create(
939190b3 947 array_fc->element_fc);
273b65be 948
7b33a0e0 949 if (!elem_field) {
a8f90e5d
PP
950 BT_LIB_LOGE_APPEND_CAUSE(
951 "Cannot create element field for "
7b33a0e0
PP
952 "dynamic array field: "
953 "index=%" PRIu64 ", "
954 "%![array-field-]+f", i, field);
fb25b9e3 955 ret = BT_FUNC_STATUS_MEMORY_ERROR;
7b33a0e0
PP
956 goto end;
957 }
9be89173 958
7b33a0e0
PP
959 BT_ASSERT(!array_field->fields->pdata[i]);
960 array_field->fields->pdata[i] = elem_field;
9be89173 961 }
9be89173
JG
962 }
963
7b33a0e0 964 array_field->length = length;
8deee039 965
273b65be 966end:
9be89173 967 return ret;
273b65be
JG
968}
969
78cf9df6
PP
970static inline
971struct bt_field *borrow_array_field_element_field_by_index(
7b33a0e0 972 struct bt_field *field, uint64_t index)
a6918753 973{
7b33a0e0 974 struct bt_field_array *array_field = (void *) field;
a6918753 975
fa6cfec3
PP
976 BT_ASSERT_PRE_DEV_NON_NULL(field, "Field");
977 BT_ASSERT_PRE_DEV_FIELD_IS_ARRAY(field, "Field");
978 BT_ASSERT_PRE_DEV_VALID_INDEX(index, array_field->length);
7b33a0e0 979 return array_field->fields->pdata[index];
a6918753
PP
980}
981
78cf9df6
PP
982struct bt_field *bt_field_array_borrow_element_field_by_index(
983 struct bt_field *field, uint64_t index)
9e550e5f 984{
78cf9df6 985 return borrow_array_field_element_field_by_index(field, index);
9e550e5f
PP
986}
987
78cf9df6
PP
988const struct bt_field *
989bt_field_array_borrow_element_field_by_index_const(
990 const struct bt_field *field, uint64_t index)
991{
992 return borrow_array_field_element_field_by_index((void *) field, index);
993}
994
995static inline
996struct bt_field *borrow_structure_field_member_field_by_index(
7b33a0e0 997 struct bt_field *field, uint64_t index)
e42dd763 998{
7b33a0e0 999 struct bt_field_structure *struct_field = (void *) field;
e42dd763 1000
fa6cfec3
PP
1001 BT_ASSERT_PRE_DEV_NON_NULL(field, "Field");
1002 BT_ASSERT_PRE_DEV_FIELD_HAS_CLASS_TYPE(field,
af0c18e3 1003 BT_FIELD_CLASS_TYPE_STRUCTURE, "Field");
fa6cfec3 1004 BT_ASSERT_PRE_DEV_VALID_INDEX(index, struct_field->fields->len);
7b33a0e0 1005 return struct_field->fields->pdata[index];
e42dd763
PP
1006}
1007
78cf9df6
PP
1008struct bt_field *bt_field_structure_borrow_member_field_by_index(
1009 struct bt_field *field, uint64_t index)
1010{
1011 return borrow_structure_field_member_field_by_index(field,
1012 index);
1013}
1014
1015const struct bt_field *
1016bt_field_structure_borrow_member_field_by_index_const(
1017 const struct bt_field *field, uint64_t index)
9e550e5f 1018{
78cf9df6 1019 return borrow_structure_field_member_field_by_index(
9e550e5f
PP
1020 (void *) field, index);
1021}
1022
78cf9df6
PP
1023static inline
1024struct bt_field *borrow_structure_field_member_field_by_name(
7b33a0e0 1025 struct bt_field *field, const char *name)
273b65be 1026{
7b33a0e0 1027 struct bt_field *ret_field = NULL;
939190b3 1028 struct bt_field_class_structure *struct_fc;
7b33a0e0
PP
1029 struct bt_field_structure *struct_field = (void *) field;
1030 gpointer orig_key;
1031 gpointer index;
fc25abce 1032
fa6cfec3
PP
1033 BT_ASSERT_PRE_DEV_NON_NULL(field, "Field");
1034 BT_ASSERT_PRE_DEV_NON_NULL(name, "Field name");
1035 BT_ASSERT_PRE_DEV_FIELD_HAS_CLASS_TYPE(field,
af0c18e3 1036 BT_FIELD_CLASS_TYPE_STRUCTURE, "Field");
939190b3 1037 struct_fc = (void *) field->class;
a6918753 1038
939190b3 1039 if (!g_hash_table_lookup_extended(struct_fc->common.name_to_index, name,
7b33a0e0 1040 &orig_key, &index)) {
a6918753 1041 goto end;
fc25abce
PP
1042 }
1043
7b33a0e0
PP
1044 ret_field = struct_field->fields->pdata[GPOINTER_TO_UINT(index)];
1045 BT_ASSERT(ret_field);
a6918753
PP
1046
1047end:
7b33a0e0 1048 return ret_field;
273b65be
JG
1049}
1050
78cf9df6
PP
1051struct bt_field *bt_field_structure_borrow_member_field_by_name(
1052 struct bt_field *field, const char *name)
1053{
1054 return borrow_structure_field_member_field_by_name(field, name);
1055}
1056
1057const struct bt_field *bt_field_structure_borrow_member_field_by_name_const(
1058 const struct bt_field *field, const char *name)
9e550e5f 1059{
78cf9df6 1060 return borrow_structure_field_member_field_by_name(
9e550e5f
PP
1061 (void *) field, name);
1062}
1063
247fa9e3
PP
1064void bt_field_option_set_has_field(struct bt_field *field, bt_bool has_field)
1065{
1066 struct bt_field_option *opt_field = (void *) field;
1067
1068 BT_ASSERT_PRE_DEV_NON_NULL(field, "Field");
467673c1 1069 BT_ASSERT_PRE_DEV_FIELD_IS_OPTION(field, "Field");
247fa9e3
PP
1070 BT_ASSERT_PRE_DEV_FIELD_HOT(field, "Field");
1071
1072 if (has_field) {
1073 opt_field->selected_field = opt_field->content_field;
1074 } else {
1075 opt_field->selected_field = NULL;
1076 }
1077}
1078
1079struct bt_field *bt_field_option_borrow_field(struct bt_field *field)
1080{
1081 struct bt_field_option *opt_field = (void *) field;
1082
1083 BT_ASSERT_PRE_DEV_NON_NULL(field, "Field");
467673c1 1084 BT_ASSERT_PRE_DEV_FIELD_IS_OPTION(field, "Field");
247fa9e3
PP
1085 return opt_field->selected_field;
1086}
1087
1088const struct bt_field *bt_field_option_borrow_field_const(
1089 const struct bt_field *field)
1090{
1091 return (const void *) bt_field_option_borrow_field((void *) field);
1092}
1093
78cf9df6
PP
1094static inline
1095struct bt_field *borrow_variant_field_selected_option_field(
7b33a0e0 1096 struct bt_field *field)
273b65be 1097{
7b33a0e0 1098 struct bt_field_variant *var_field = (void *) field;
273b65be 1099
fa6cfec3 1100 BT_ASSERT_PRE_DEV_NON_NULL(field, "Field");
02b61fe0 1101 BT_ASSERT_PRE_DEV_FIELD_IS_VARIANT(field, "Field");
fa6cfec3 1102 BT_ASSERT_PRE_DEV(var_field->selected_field,
7b33a0e0
PP
1103 "Variant field has no selected field: %!+f", field);
1104 return var_field->selected_field;
273b65be
JG
1105}
1106
78cf9df6
PP
1107struct bt_field *bt_field_variant_borrow_selected_option_field(
1108 struct bt_field *field)
1109{
1110 return borrow_variant_field_selected_option_field(field);
1111}
1112
1113const struct bt_field *bt_field_variant_borrow_selected_option_field_const(
1114 const struct bt_field *field)
273b65be 1115{
78cf9df6 1116 return borrow_variant_field_selected_option_field((void *) field);
9e550e5f
PP
1117}
1118
02b61fe0
PP
1119static
1120const struct bt_field_class_variant_option *
1121borrow_variant_field_selected_class_option(const struct bt_field *field)
1122{
1123 const struct bt_field_class_named_field_class_container *container_fc;
1124 const struct bt_field_variant *var_field = (const void *) field;
1125
1126 BT_ASSERT(field);
1127 BT_ASSERT_PRE_DEV(var_field->selected_field,
1128 "Variant field has no selected field: %!+f", field);
1129 container_fc = (const void *) field->class;
1130 return container_fc->named_fcs->pdata[var_field->selected_index];
1131}
1132
1133const struct bt_field_class_variant_option *
1134bt_field_variant_borrow_selected_class_option_const(
1135 const struct bt_field *field)
1136{
1137 BT_ASSERT_PRE_DEV_NON_NULL(field, "Field");
1138 BT_ASSERT_PRE_DEV_FIELD_IS_VARIANT(field, "Field");
1139 return borrow_variant_field_selected_class_option(field);
1140}
1141
0822832b
PP
1142const struct bt_field_class_variant_with_selector_integer_unsigned_option *
1143bt_field_variant_with_unsigned_integer_selector_borrow_selected_class_option_const(
02b61fe0
PP
1144 const struct bt_field *field)
1145{
1146 BT_ASSERT_PRE_DEV_NON_NULL(field, "Field");
1147 BT_ASSERT_PRE_DEV_FIELD_HAS_CLASS_TYPE(field,
0822832b 1148 BT_FIELD_CLASS_TYPE_VARIANT_WITH_UNSIGNED_INTEGER_SELECTOR, "Field");
02b61fe0
PP
1149 return (const void *) borrow_variant_field_selected_class_option(field);
1150}
1151
0822832b
PP
1152const struct bt_field_class_variant_with_selector_integer_signed_option *
1153bt_field_variant_with_signed_integer_selector_borrow_selected_class_option_const(
02b61fe0
PP
1154 const struct bt_field *field)
1155{
1156 BT_ASSERT_PRE_DEV_NON_NULL(field, "Field");
1157 BT_ASSERT_PRE_DEV_FIELD_HAS_CLASS_TYPE(field,
0822832b 1158 BT_FIELD_CLASS_TYPE_VARIANT_WITH_SIGNED_INTEGER_SELECTOR, "Field");
02b61fe0
PP
1159 return (const void *) borrow_variant_field_selected_class_option(field);
1160}
1161
1162enum bt_field_variant_select_option_field_by_index_status
1163bt_field_variant_select_option_field_by_index(
78cf9df6 1164 struct bt_field *field, uint64_t index)
9e550e5f 1165{
7b33a0e0 1166 struct bt_field_variant *var_field = (void *) field;
fc25abce 1167
fa6cfec3 1168 BT_ASSERT_PRE_DEV_NON_NULL(field, "Field");
02b61fe0 1169 BT_ASSERT_PRE_DEV_FIELD_IS_VARIANT(field, "Field");
fa6cfec3
PP
1170 BT_ASSERT_PRE_DEV_FIELD_HOT(field, "Field");
1171 BT_ASSERT_PRE_DEV_VALID_INDEX(index, var_field->fields->len);
7b33a0e0
PP
1172 var_field->selected_field = var_field->fields->pdata[index];
1173 var_field->selected_index = index;
fb25b9e3 1174 return BT_FUNC_STATUS_OK;
273b65be
JG
1175}
1176
7b33a0e0 1177uint64_t bt_field_variant_get_selected_option_field_index(
78cf9df6 1178 const struct bt_field *field)
a6918753 1179{
78cf9df6 1180 const struct bt_field_variant *var_field = (const void *) field;
a6918753 1181
fa6cfec3 1182 BT_ASSERT_PRE_DEV_NON_NULL(field, "Field");
02b61fe0 1183 BT_ASSERT_PRE_DEV_FIELD_IS_VARIANT(field, "Field");
fa6cfec3 1184 BT_ASSERT_PRE_DEV(var_field->selected_field,
7b33a0e0
PP
1185 "Variant field has no selected field: %!+f", field);
1186 return var_field->selected_index;
a6918753
PP
1187}
1188
7b33a0e0
PP
1189static inline
1190void bt_field_finalize(struct bt_field *field)
273b65be 1191{
7b33a0e0 1192 BT_ASSERT(field);
939190b3 1193 BT_LOGD_STR("Putting field's class.");
1248f5ea 1194 BT_OBJECT_PUT_REF_AND_RESET(field->class);
273b65be
JG
1195}
1196
9414b439
PP
1197static
1198void destroy_bool_field(struct bt_field *field)
1199{
1200 BT_ASSERT(field);
1201 BT_LIB_LOGD("Destroying boolean field object: %!+f", field);
1202 bt_field_finalize(field);
1203 g_free(field);
1204}
1205
6943da6a
PP
1206static
1207void destroy_bit_array_field(struct bt_field *field)
1208{
1209 BT_ASSERT(field);
1210 BT_LIB_LOGD("Destroying bit array field object: %!+f", field);
1211 bt_field_finalize(field);
1212 g_free(field);
1213}
1214
273b65be 1215static
7b33a0e0 1216void destroy_integer_field(struct bt_field *field)
273b65be 1217{
7b33a0e0
PP
1218 BT_ASSERT(field);
1219 BT_LIB_LOGD("Destroying integer field object: %!+f", field);
1220 bt_field_finalize(field);
1221 g_free(field);
273b65be
JG
1222}
1223
18acc6f8 1224static
7b33a0e0 1225void destroy_real_field(struct bt_field *field)
273b65be 1226{
7b33a0e0
PP
1227 BT_ASSERT(field);
1228 BT_LIB_LOGD("Destroying real field object: %!+f", field);
1229 bt_field_finalize(field);
1230 g_free(field);
273b65be
JG
1231}
1232
18acc6f8 1233static
7b33a0e0 1234void destroy_structure_field(struct bt_field *field)
273b65be 1235{
7b33a0e0 1236 struct bt_field_structure *struct_field = (void *) field;
273b65be 1237
8b45963b 1238 BT_ASSERT(field);
7b33a0e0
PP
1239 BT_LIB_LOGD("Destroying structure field object: %!+f", field);
1240 bt_field_finalize(field);
8b45963b 1241
7b33a0e0
PP
1242 if (struct_field->fields) {
1243 g_ptr_array_free(struct_field->fields, TRUE);
1248f5ea 1244 struct_field->fields = NULL;
273b65be 1245 }
8b45963b 1246
7b33a0e0 1247 g_free(field);
273b65be
JG
1248}
1249
247fa9e3
PP
1250static
1251void destroy_option_field(struct bt_field *field)
1252{
1253 struct bt_field_option *opt_field = (void *) field;
1254
1255 BT_ASSERT(field);
1256 BT_LIB_LOGD("Destroying option field object: %!+f", field);
1257 bt_field_finalize(field);
1258
1259 if (opt_field->content_field) {
1260 bt_field_destroy(opt_field->content_field);
1261 }
1262
1263 g_free(field);
1264}
1265
18acc6f8 1266static
7b33a0e0 1267void destroy_variant_field(struct bt_field *field)
273b65be 1268{
7b33a0e0 1269 struct bt_field_variant *var_field = (void *) field;
273b65be 1270
8b45963b 1271 BT_ASSERT(field);
7b33a0e0
PP
1272 BT_LIB_LOGD("Destroying variant field object: %!+f", field);
1273 bt_field_finalize(field);
a6918753 1274
7b33a0e0
PP
1275 if (var_field->fields) {
1276 g_ptr_array_free(var_field->fields, TRUE);
1248f5ea 1277 var_field->fields = NULL;
fc25abce 1278 }
8b45963b 1279
7b33a0e0 1280 g_free(field);
273b65be
JG
1281}
1282
18acc6f8 1283static
7b33a0e0 1284void destroy_array_field(struct bt_field *field)
273b65be 1285{
7b33a0e0 1286 struct bt_field_array *array_field = (void *) field;
273b65be 1287
8b45963b 1288 BT_ASSERT(field);
7b33a0e0
PP
1289 BT_LIB_LOGD("Destroying array field object: %!+f", field);
1290 bt_field_finalize(field);
8deee039 1291
7b33a0e0
PP
1292 if (array_field->fields) {
1293 g_ptr_array_free(array_field->fields, TRUE);
1248f5ea 1294 array_field->fields = NULL;
273b65be 1295 }
8b45963b 1296
7b33a0e0 1297 g_free(field);
273b65be
JG
1298}
1299
18acc6f8 1300static
7b33a0e0 1301void destroy_string_field(struct bt_field *field)
273b65be 1302{
7b33a0e0 1303 struct bt_field_string *string_field = (void *) field;
273b65be 1304
8b45963b 1305 BT_ASSERT(field);
7b33a0e0
PP
1306 BT_LIB_LOGD("Destroying string field object: %!+f", field);
1307 bt_field_finalize(field);
8deee039 1308
7b33a0e0
PP
1309 if (string_field->buf) {
1310 g_array_free(string_field->buf, TRUE);
1248f5ea 1311 string_field->buf = NULL;
273b65be 1312 }
7b33a0e0
PP
1313
1314 g_free(field);
273b65be
JG
1315}
1316
7b33a0e0
PP
1317BT_HIDDEN
1318void bt_field_destroy(struct bt_field *field)
12c8a1a3 1319{
8b45963b 1320 BT_ASSERT(field);
af0c18e3 1321 field_destroy_funcs[field->class->type](field);
12c8a1a3
JG
1322}
1323
18acc6f8 1324static
7b33a0e0 1325void reset_single_field(struct bt_field *field)
12c8a1a3 1326{
8b45963b 1327 BT_ASSERT(field);
7b33a0e0 1328 field->is_set = false;
12c8a1a3
JG
1329}
1330
18acc6f8 1331static
7b33a0e0 1332void reset_structure_field(struct bt_field *field)
12c8a1a3 1333{
7b33a0e0
PP
1334 uint64_t i;
1335 struct bt_field_structure *struct_field = (void *) field;
12c8a1a3 1336
8b45963b 1337 BT_ASSERT(field);
7b33a0e0
PP
1338
1339 for (i = 0; i < struct_field->fields->len; i++) {
1340 bt_field_reset(struct_field->fields->pdata[i]);
1341 }
12c8a1a3
JG
1342}
1343
247fa9e3
PP
1344static
1345void reset_option_field(struct bt_field *field)
1346{
1347 struct bt_field_option *opt_field = (void *) field;
1348
1349 BT_ASSERT(opt_field);
1350 bt_field_reset(opt_field->content_field);
1351 opt_field->selected_field = NULL;
1352}
1353
18acc6f8 1354static
7b33a0e0 1355void reset_variant_field(struct bt_field *field)
12c8a1a3 1356{
7b33a0e0
PP
1357 uint64_t i;
1358 struct bt_field_variant *var_field = (void *) field;
12c8a1a3 1359
8b45963b 1360 BT_ASSERT(field);
8b45963b 1361
7b33a0e0
PP
1362 for (i = 0; i < var_field->fields->len; i++) {
1363 bt_field_reset(var_field->fields->pdata[i]);
12c8a1a3 1364 }
12c8a1a3
JG
1365}
1366
18acc6f8 1367static
7b33a0e0 1368void reset_array_field(struct bt_field *field)
12c8a1a3 1369{
a6918753 1370 uint64_t i;
7b33a0e0 1371 struct bt_field_array *array_field = (void *) field;
12c8a1a3 1372
8b45963b 1373 BT_ASSERT(field);
8b45963b 1374
7b33a0e0
PP
1375 for (i = 0; i < array_field->fields->len; i++) {
1376 bt_field_reset(array_field->fields->pdata[i]);
12c8a1a3 1377 }
12c8a1a3
JG
1378}
1379
18acc6f8 1380static
7b33a0e0 1381void set_single_field_is_frozen(struct bt_field *field, bool is_frozen)
918be005 1382{
a6918753 1383 field->frozen = is_frozen;
918be005
PP
1384}
1385
18acc6f8 1386static
7b33a0e0 1387void set_structure_field_is_frozen(struct bt_field *field, bool is_frozen)
918be005 1388{
a6918753 1389 uint64_t i;
7b33a0e0 1390 struct bt_field_structure *struct_field = (void *) field;
918be005 1391
7b33a0e0
PP
1392 BT_LIB_LOGD("Setting structure field's frozen state: "
1393 "%![field-]+f, is-frozen=%d", field, is_frozen);
fc25abce 1394
7b33a0e0
PP
1395 for (i = 0; i < struct_field->fields->len; i++) {
1396 struct bt_field *member_field = struct_field->fields->pdata[i];
918be005 1397
7b33a0e0
PP
1398 BT_LIB_LOGD("Setting structure field's member field's "
1399 "frozen state: %![field-]+f, index=%" PRIu64,
1400 member_field, i);
247fa9e3 1401 _bt_field_set_is_frozen(member_field, is_frozen);
918be005
PP
1402 }
1403
7b33a0e0 1404 set_single_field_is_frozen(field, is_frozen);
918be005
PP
1405}
1406
247fa9e3
PP
1407static
1408void set_option_field_is_frozen(struct bt_field *field, bool is_frozen)
1409{
1410 struct bt_field_option *opt_field = (void *) field;
1411
1412 BT_LIB_LOGD("Setting option field's frozen state: "
1413 "%![field-]+f, is-frozen=%d", field, is_frozen);
1414 _bt_field_set_is_frozen(opt_field->content_field, is_frozen);
1415 set_single_field_is_frozen(field, is_frozen);
1416}
1417
18acc6f8 1418static
7b33a0e0 1419void set_variant_field_is_frozen(struct bt_field *field, bool is_frozen)
918be005 1420{
a6918753 1421 uint64_t i;
7b33a0e0 1422 struct bt_field_variant *var_field = (void *) field;
918be005 1423
7b33a0e0
PP
1424 BT_LIB_LOGD("Setting variant field's frozen state: "
1425 "%![field-]+f, is-frozen=%d", field, is_frozen);
a6918753 1426
7b33a0e0
PP
1427 for (i = 0; i < var_field->fields->len; i++) {
1428 struct bt_field *option_field = var_field->fields->pdata[i];
a6918753 1429
7b33a0e0
PP
1430 BT_LIB_LOGD("Setting variant field's option field's "
1431 "frozen state: %![field-]+f, index=%" PRIu64,
1432 option_field, i);
247fa9e3 1433 _bt_field_set_is_frozen(option_field, is_frozen);
a6918753
PP
1434 }
1435
7b33a0e0 1436 set_single_field_is_frozen(field, is_frozen);
918be005
PP
1437}
1438
18acc6f8 1439static
7b33a0e0 1440void set_array_field_is_frozen(struct bt_field *field, bool is_frozen)
918be005 1441{
7b33a0e0 1442 uint64_t i;
18acc6f8 1443 struct bt_field_array *array_field = (void *) field;
918be005 1444
7b33a0e0
PP
1445 BT_LIB_LOGD("Setting array field's frozen state: "
1446 "%![field-]+f, is-frozen=%d", field, is_frozen);
fc25abce 1447
7b33a0e0
PP
1448 for (i = 0; i < array_field->fields->len; i++) {
1449 struct bt_field *elem_field = array_field->fields->pdata[i];
918be005 1450
7b33a0e0
PP
1451 BT_LIB_LOGD("Setting array field's element field's "
1452 "frozen state: %![field-]+f, index=%" PRIu64,
fc25abce 1453 elem_field, i);
247fa9e3 1454 _bt_field_set_is_frozen(elem_field, is_frozen);
918be005
PP
1455 }
1456
7b33a0e0 1457 set_single_field_is_frozen(field, is_frozen);
918be005
PP
1458}
1459
1460BT_HIDDEN
78cf9df6 1461void _bt_field_set_is_frozen(const struct bt_field *field,
a6918753 1462 bool is_frozen)
918be005 1463{
7b33a0e0
PP
1464 BT_ASSERT(field);
1465 BT_LIB_LOGD("Setting field object's frozen state: %!+f, is-frozen=%d",
a6918753 1466 field, is_frozen);
a6918753 1467 BT_ASSERT(field->methods->set_is_frozen);
78cf9df6 1468 field->methods->set_is_frozen((void *) field, is_frozen);
918be005 1469}
76f869ab 1470
18acc6f8 1471static
78cf9df6 1472bool single_field_is_set(const struct bt_field *field)
76f869ab 1473{
7b33a0e0
PP
1474 BT_ASSERT(field);
1475 return field->is_set;
76f869ab
JG
1476}
1477
18acc6f8 1478static
78cf9df6 1479bool structure_field_is_set(const struct bt_field *field)
76f869ab 1480{
7b33a0e0
PP
1481 bool is_set = true;
1482 uint64_t i;
78cf9df6 1483 const struct bt_field_structure *struct_field = (const void *) field;
76f869ab 1484
8b45963b 1485 BT_ASSERT(field);
8deee039 1486
7b33a0e0
PP
1487 for (i = 0; i < struct_field->fields->len; i++) {
1488 is_set = bt_field_is_set(struct_field->fields->pdata[i]);
53d65c1d 1489 if (!is_set) {
76f869ab
JG
1490 goto end;
1491 }
1492 }
8deee039 1493
76f869ab 1494end:
53d65c1d 1495 return is_set;
76f869ab
JG
1496}
1497
247fa9e3
PP
1498static
1499bool option_field_is_set(const struct bt_field *field)
1500{
1501 const struct bt_field_option *opt_field = (const void *) field;
1502 bool is_set = false;
1503
1504 BT_ASSERT(field);
1505
1506 if (opt_field->selected_field) {
1507 is_set = bt_field_is_set(opt_field->selected_field);
1508 }
1509
1510 return is_set;
1511}
1512
18acc6f8 1513static
78cf9df6 1514bool variant_field_is_set(const struct bt_field *field)
76f869ab 1515{
78cf9df6 1516 const struct bt_field_variant *var_field = (const void *) field;
7b33a0e0 1517 bool is_set = false;
76f869ab 1518
8b45963b 1519 BT_ASSERT(field);
8deee039 1520
7b33a0e0
PP
1521 if (var_field->selected_field) {
1522 is_set = bt_field_is_set(var_field->selected_field);
76f869ab 1523 }
8deee039 1524
53d65c1d 1525 return is_set;
76f869ab
JG
1526}
1527
18acc6f8 1528static
78cf9df6 1529bool array_field_is_set(const struct bt_field *field)
76f869ab 1530{
7b33a0e0
PP
1531 bool is_set = true;
1532 uint64_t i;
78cf9df6 1533 const struct bt_field_array *array_field = (const void *) field;
76f869ab 1534
8b45963b 1535 BT_ASSERT(field);
8deee039 1536
7b33a0e0
PP
1537 for (i = 0; i < array_field->length; i++) {
1538 is_set = bt_field_is_set(array_field->fields->pdata[i]);
53d65c1d 1539 if (!is_set) {
76f869ab
JG
1540 goto end;
1541 }
1542 }
8deee039 1543
76f869ab 1544end:
53d65c1d 1545 return is_set;
76f869ab 1546}
This page took 0.160892 seconds and 4 git commands to generate.