extern "C" {
#endif
+extern const bt_value *bt_clock_class_borrow_user_attributes_const(
+ const bt_clock_class *clock_class);
+
extern const char *bt_clock_class_get_name(
const bt_clock_class *clock_class);
extern bt_clock_class *bt_clock_class_create(bt_self_component *self_comp);
+extern bt_value *bt_clock_class_borrow_user_attributes(
+ bt_clock_class *clock_class);
+
+extern void bt_clock_class_set_user_attributes(
+ bt_clock_class *clock_class, const bt_value *user_attributes);
+
typedef enum bt_clock_class_set_name_status {
BT_CLOCK_CLASS_SET_NAME_STATUS_MEMORY_ERROR = __BT_FUNC_STATUS_MEMORY_ERROR,
BT_CLOCK_CLASS_SET_NAME_STATUS_OK = __BT_FUNC_STATUS_OK,
BT_EVENT_CLASS_LOG_LEVEL_DEBUG,
} bt_event_class_log_level;
+extern const bt_value *bt_event_class_borrow_user_attributes_const(
+ const bt_event_class *event_class);
+
extern const bt_stream_class *bt_event_class_borrow_stream_class_const(
const bt_event_class *event_class);
extern bt_event_class *bt_event_class_create_with_id(
bt_stream_class *stream_class, uint64_t id);
+extern bt_value *bt_event_class_borrow_user_attributes(
+ bt_event_class *event_class);
+
+extern void bt_event_class_set_user_attributes(
+ bt_event_class *event_class, const bt_value *user_attributes);
+
extern bt_stream_class *bt_event_class_borrow_stream_class(
bt_event_class *event_class);
extern bt_field_class_type bt_field_class_get_type(
const bt_field_class *field_class);
+extern const bt_value *bt_field_class_borrow_user_attributes_const(
+ const bt_field_class *field_class);
+
extern uint64_t bt_field_class_bit_array_get_length(
const bt_field_class *field_class);
bt_field_class_structure_member_borrow_field_class_const(
const bt_field_class_structure_member *member);
+extern const bt_value *bt_field_class_structure_member_borrow_user_attributes_const(
+ const bt_field_class_structure_member *member);
+
extern const bt_field_class *
bt_field_class_array_borrow_element_field_class_const(
const bt_field_class *field_class);
bt_field_class_variant_option_borrow_field_class_const(
const bt_field_class_variant_option *option);
+extern const bt_value *bt_field_class_variant_option_borrow_user_attributes_const(
+ const bt_field_class_variant_option *option);
+
extern const bt_field_path *
bt_field_class_variant_with_selector_borrow_selector_field_path_const(
const bt_field_class *field_class);
extern "C" {
#endif
+extern void bt_field_class_set_user_attributes(
+ bt_field_class *field_class, const bt_value *user_attributes);
+
+extern bt_value *bt_field_class_borrow_user_attributes(
+ bt_field_class *field_class);
+
extern bt_field_class *bt_field_class_bool_create(
bt_trace_class *trace_class);
bt_field_class_structure_borrow_member_by_name(
bt_field_class *field_class, const char *name);
+extern bt_value *bt_field_class_structure_member_borrow_user_attributes(
+ bt_field_class_structure_member *member);
+
+extern void bt_field_class_structure_member_set_user_attributes(
+ bt_field_class_structure_member *member,
+ const bt_value *user_attributes);
+
extern bt_field_class *bt_field_class_array_static_create(
bt_trace_class *trace_class,
bt_field_class *elem_field_class, uint64_t length);
bt_field_class_variant_borrow_option_by_name(
bt_field_class *field_class, const char *name);
+extern bt_value *bt_field_class_variant_option_borrow_user_attributes(
+ bt_field_class_variant_option *option);
+
+extern void bt_field_class_variant_option_set_user_attributes(
+ bt_field_class_variant_option *option,
+ const bt_value *user_attributes);
+
#ifdef __cplusplus
}
#endif
extern "C" {
#endif
+extern const bt_value *bt_stream_class_borrow_user_attributes_const(
+ const bt_stream_class *stream_class);
+
extern const bt_trace_class *bt_stream_class_borrow_trace_class_const(
const bt_stream_class *stream_class);
extern bt_stream_class *bt_stream_class_create_with_id(
bt_trace_class *trace_class, uint64_t id);
+extern bt_value *bt_stream_class_borrow_user_attributes(
+ bt_stream_class *stream_class);
+
+extern void bt_stream_class_set_user_attributes(
+ bt_stream_class *stream_class, const bt_value *user_attributes);
+
extern bt_trace_class *bt_stream_class_borrow_trace_class(
bt_stream_class *stream_class);
extern "C" {
#endif
+extern const bt_value *bt_stream_borrow_user_attributes_const(
+ const bt_stream *stream);
+
extern const bt_stream_class *bt_stream_borrow_class_const(
const bt_stream *stream);
bt_stream_class *stream_class,
bt_trace *trace, uint64_t id);
+extern bt_value *bt_stream_borrow_user_attributes(bt_stream *stream);
+
+extern void bt_stream_set_user_attributes(
+ bt_stream *stream, const bt_value *user_attributes);
+
extern bt_trace *bt_stream_borrow_trace(bt_stream *stream);
extern bt_stream_class *bt_stream_borrow_class(bt_stream *stream);
typedef void (* bt_trace_class_destruction_listener_func)(
const bt_trace_class *trace_class, void *data);
+extern const bt_value *bt_trace_class_borrow_user_attributes_const(
+ const bt_trace_class *trace_class);
+
extern bt_bool bt_trace_class_assigns_automatic_stream_class_id(
const bt_trace_class *trace_class);
extern bt_trace_class *bt_trace_class_create(bt_self_component *self_comp);
+extern bt_value *bt_trace_class_borrow_user_attributes(
+ bt_trace_class *trace_class);
+
+extern void bt_trace_class_set_user_attributes(
+ bt_trace_class *trace_class, const bt_value *user_attributes);
+
extern void bt_trace_class_set_assigns_automatic_stream_class_id(
bt_trace_class *trace_class, bt_bool value);
typedef void (* bt_trace_destruction_listener_func)(
const bt_trace *trace, void *data);
+extern const bt_value *bt_trace_borrow_user_attributes_const(
+ const bt_trace *trace);
+
extern const bt_trace_class *bt_trace_borrow_class_const(
const bt_trace *trace);
extern bt_trace *bt_trace_create(bt_trace_class *trace_class);
+extern bt_value *bt_trace_borrow_user_attributes(bt_trace *trace);
+
+extern void bt_trace_set_user_attributes(
+ bt_trace *trace, const bt_value *user_attributes);
+
typedef enum bt_trace_set_name_status {
BT_TRACE_SET_NAME_STATUS_MEMORY_ERROR = __BT_FUNC_STATUS_MEMORY_ERROR,
BT_TRACE_SET_NAME_STATUS_OK = __BT_FUNC_STATUS_OK,
#include "lib/object.h"
#include "common/assert.h"
#include "lib/func-status.h"
+#include "lib/value.h"
#define BT_ASSERT_PRE_DEV_CLOCK_CLASS_HOT(_cc) \
BT_ASSERT_PRE_DEV_HOT((_cc), "Clock class", ": %!+K", (_cc))
struct bt_clock_class *clock_class = (void *) obj;
BT_LIB_LOGD("Destroying clock class: %!+K", clock_class);
+ BT_OBJECT_PUT_REF_AND_RESET(clock_class->user_attributes);
if (clock_class->name.str) {
g_string_free(clock_class->name.str, TRUE);
}
bt_object_init_shared(&clock_class->base, destroy_clock_class);
+
+ clock_class->user_attributes = bt_value_map_create();
+ if (!clock_class->user_attributes) {
+ BT_LIB_LOGE_APPEND_CAUSE(
+ "Failed to create a map value object.");
+ goto error;
+ }
+
clock_class->name.str = g_string_new(NULL);
if (!clock_class->name.str) {
BT_LIB_LOGE_APPEND_CAUSE("Failed to allocate a GString.");
return;
}
+ BT_LIB_LOGD("Freezing clock class's user attributes: %!+v",
+ clock_class->user_attributes);
+ bt_value_freeze(clock_class->user_attributes);
BT_LIB_LOGD("Freezing clock class: %!+K", clock_class);
((struct bt_clock_class *) clock_class)->frozen = 1;
}
return ret;
}
+const struct bt_value *bt_clock_class_borrow_user_attributes_const(
+ const struct bt_clock_class *clock_class)
+{
+ BT_ASSERT_PRE_DEV_NON_NULL(clock_class, "Clock class");
+ return clock_class->user_attributes;
+}
+
+struct bt_value *bt_clock_class_borrow_user_attributes(
+ struct bt_clock_class *clock_class)
+{
+ return (void *) bt_clock_class_borrow_user_attributes_const(
+ (void *) clock_class);
+}
+
+void bt_clock_class_set_user_attributes(
+ struct bt_clock_class *clock_class,
+ const struct bt_value *user_attributes)
+{
+ BT_ASSERT_PRE_NON_NULL(clock_class, "Clock class");
+ BT_ASSERT_PRE_NON_NULL(user_attributes, "User attributes");
+ BT_ASSERT_PRE(user_attributes->type == BT_VALUE_TYPE_MAP,
+ "User attributes object is not a map value object.");
+ BT_ASSERT_PRE_DEV_CLOCK_CLASS_HOT(clock_class);
+ bt_object_put_no_null_check(clock_class->user_attributes);
+ clock_class->user_attributes = (void *) user_attributes;
+ bt_object_get_no_null_check(clock_class->user_attributes);
+}
+
void bt_clock_class_get_ref(const struct bt_clock_class *clock_class)
{
bt_object_get_ref(clock_class);
struct bt_clock_class {
struct bt_object base;
+ /* Owned by this */
+ struct bt_value *user_attributes;
+
struct {
GString *str;
struct bt_event_class *event_class = (void *) obj;
BT_LIB_LOGD("Destroying event class: %!+E", event_class);
+ BT_OBJECT_PUT_REF_AND_RESET(event_class->user_attributes);
if (event_class->name.str) {
g_string_free(event_class->name.str, TRUE);
bt_object_init_shared_with_parent(&event_class->base,
destroy_event_class);
+ event_class->user_attributes = bt_value_map_create();
+ if (!event_class->user_attributes) {
+ BT_LIB_LOGE_APPEND_CAUSE(
+ "Failed to create a map value object.");
+ goto error;
+ }
+
event_class->id = id;
bt_property_uint_init(&event_class->log_level,
BT_PROPERTY_AVAILABILITY_NOT_AVAILABLE, 0);
event_class->name.str = g_string_new(NULL);
if (!event_class->name.str) {
BT_LIB_LOGE_APPEND_CAUSE("Failed to allocate a GString.");
- ret = -1;
- goto end;
+ goto error;
}
event_class->emf_uri.str = g_string_new(NULL);
if (!event_class->emf_uri.str) {
BT_LIB_LOGE_APPEND_CAUSE("Failed to allocate a GString.");
- ret = -1;
- goto end;
+ goto error;
}
ret = bt_object_pool_initialize(&event_class->event_pool,
{
/* The field classes are already frozen */
BT_ASSERT(event_class);
+ BT_LIB_LOGD("Freezing event class's user attributes: %!+v",
+ event_class->user_attributes);
+ bt_value_freeze(event_class->user_attributes);
BT_LIB_LOGD("Freezing event class: %!+E", event_class);
((struct bt_event_class *) event_class)->frozen = true;
}
+const struct bt_value *bt_event_class_borrow_user_attributes_const(
+ const struct bt_event_class *event_class)
+{
+ BT_ASSERT_PRE_DEV_NON_NULL(event_class, "Event class");
+ return event_class->user_attributes;
+}
+
+struct bt_value *bt_event_class_borrow_user_attributes(
+ struct bt_event_class *event_class)
+{
+ return (void *) bt_event_class_borrow_user_attributes_const(
+ (void *) event_class);
+}
+
+void bt_event_class_set_user_attributes(
+ struct bt_event_class *event_class,
+ const struct bt_value *user_attributes)
+{
+ BT_ASSERT_PRE_NON_NULL(event_class, "Event class");
+ BT_ASSERT_PRE_NON_NULL(user_attributes, "User attributes");
+ BT_ASSERT_PRE(user_attributes->type == BT_VALUE_TYPE_MAP,
+ "User attributes object is not a map value object.");
+ BT_ASSERT_PRE_DEV_EVENT_CLASS_HOT(event_class);
+ bt_object_put_no_null_check(event_class->user_attributes);
+ event_class->user_attributes = (void *) user_attributes;
+ bt_object_get_no_null_check(event_class->user_attributes);
+}
+
void bt_event_class_get_ref(const struct bt_event_class *event_class)
{
bt_object_get_ref(event_class);
struct bt_field_class *specific_context_fc;
struct bt_field_class *payload_fc;
+ /* Owned by this */
+ struct bt_value *user_attributes;
+
struct {
GString *str;
#include "utils.h"
#include "lib/func-status.h"
#include "lib/integer-range-set.h"
+#include "lib/value.h"
enum bt_field_class_type bt_field_class_get_type(
const struct bt_field_class *fc)
}
static
-void init_field_class(struct bt_field_class *fc, enum bt_field_class_type type,
+int init_field_class(struct bt_field_class *fc, enum bt_field_class_type type,
bt_object_release_func release_func)
{
+ int ret = 0;
+
BT_ASSERT(fc);
BT_ASSERT(release_func);
bt_object_init_shared(&fc->base, release_func);
fc->type = type;
+ fc->user_attributes = bt_value_map_create();
+ if (!fc->user_attributes) {
+ BT_LIB_LOGE_APPEND_CAUSE(
+ "Failed to create a map value object.");
+ ret = -1;
+ goto end;
+ }
+
+end:
+ return ret;
+}
+
+static
+void finalize_field_class(struct bt_field_class *fc)
+{
+ BT_OBJECT_PUT_REF_AND_RESET(fc->user_attributes);
}
static
{
BT_ASSERT(obj);
BT_LIB_LOGD("Destroying bit array field class object: %!+F", obj);
+ finalize_field_class((void *) obj);
g_free(obj);
}
goto error;
}
- init_field_class((void *) ba_fc, BT_FIELD_CLASS_TYPE_BIT_ARRAY,
- destroy_bit_array_field_class);
+ if (init_field_class((void *) ba_fc, BT_FIELD_CLASS_TYPE_BIT_ARRAY,
+ destroy_bit_array_field_class)) {
+ goto error;
+ }
+
ba_fc->length = length;
BT_LIB_LOGD("Created bit array field class object: %!+F", ba_fc);
goto end;
{
BT_ASSERT(obj);
BT_LIB_LOGD("Destroying boolean field class object: %!+F", obj);
+ finalize_field_class((void *) obj);
g_free(obj);
}
goto error;
}
- init_field_class((void *) bool_fc, BT_FIELD_CLASS_TYPE_BOOL,
- destroy_bool_field_class);
+ if (init_field_class((void *) bool_fc, BT_FIELD_CLASS_TYPE_BOOL,
+ destroy_bool_field_class)) {
+ goto error;
+ }
+
BT_LIB_LOGD("Created boolean field class object: %!+F", bool_fc);
goto end;
}
static
-void init_integer_field_class(struct bt_field_class_integer *fc,
+int init_integer_field_class(struct bt_field_class_integer *fc,
enum bt_field_class_type type,
bt_object_release_func release_func)
{
- init_field_class((void *) fc, type, release_func);
+ int ret;
+
+ ret = init_field_class((void *) fc, type, release_func);
+ if (ret) {
+ goto end;
+ }
+
fc->range = 64;
fc->base = BT_FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_DECIMAL;
+
+end:
+ return ret;
}
static
{
BT_ASSERT(obj);
BT_LIB_LOGD("Destroying integer field class object: %!+F", obj);
+ finalize_field_class((void *) obj);
g_free(obj);
}
goto error;
}
- init_integer_field_class(int_fc, type, destroy_integer_field_class);
+ if (init_integer_field_class(int_fc, type,
+ destroy_integer_field_class)) {
+ goto error;
+ }
+
BT_LIB_LOGD("Created integer field class object: %!+F", int_fc);
goto end;
BT_ASSERT(fc);
BT_LIB_LOGD("Destroying enumeration field class object: %!+F", fc);
+ finalize_field_class((void *) obj);
if (fc->mappings) {
uint64_t i;
goto error;
}
- init_integer_field_class((void *) enum_fc, type,
- destroy_enumeration_field_class);
+ if (init_integer_field_class((void *) enum_fc, type,
+ destroy_enumeration_field_class)) {
+ goto error;
+ }
+
enum_fc->mappings = g_array_new(FALSE, TRUE,
sizeof(struct bt_field_class_enumeration_mapping));
if (!enum_fc->mappings) {
{
BT_ASSERT(obj);
BT_LIB_LOGD("Destroying real field class object: %!+F", obj);
+ finalize_field_class((void *) obj);
g_free(obj);
}
goto error;
}
- init_field_class((void *) real_fc, BT_FIELD_CLASS_TYPE_REAL,
- destroy_real_field_class);
+ if (init_field_class((void *) real_fc, BT_FIELD_CLASS_TYPE_REAL,
+ destroy_real_field_class)) {
+ goto error;
+ }
+
BT_LIB_LOGD("Created real field class object: %!+F", real_fc);
goto end;
{
int ret = 0;
- init_field_class((void *) fc, type, fc_release_func);
+ ret = init_field_class((void *) fc, type, fc_release_func);
+ if (ret) {
+ goto end;
+ }
+
fc->named_fcs = g_ptr_array_new_with_free_func(named_fc_destroy_func);
if (!fc->named_fcs) {
BT_LIB_LOGE_APPEND_CAUSE("Failed to allocate a GPtrArray.");
"addr=%p, name=\"%s\", %![fc-]+F",
named_fc, named_fc->name ? named_fc->name->str : NULL,
named_fc->fc);
+ BT_OBJECT_PUT_REF_AND_RESET(named_fc->user_attributes);
if (named_fc->name) {
g_string_free(named_fc->name, TRUE);
static
void destroy_named_field_class(gpointer ptr)
{
+ struct bt_named_field_class *named_fc = ptr;
+
+ BT_OBJECT_PUT_REF_AND_RESET(named_fc->user_attributes);
+
if (ptr) {
finalize_named_field_class(ptr);
g_free(ptr);
{
BT_ASSERT(obj);
BT_LIB_LOGD("Destroying structure field class object: %!+F", obj);
+ finalize_field_class((void *) obj);
finalize_named_field_classes_container((void *) obj);
g_free(obj);
}
goto end;
}
+ named_fc->user_attributes = bt_value_map_create();
+ if (!named_fc->user_attributes) {
+ BT_LIB_LOGE_APPEND_CAUSE(
+ "Failed to create a map value object.");
+ status = BT_FUNC_STATUS_MEMORY_ERROR;
+ goto end;
+ }
+
named_fc->fc = fc;
bt_object_get_no_null_check(named_fc->fc);
- bt_named_field_class_freeze(named_fc);
end:
return status;
"Duplicate member/option name in structure/variant field class: "
"%![container-fc-]+F, name=\"%s\"", container_fc,
named_fc->name->str);
+
+ /*
+ * Freeze the contained field class, but not the named field
+ * class itself, as it's still possible afterwards to modify
+ * properties of the member/option object.
+ */
+ bt_field_class_freeze(named_fc->fc);
g_ptr_array_add(container_fc->named_fcs, named_fc);
g_hash_table_insert(container_fc->name_to_index, named_fc->name->str,
GUINT_TO_POINTER(container_fc->named_fcs->len - 1));
BT_ASSERT(fc);
BT_LIB_LOGD("Destroying option field class object: %!+F", fc);
+ finalize_field_class((void *) obj);
BT_LOGD_STR("Putting content field class.");
BT_OBJECT_PUT_REF_AND_RESET(fc->content_fc);
BT_LOGD_STR("Putting selector field path.");
goto error;
}
- init_field_class((void *) opt_fc, BT_FIELD_CLASS_TYPE_OPTION,
- destroy_option_field_class);
+ if (init_field_class((void *) opt_fc, BT_FIELD_CLASS_TYPE_OPTION,
+ destroy_option_field_class)) {
+ goto error;
+ }
+
opt_fc->content_fc = content_fc;
bt_object_get_no_null_check(opt_fc->content_fc);
bt_field_class_freeze(opt_fc->content_fc);
{
BT_ASSERT(var_fc);
BT_LIB_LOGD("Finalizing variant field class object: %!+F", var_fc);
+ finalize_field_class((void *) var_fc);
finalize_named_field_classes_container((void *) var_fc);
}
}
static
-void init_array_field_class(struct bt_field_class_array *fc,
+int init_array_field_class(struct bt_field_class_array *fc,
enum bt_field_class_type type, bt_object_release_func release_func,
struct bt_field_class *element_fc)
{
+ int ret;
+
BT_ASSERT(element_fc);
- init_field_class((void *) fc, type, release_func);
+ ret = init_field_class((void *) fc, type, release_func);
+ if (ret) {
+ goto end;
+ }
+
fc->element_fc = element_fc;
bt_object_get_no_null_check(fc->element_fc);
bt_field_class_freeze(element_fc);
+
+end:
+ return ret;
}
static
{
BT_ASSERT(array_fc);
BT_LOGD_STR("Putting element field class.");
+ finalize_field_class((void *) array_fc);
BT_OBJECT_PUT_REF_AND_RESET(array_fc->element_fc);
}
goto error;
}
- init_array_field_class((void *) array_fc, BT_FIELD_CLASS_TYPE_STATIC_ARRAY,
- destroy_static_array_field_class, element_fc);
+ if (init_array_field_class((void *) array_fc,
+ BT_FIELD_CLASS_TYPE_STATIC_ARRAY,
+ destroy_static_array_field_class, element_fc)) {
+ goto error;
+ }
+
array_fc->length = length;
BT_LIB_LOGD("Created static array field class object: %!+F", array_fc);
goto end;
goto error;
}
- init_array_field_class((void *) array_fc,
- BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY,
- destroy_dynamic_array_field_class, element_fc);
+ if (init_array_field_class((void *) array_fc,
+ BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY,
+ destroy_dynamic_array_field_class, element_fc)) {
+ goto error;
+ }
if (length_fc) {
BT_ASSERT_PRE_FC_IS_UNSIGNED_INT(length_fc,
{
BT_ASSERT(obj);
BT_LIB_LOGD("Destroying string field class object: %!+F", obj);
+ finalize_field_class((void *) obj);
g_free(obj);
}
goto error;
}
- init_field_class((void *) string_fc, BT_FIELD_CLASS_TYPE_STRING,
- destroy_string_field_class);
+ if (init_field_class((void *) string_fc, BT_FIELD_CLASS_TYPE_STRING,
+ destroy_string_field_class)) {
+ goto error;
+ }
+
BT_LIB_LOGD("Created string field class object: %!+F", string_fc);
goto end;
* their owner.
*/
BT_ASSERT(fc);
+ bt_value_freeze(fc->user_attributes);
fc->frozen = true;
switch (fc->type) {
void _bt_named_field_class_freeze(const struct bt_named_field_class *named_fc)
{
BT_ASSERT(named_fc);
+ BT_ASSERT(named_fc->fc->frozen);
+ BT_LIB_LOGD("Freezing named field class's user attributes: %!+v",
+ named_fc->user_attributes);
+ bt_value_freeze(named_fc->user_attributes);
((struct bt_named_field_class *) named_fc)->frozen = true;
- bt_field_class_freeze(named_fc->fc);
}
BT_HIDDEN
}
}
+const struct bt_value *bt_field_class_borrow_user_attributes_const(
+ const struct bt_field_class *fc)
+{
+ BT_ASSERT_PRE_DEV_NON_NULL(fc, "Field class");
+ return fc->user_attributes;
+}
+
+struct bt_value *bt_field_class_borrow_user_attributes(
+ struct bt_field_class *field_class)
+{
+ return (void *) bt_field_class_borrow_user_attributes_const(
+ (void *) field_class);
+}
+
+
+void bt_field_class_set_user_attributes(
+ struct bt_field_class *fc,
+ const struct bt_value *user_attributes)
+{
+ BT_ASSERT_PRE_NON_NULL(fc, "Field class");
+ BT_ASSERT_PRE_NON_NULL(user_attributes, "User attributes");
+ BT_ASSERT_PRE(user_attributes->type == BT_VALUE_TYPE_MAP,
+ "User attributes object is not a map value object.");
+ BT_ASSERT_PRE_DEV_FC_HOT(fc, "Field class");
+ bt_object_put_no_null_check(fc->user_attributes);
+ fc->user_attributes = (void *) user_attributes;
+ bt_object_get_no_null_check(fc->user_attributes);
+}
+
+static
+const struct bt_value *bt_named_field_class_borrow_user_attributes_const(
+ const struct bt_named_field_class *named_fc)
+{
+ return named_fc->user_attributes;
+}
+
+static
+void bt_named_field_class_set_user_attributes(
+ struct bt_named_field_class *named_fc,
+ const struct bt_value *user_attributes)
+{
+ BT_ASSERT_PRE_NON_NULL(user_attributes, "User attributes");
+ BT_ASSERT_PRE(user_attributes->type == BT_VALUE_TYPE_MAP,
+ "User attributes object is not a map value object.");
+ BT_ASSERT_PRE_DEV_HOT(named_fc,
+ "Structure field class member or variant field class option",
+ ".");
+ bt_object_put_no_null_check(named_fc->user_attributes);
+ named_fc->user_attributes = (void *) user_attributes;
+ bt_object_get_no_null_check(named_fc->user_attributes);
+}
+
+const struct bt_value *
+bt_field_class_structure_member_borrow_user_attributes_const(
+ const struct bt_field_class_structure_member *member)
+{
+ BT_ASSERT_PRE_NON_NULL(member, "Structure field class member");
+ return bt_named_field_class_borrow_user_attributes_const(
+ (const void *) member);
+}
+
+struct bt_value *
+bt_field_class_structure_member_borrow_user_attributes(
+ struct bt_field_class_structure_member *member)
+{
+ BT_ASSERT_PRE_NON_NULL(member, "Structure field class member");
+ return (void *) bt_named_field_class_borrow_user_attributes_const(
+ (void *) member);
+}
+
+void bt_field_class_structure_member_set_user_attributes(
+ struct bt_field_class_structure_member *member,
+ const struct bt_value *user_attributes)
+{
+ BT_ASSERT_PRE_NON_NULL(member, "Structure field class member");
+ bt_named_field_class_set_user_attributes((void *) member,
+ user_attributes);
+}
+
+const struct bt_value *bt_field_class_variant_option_borrow_user_attributes_const(
+ const struct bt_field_class_variant_option *option)
+{
+ BT_ASSERT_PRE_NON_NULL(option, "Variant field class option");
+ return bt_named_field_class_borrow_user_attributes_const(
+ (const void *) option);
+}
+
+struct bt_value *bt_field_class_variant_option_borrow_user_attributes(
+ struct bt_field_class_variant_option *option)
+{
+ BT_ASSERT_PRE_NON_NULL(option, "Variant field class option");
+ return (void *) bt_named_field_class_borrow_user_attributes_const(
+ (void *) option);
+}
+
+void bt_field_class_variant_option_set_user_attributes(
+ struct bt_field_class_variant_option *option,
+ const struct bt_value *user_attributes)
+{
+ BT_ASSERT_PRE_NON_NULL(option, "Variant field class option");
+ bt_named_field_class_set_user_attributes((void *) option,
+ user_attributes);
+}
+
void bt_field_class_get_ref(const struct bt_field_class *field_class)
{
bt_object_get_ref(field_class);
enum bt_field_class_type type;
bool frozen;
+ /* Owned by this */
+ struct bt_value *user_attributes;
+
/*
* This flag indicates whether or not this field class is part
* of a trace class.
struct bt_named_field_class {
GString *name;
+ /* Owned by this */
+ struct bt_value *user_attributes;
+
/* Owned by this */
struct bt_field_class *fc;
#include "stream-class.h"
#include "trace.h"
#include "utils.h"
+#include "lib/value.h"
#include "lib/func-status.h"
#define BT_ASSERT_PRE_DEV_STREAM_CLASS_HOT(_sc) \
BT_LIB_LOGD("Destroying stream class: %!+S", stream_class);
BT_LOGD_STR("Putting default clock class.");
+ BT_OBJECT_PUT_REF_AND_RESET(stream_class->user_attributes);
BT_OBJECT_PUT_REF_AND_RESET(stream_class->default_clock_class);
if (stream_class->event_classes) {
bt_object_init_shared_with_parent(&stream_class->base,
destroy_stream_class);
+ stream_class->user_attributes = bt_value_map_create();
+ if (!stream_class->user_attributes) {
+ BT_LIB_LOGE_APPEND_CAUSE(
+ "Failed to create a map value object.");
+ goto error;
+ }
stream_class->name.str = g_string_new(NULL);
if (!stream_class->name.str) {
BT_LIB_LOGE_APPEND_CAUSE("Failed to allocate a GString.");
- ret = -1;
- goto end;
+ goto error;
}
stream_class->id = id;
{
/* The field classes and default clock class are already frozen */
BT_ASSERT(stream_class);
+ BT_LIB_LOGD("Freezing stream class's user attributes: %!+v",
+ stream_class->user_attributes);
+ bt_value_freeze(stream_class->user_attributes);
BT_LIB_LOGD("Freezing stream class: %!+S", stream_class);
((struct bt_stream_class *) stream_class)->frozen = true;
}
"assignment property: %!+S", stream_class);
}
+const struct bt_value *bt_stream_class_borrow_user_attributes_const(
+ const struct bt_stream_class *stream_class)
+{
+ BT_ASSERT_PRE_DEV_NON_NULL(stream_class, "Stream class");
+ return stream_class->user_attributes;
+}
+
+struct bt_value *bt_stream_class_borrow_user_attributes(
+ struct bt_stream_class *stream_class)
+{
+ return (void *) bt_stream_class_borrow_user_attributes_const(
+ (void *) stream_class);
+}
+
+void bt_stream_class_set_user_attributes(
+ struct bt_stream_class *stream_class,
+ const struct bt_value *user_attributes)
+{
+ BT_ASSERT_PRE_NON_NULL(stream_class, "Stream class");
+ BT_ASSERT_PRE_NON_NULL(user_attributes, "User attributes");
+ BT_ASSERT_PRE(user_attributes->type == BT_VALUE_TYPE_MAP,
+ "User attributes object is not a map value object.");
+ BT_ASSERT_PRE_DEV_STREAM_CLASS_HOT(stream_class);
+ bt_object_put_no_null_check(stream_class->user_attributes);
+ stream_class->user_attributes = (void *) user_attributes;
+ bt_object_get_no_null_check(stream_class->user_attributes);
+}
+
void bt_stream_class_get_ref(const struct bt_stream_class *stream_class)
{
bt_object_get_ref(stream_class);
struct bt_stream_class {
struct bt_object base;
+ /* Owned by this */
+ struct bt_value *user_attributes;
+
struct {
GString *str;
#include "stream-class.h"
#include "stream.h"
#include "trace.h"
+#include "lib/value.h"
#include "lib/func-status.h"
#define BT_ASSERT_PRE_DEV_STREAM_HOT(_stream) \
struct bt_stream *stream = (void *) obj;
BT_LIB_LOGD("Destroying stream object: %!+s", stream);
+ BT_OBJECT_PUT_REF_AND_RESET(stream->user_attributes);
if (stream->name.str) {
g_string_free(stream->name.str, TRUE);
}
bt_object_init_shared_with_parent(&stream->base, destroy_stream);
+ stream->user_attributes = bt_value_map_create();
+ if (!stream->user_attributes) {
+ BT_LIB_LOGE_APPEND_CAUSE(
+ "Failed to create a map value object.");
+ goto error;
+ }
+
stream->name.str = g_string_new(NULL);
if (!stream->name.str) {
BT_LIB_LOGE_APPEND_CAUSE("Failed to allocate a GString.");
void _bt_stream_freeze(const struct bt_stream *stream)
{
BT_ASSERT(stream);
+ BT_LIB_LOGD("Freezing stream's user attributes: %!+v",
+ stream->user_attributes);
+ bt_value_freeze(stream->user_attributes);
BT_LIB_LOGD("Freezing stream: %!+s", stream);
((struct bt_stream *) stream)->frozen = true;
}
+const struct bt_value *bt_stream_borrow_user_attributes_const(
+ const struct bt_stream *stream)
+{
+ BT_ASSERT_PRE_DEV_NON_NULL(stream, "Stream");
+ return stream->user_attributes;
+}
+
+struct bt_value *bt_stream_borrow_user_attributes(struct bt_stream *stream)
+{
+ return (void *) bt_stream_borrow_user_attributes_const((void *) stream);
+}
+
+void bt_stream_set_user_attributes(struct bt_stream *stream,
+ const struct bt_value *user_attributes)
+{
+ BT_ASSERT_PRE_NON_NULL(stream, "Stream");
+ BT_ASSERT_PRE_NON_NULL(user_attributes, "User attributes");
+ BT_ASSERT_PRE(user_attributes->type == BT_VALUE_TYPE_MAP,
+ "User attributes object is not a map value object.");
+ BT_ASSERT_PRE_DEV_STREAM_HOT(stream);
+ bt_object_put_no_null_check(stream->user_attributes);
+ stream->user_attributes = (void *) user_attributes;
+ bt_object_get_no_null_check(stream->user_attributes);
+}
+
void bt_stream_get_ref(const struct bt_stream *stream)
{
bt_object_get_ref(stream);
struct bt_stream {
struct bt_object base;
+ /* Owned by this */
+ struct bt_value *user_attributes;
+
/* Owned by this */
struct bt_stream_class *class;
#include "stream.h"
#include "trace.h"
#include "utils.h"
+#include "lib/value.h"
#include "lib/func-status.h"
struct bt_trace_class_destruction_listener_elem {
struct bt_trace_class *tc = (void *) obj;
BT_LIB_LOGD("Destroying trace class object: %!+T", tc);
+ BT_OBJECT_PUT_REF_AND_RESET(tc->user_attributes);
+
/*
* Call destruction listener functions so that everything else
* still exists in the trace class.
}
bt_object_init_shared_with_parent(&tc->base, destroy_trace_class);
+ tc->user_attributes = bt_value_map_create();
+ if (!tc->user_attributes) {
+ BT_LIB_LOGE_APPEND_CAUSE(
+ "Failed to create a map value object.");
+ goto error;
+ }
tc->stream_classes = g_ptr_array_new_with_free_func(
(GDestroyNotify) bt_object_try_spec_release);
"assignment property: %!+T", tc);
}
+const struct bt_value *bt_trace_class_borrow_user_attributes_const(
+ const struct bt_trace_class *trace_class)
+{
+ BT_ASSERT_PRE_DEV_NON_NULL(trace_class, "Trace class");
+ return trace_class->user_attributes;
+}
+
+struct bt_value *bt_trace_class_borrow_user_attributes(
+ struct bt_trace_class *trace_class)
+{
+ return (void *) bt_trace_class_borrow_user_attributes_const(
+ (void *) trace_class);
+}
+
+void bt_trace_class_set_user_attributes(struct bt_trace_class *trace_class,
+ const struct bt_value *user_attributes)
+{
+ BT_ASSERT_PRE_NON_NULL(trace_class, "Trace class");
+ BT_ASSERT_PRE_NON_NULL(user_attributes, "User attributes");
+ BT_ASSERT_PRE(user_attributes->type == BT_VALUE_TYPE_MAP,
+ "User attributes object is not a map value object.");
+ BT_ASSERT_PRE_DEV_TRACE_CLASS_HOT(trace_class);
+ bt_object_put_no_null_check(trace_class->user_attributes);
+ trace_class->user_attributes = (void *) user_attributes;
+ bt_object_get_no_null_check(trace_class->user_attributes);
+}
+
void bt_trace_class_get_ref(const struct bt_trace_class *trace_class)
{
bt_object_get_ref(trace_class);
struct bt_trace_class {
struct bt_object base;
+ /* Owned by this */
+ struct bt_value *user_attributes;
+
/* Array of `struct bt_stream_class *` */
GPtrArray *stream_classes;
#include "trace-class.h"
#include "trace.h"
#include "utils.h"
+#include "lib/value.h"
#include "lib/func-status.h"
struct bt_trace_destruction_listener_elem {
struct bt_trace *trace = (void *) obj;
BT_LIB_LOGD("Destroying trace object: %!+t", trace);
+ BT_OBJECT_PUT_REF_AND_RESET(trace->user_attributes);
/*
* Call destruction listener functions so that everything else
}
bt_object_init_shared(&trace->base, destroy_trace);
+ trace->user_attributes = bt_value_map_create();
+ if (!trace->user_attributes) {
+ BT_LIB_LOGE_APPEND_CAUSE(
+ "Failed to create a map value object.");
+ goto error;
+ }
+
trace->streams = g_ptr_array_new_with_free_func(
(GDestroyNotify) bt_object_try_spec_release);
if (!trace->streams) {
BT_ASSERT(trace);
BT_LIB_LOGD("Freezing trace's class: %!+T", trace->class);
bt_trace_class_freeze(trace->class);
+ BT_LIB_LOGD("Freezing trace's user attributes: %!+v",
+ trace->user_attributes);
+ bt_value_freeze(trace->user_attributes);
BT_LIB_LOGD("Freezing trace: %!+t", trace);
((struct bt_trace *) trace)->frozen = true;
}
return bt_trace_borrow_class((void *) trace);
}
+const struct bt_value *bt_trace_borrow_user_attributes_const(
+ const struct bt_trace *trace)
+{
+ BT_ASSERT_PRE_DEV_NON_NULL(trace, "Trace");
+ return trace->user_attributes;
+}
+
+struct bt_value *bt_trace_borrow_user_attributes(struct bt_trace *trace)
+{
+ return (void *) bt_trace_borrow_user_attributes_const((void *) trace);
+}
+
+void bt_trace_set_user_attributes(
+ struct bt_trace *trace,
+ const struct bt_value *user_attributes)
+{
+ BT_ASSERT_PRE_NON_NULL(trace, "Trace");
+ BT_ASSERT_PRE_NON_NULL(user_attributes, "User attributes");
+ BT_ASSERT_PRE(user_attributes->type == BT_VALUE_TYPE_MAP,
+ "User attributes object is not a map value object.");
+ BT_ASSERT_PRE_DEV_TRACE_HOT(trace);
+ bt_object_put_no_null_check(trace->user_attributes);
+ trace->user_attributes = (void *) user_attributes;
+ bt_object_get_no_null_check(trace->user_attributes);
+}
+
void bt_trace_get_ref(const struct bt_trace *trace)
{
bt_object_get_ref(trace);
struct bt_trace {
struct bt_object base;
+ /* Owned by this */
+ struct bt_value *user_attributes;
+
/* Owned by this */
struct bt_trace_class *class;