#include <babeltrace/ctf-writer/event-types.h>
#include <babeltrace/ctf-ir/event-types-internal.h>
+#include <babeltrace/ctf-ir/field-path-internal.h>
#include <babeltrace/ctf-ir/utils.h>
#include <babeltrace/ref.h>
#include <babeltrace/ctf-ir/clock.h>
integer->parent.declaration->id = CTF_TYPE_INTEGER;
integer->declaration.len = size;
integer->declaration.base = BT_CTF_INTEGER_BASE_DECIMAL;
- integer->declaration.encoding = CTF_STRING_NONE;
+ integer->declaration.encoding = BT_CTF_STRING_ENCODING_NONE;
bt_ctf_field_type_init(&integer->parent, TRUE);
return &integer->parent;
}
return ret;
}
-enum ctf_string_encoding bt_ctf_field_type_integer_get_encoding(
+enum bt_ctf_string_encoding bt_ctf_field_type_integer_get_encoding(
struct bt_ctf_field_type *type)
{
- enum ctf_string_encoding ret = CTF_STRING_UNKNOWN;
+ enum bt_ctf_string_encoding ret = BT_CTF_STRING_ENCODING_UNKNOWN;
struct bt_ctf_field_type_integer *integer;
if (!type || type->declaration->id != CTF_TYPE_INTEGER) {
}
int bt_ctf_field_type_integer_set_encoding(struct bt_ctf_field_type *type,
- enum ctf_string_encoding encoding)
+ enum bt_ctf_string_encoding encoding)
{
int ret = 0;
struct bt_ctf_field_type_integer *integer;
if (!type || type->frozen ||
(type->declaration->id != CTF_TYPE_INTEGER) ||
- (encoding < CTF_STRING_NONE) ||
- (encoding >= CTF_STRING_UNKNOWN)) {
+ (encoding < BT_CTF_STRING_ENCODING_NONE) ||
+ (encoding >= BT_CTF_STRING_ENCODING_UNKNOWN)) {
ret = -1;
goto end;
}
string->parent.declaration = &string->declaration.p;
string->parent.declaration->id = CTF_TYPE_STRING;
bt_ctf_field_type_init(&string->parent, TRUE);
- string->declaration.encoding = CTF_STRING_UTF8;
+ string->declaration.encoding = BT_CTF_STRING_ENCODING_UTF8;
string->parent.declaration->alignment = CHAR_BIT;
return &string->parent;
}
-enum ctf_string_encoding bt_ctf_field_type_string_get_encoding(
+enum bt_ctf_string_encoding bt_ctf_field_type_string_get_encoding(
struct bt_ctf_field_type *type)
{
struct bt_ctf_field_type_string *string;
- enum ctf_string_encoding ret = CTF_STRING_UNKNOWN;
+ enum bt_ctf_string_encoding ret = BT_CTF_STRING_ENCODING_UNKNOWN;
if (!type || (type->declaration->id != CTF_TYPE_STRING)) {
goto end;
}
int bt_ctf_field_type_string_set_encoding(struct bt_ctf_field_type *type,
- enum ctf_string_encoding encoding)
+ enum bt_ctf_string_encoding encoding)
{
int ret = 0;
struct bt_ctf_field_type_string *string;
if (!type || type->declaration->id != CTF_TYPE_STRING ||
- (encoding != CTF_STRING_UTF8 &&
- encoding != CTF_STRING_ASCII)) {
+ (encoding != BT_CTF_STRING_ENCODING_UTF8 &&
+ encoding != BT_CTF_STRING_ENCODING_ASCII)) {
ret = -1;
goto end;
}
return copy;
}
-BT_HIDDEN
-struct bt_ctf_field_path *bt_ctf_field_path_create(void)
-{
- struct bt_ctf_field_path *field_path = NULL;
-
- field_path = g_new0(struct bt_ctf_field_path, 1);
- if (!field_path) {
- goto end;
- }
-
- field_path->root = CTF_NODE_UNKNOWN;
- field_path->path_indexes = g_array_new(TRUE, FALSE, sizeof(int));
- if (!field_path->path_indexes) {
- bt_ctf_field_path_destroy(field_path);
- field_path = NULL;
- }
-end:
- return field_path;
-}
-
-BT_HIDDEN
-void bt_ctf_field_path_clear(struct bt_ctf_field_path *field_path)
-{
- if (field_path->path_indexes->len > 0) {
- g_array_remove_range(field_path->path_indexes, 0,
- field_path->path_indexes->len);
- }
-}
-
-BT_HIDDEN
-struct bt_ctf_field_path *bt_ctf_field_path_copy(
- struct bt_ctf_field_path *path)
-{
- struct bt_ctf_field_path *new_path = bt_ctf_field_path_create();
-
- if (!new_path) {
- goto end;
- }
-
- new_path->root = path->root;
- g_array_insert_vals(new_path->path_indexes, 0,
- path->path_indexes->data, path->path_indexes->len);
-end:
- return new_path;
-}
-
-BT_HIDDEN
-void bt_ctf_field_path_destroy(struct bt_ctf_field_path *path)
-{
- if (!path) {
- return;
- }
-
- if (path->path_indexes) {
- g_array_free(path->path_indexes, TRUE);
- }
- g_free(path);
-}
-
BT_HIDDEN
int bt_ctf_field_type_structure_get_field_name_index(
struct bt_ctf_field_type *type, const char *name)
sequence = container_of(type, struct bt_ctf_field_type_sequence,
parent);
- if (sequence->length_field_path) {
- bt_ctf_field_path_destroy(sequence->length_field_path);
- }
- sequence->length_field_path = path;
+ bt_get(path);
+ BT_MOVE(sequence->length_field_path, path);
end:
return ret;
}
-BT_HIDDEN
-struct bt_ctf_field_path *bt_ctf_field_type_sequence_get_length_field_path(
- struct bt_ctf_field_type *type)
-{
- struct bt_ctf_field_type_sequence *sequence;
-
- sequence = container_of(type, struct bt_ctf_field_type_sequence,
- parent);
-
- return sequence->length_field_path;
-}
-
BT_HIDDEN
int bt_ctf_field_type_variant_set_tag_field_path(struct bt_ctf_field_type *type,
struct bt_ctf_field_path *path)
variant = container_of(type, struct bt_ctf_field_type_variant,
parent);
- if (variant->tag_path) {
- bt_ctf_field_path_destroy(variant->tag_path);
- }
- variant->tag_path = path;
+ bt_get(path);
+ BT_MOVE(variant->tag_field_path, path);
end:
return ret;
}
BT_HIDDEN
-struct bt_ctf_field_path *bt_ctf_field_type_variant_get_tag_field_path(
- struct bt_ctf_field_type *type)
-{
- struct bt_ctf_field_type_variant *variant;
-
- variant = container_of(type, struct bt_ctf_field_type_variant,
- parent);
-
- return variant->tag_path;
-}
-
-BT_HIDDEN
-int bt_ctf_field_type_variant_set_tag(struct bt_ctf_field_type *type,
+int bt_ctf_field_type_variant_set_tag_field_type(struct bt_ctf_field_type *type,
struct bt_ctf_field_type *tag)
{
int ret = 0;
struct bt_ctf_field_type_variant *variant;
- if (!type || !tag || type->frozen ||
- bt_ctf_field_type_get_type_id(tag) != CTF_TYPE_ENUM) {
+ if (!type || !tag ||
+ bt_ctf_field_type_get_type_id(tag) != CTF_TYPE_ENUM) {
ret = -1;
goto end;
}
g_hash_table_destroy(variant->field_name_to_index);
g_string_free(variant->tag_name, TRUE);
bt_put(&variant->tag->parent);
- bt_ctf_field_path_destroy(variant->tag_path);
+ BT_PUT(variant->tag_field_path);
g_free(variant);
}
bt_put(sequence->element_type);
g_string_free(sequence->length_field_name, TRUE);
- bt_ctf_field_path_destroy(sequence->length_field_path);
+ BT_PUT(sequence->length_field_path);
g_free(sequence);
}
}
static
-const char *get_encoding_string(enum ctf_string_encoding encoding)
+const char *get_encoding_string(enum bt_ctf_string_encoding encoding)
{
const char *encoding_string;
switch (encoding) {
- case CTF_STRING_NONE:
+ case BT_CTF_STRING_ENCODING_NONE:
encoding_string = "none";
break;
- case CTF_STRING_ASCII:
+ case BT_CTF_STRING_ENCODING_ASCII:
encoding_string = "ASCII";
break;
- case CTF_STRING_UTF8:
+ case BT_CTF_STRING_ENCODING_UTF8:
encoding_string = "UTF8";
break;
default:
}
copy_variant->declaration = variant->declaration;
- if (variant->tag_path) {
- copy_variant->tag_path = bt_ctf_field_path_copy(
- variant->tag_path);
- if (!copy_variant->tag_path) {
+ if (variant->tag_field_path) {
+ copy_variant->tag_field_path = bt_ctf_field_path_copy(
+ variant->tag_field_path);
+ if (!copy_variant->tag_field_path) {
goto error;
}
}
if (ret) {
goto end;
}
-
- ret = 1;
}
/* Equal */
if (ret) {
goto end;
}
-
- ret = 1;
}
/* Equal */
end:
return ret;
}
+
+BT_HIDDEN
+int bt_ctf_field_type_get_field_count(struct bt_ctf_field_type *field_type)
+{
+ int field_count = -1;
+ enum ctf_type_id type_id = bt_ctf_field_type_get_type_id(field_type);
+
+ switch (type_id) {
+ case CTF_TYPE_STRUCT:
+ field_count =
+ bt_ctf_field_type_structure_get_field_count(field_type);
+ break;
+ case CTF_TYPE_VARIANT:
+ field_count =
+ bt_ctf_field_type_variant_get_field_count(field_type);
+ break;
+ case CTF_TYPE_ARRAY:
+ case CTF_TYPE_SEQUENCE:
+ /*
+ * Array and sequence types always contain a single member
+ * (the element type).
+ */
+ field_count = 1;
+ break;
+ default:
+ break;
+ }
+
+ return field_count;
+}
+
+BT_HIDDEN
+struct bt_ctf_field_type *bt_ctf_field_type_get_field_at_index(
+ struct bt_ctf_field_type *field_type, int index)
+{
+ struct bt_ctf_field_type *field = NULL;
+ enum ctf_type_id type_id = bt_ctf_field_type_get_type_id(field_type);
+
+ switch (type_id) {
+ case CTF_TYPE_STRUCT:
+ bt_ctf_field_type_structure_get_field(field_type, NULL, &field,
+ index);
+ break;
+ case CTF_TYPE_VARIANT:
+ bt_ctf_field_type_variant_get_field(field_type, NULL,
+ &field, index);
+ break;
+ case CTF_TYPE_ARRAY:
+ field = bt_ctf_field_type_array_get_element_type(field_type);
+ break;
+ case CTF_TYPE_SEQUENCE:
+ field = bt_ctf_field_type_sequence_get_element_type(field_type);
+ break;
+ default:
+ break;
+ }
+
+ return field;
+}
+
+BT_HIDDEN
+int bt_ctf_field_type_get_field_index(struct bt_ctf_field_type *field_type,
+ const char *name)
+{
+ int field_index = -1;
+ enum ctf_type_id type_id = bt_ctf_field_type_get_type_id(field_type);
+
+ switch (type_id) {
+ case CTF_TYPE_STRUCT:
+ field_index = bt_ctf_field_type_structure_get_field_name_index(
+ field_type, name);
+ break;
+ case CTF_TYPE_VARIANT:
+ field_index = bt_ctf_field_type_variant_get_field_name_index(
+ field_type, name);
+ break;
+ default:
+ break;
+ }
+
+ return field_index;
+}
+
+struct bt_ctf_field_path *bt_ctf_field_type_variant_get_tag_field_path(
+ struct bt_ctf_field_type *type)
+{
+ struct bt_ctf_field_path *field_path = NULL;
+ struct bt_ctf_field_type_variant *variant;
+
+ if (!type || !bt_ctf_field_type_is_variant(type)) {
+ goto end;
+ }
+
+ variant = container_of(type, struct bt_ctf_field_type_variant,
+ parent);
+ field_path = bt_get(variant->tag_field_path);
+end:
+ return field_path;
+}
+
+struct bt_ctf_field_path *bt_ctf_field_type_sequence_get_length_field_path(
+ struct bt_ctf_field_type *type)
+{
+ struct bt_ctf_field_path *field_path = NULL;
+ struct bt_ctf_field_type_sequence *sequence;
+
+ if (!type || !bt_ctf_field_type_is_sequence(type)) {
+ goto end;
+ }
+
+ sequence = container_of(type, struct bt_ctf_field_type_sequence,
+ parent);
+ field_path = bt_get(sequence->length_field_path);
+end:
+ return field_path;
+}
projects / babeltrace.git / blobdiff