[lttng-tools.git] / src / common / event-field-value.cpp

/*
 * event-field-value.c
 *
 * Linux Trace Toolkit Control Library
 *
 * Copyright (C) 2020 Philippe Proulx <pproulx@efficios.com>
 *
 * SPDX-License-Identifier: LGPL-2.1-only
 *
 */

#define _LGPL_SOURCE
#include <common/error.hpp>
#include <common/macros.hpp>

#include <lttng/event-field-value-internal.hpp>

#include <stdbool.h>
#include <stddef.h>

static struct lttng_event_field_value *
create_empty_field_val(enum lttng_event_field_value_type type, size_t size)
{
	struct lttng_event_field_value *field_val;

	field_val = zmalloc<lttng_event_field_value>(size);
	if (!field_val) {
		goto end;
	}

	field_val->type = type;

end:
	return field_val;
}

struct lttng_event_field_value *lttng_event_field_value_uint_create(uint64_t val)
{
	struct lttng_event_field_value_uint *field_val;

	field_val = lttng::utils::container_of(
		create_empty_field_val(LTTNG_EVENT_FIELD_VALUE_TYPE_UNSIGNED_INT,
				       sizeof(*field_val)),
		&lttng_event_field_value_uint::parent);
	if (!field_val) {
		goto error;
	}

	field_val->val = val;
	goto end;

error:
	lttng_event_field_value_destroy(&field_val->parent);

end:
	return &field_val->parent;
}

struct lttng_event_field_value *lttng_event_field_value_int_create(int64_t val)
{
	struct lttng_event_field_value_int *field_val;

	field_val = lttng::utils::container_of(
		create_empty_field_val(LTTNG_EVENT_FIELD_VALUE_TYPE_SIGNED_INT, sizeof(*field_val)),
		&lttng_event_field_value_int::parent);
	if (!field_val) {
		goto error;
	}

	field_val->val = val;
	goto end;

error:
	lttng_event_field_value_destroy(&field_val->parent);

end:
	return &field_val->parent;
}

static struct lttng_event_field_value_enum *
create_enum_field_val(enum lttng_event_field_value_type type, size_t size)
{
	struct lttng_event_field_value_enum *field_val;

	field_val = lttng::utils::container_of(create_empty_field_val(type, size),
					       &lttng_event_field_value_enum::parent);
	if (!field_val) {
		goto error;
	}

	lttng_dynamic_pointer_array_init(&field_val->labels, free);
	goto end;

error:
	lttng_event_field_value_destroy(&field_val->parent);

end:
	return field_val;
}

struct lttng_event_field_value *lttng_event_field_value_enum_uint_create(uint64_t val)
{
	struct lttng_event_field_value_enum_uint *field_val;

	field_val = lttng::utils::container_of(
		create_enum_field_val(LTTNG_EVENT_FIELD_VALUE_TYPE_UNSIGNED_ENUM,
				      sizeof(*field_val)),
		&lttng_event_field_value_enum_uint::parent);
	if (!field_val) {
		goto error;
	}

	field_val->val = val;
	goto end;

error:
	lttng_event_field_value_destroy(&field_val->parent.parent);

end:
	return &field_val->parent.parent;
}

struct lttng_event_field_value *lttng_event_field_value_enum_int_create(int64_t val)
{
	struct lttng_event_field_value_enum_int *field_val;

	field_val = lttng::utils::container_of(
		create_enum_field_val(LTTNG_EVENT_FIELD_VALUE_TYPE_SIGNED_ENUM, sizeof(*field_val)),
		&lttng_event_field_value_enum_int::parent);
	if (!field_val) {
		goto error;
	}

	field_val->val = val;
	goto end;

error:
	lttng_event_field_value_destroy(&field_val->parent.parent);

end:
	return &field_val->parent.parent;
}

struct lttng_event_field_value *lttng_event_field_value_real_create(double val)
{
	struct lttng_event_field_value_real *field_val = lttng::utils::container_of(
		create_empty_field_val(LTTNG_EVENT_FIELD_VALUE_TYPE_REAL, sizeof(*field_val)),
		&lttng_event_field_value_real::parent);

	if (!field_val) {
		goto error;
	}

	field_val->val = val;
	goto end;

error:
	lttng_event_field_value_destroy(&field_val->parent);

end:
	return &field_val->parent;
}

struct lttng_event_field_value *lttng_event_field_value_string_create_with_size(const char *val,
										size_t size)
{
	struct lttng_event_field_value_string *field_val = lttng::utils::container_of(
		create_empty_field_val(LTTNG_EVENT_FIELD_VALUE_TYPE_STRING, sizeof(*field_val)),
		&lttng_event_field_value_string::parent);

	if (!field_val) {
		goto error;
	}

	if (size) {
		LTTNG_ASSERT(val);
		field_val->val = strndup(val, size);
	} else {
		/*
		 * User code do not expect a NULL string pointer. Populate with
		 * an empty string when length is 0.
		 */
		field_val->val = strdup("");
	}
	if (!field_val->val) {
		goto error;
	}

	goto end;

error:
	lttng_event_field_value_destroy(&field_val->parent);

end:
	return &field_val->parent;
}

struct lttng_event_field_value *lttng_event_field_value_string_create(const char *val)
{
	LTTNG_ASSERT(val);
	return lttng_event_field_value_string_create_with_size(val, strlen(val));
}

static void destroy_field_val(void *field_val)
{
	lttng_event_field_value_destroy((lttng_event_field_value *) field_val);
}

struct lttng_event_field_value *lttng_event_field_value_array_create()
{
	struct lttng_event_field_value_array *field_val = lttng::utils::container_of(
		create_empty_field_val(LTTNG_EVENT_FIELD_VALUE_TYPE_ARRAY, sizeof(*field_val)),
		&lttng_event_field_value_array::parent);

	if (!field_val) {
		goto error;
	}

	lttng_dynamic_pointer_array_init(&field_val->elems, destroy_field_val);
	goto end;

error:
	lttng_event_field_value_destroy(&field_val->parent);

end:
	return &field_val->parent;
}

void lttng_event_field_value_destroy(struct lttng_event_field_value *field_val)
{
	if (!field_val) {
		goto end;
	}

	switch (field_val->type) {
	case LTTNG_EVENT_FIELD_VALUE_TYPE_UNSIGNED_ENUM:
	case LTTNG_EVENT_FIELD_VALUE_TYPE_SIGNED_ENUM:
	{
		struct lttng_event_field_value_enum *enum_field_val = lttng::utils::container_of(
			field_val, &lttng_event_field_value_enum::parent);

		lttng_dynamic_pointer_array_reset(&enum_field_val->labels);
		break;
	}
	case LTTNG_EVENT_FIELD_VALUE_TYPE_STRING:
	{
		struct lttng_event_field_value_string *str_field_val = lttng::utils::container_of(
			field_val, &lttng_event_field_value_string::parent);

		free(str_field_val->val);
		break;
	}
	case LTTNG_EVENT_FIELD_VALUE_TYPE_ARRAY:
	{
		struct lttng_event_field_value_array *array_field_expr = lttng::utils::container_of(
			field_val, &lttng_event_field_value_array::parent);

		lttng_dynamic_pointer_array_reset(&array_field_expr->elems);
		break;
	}
	default:
		break;
	}

	free(field_val);

end:
	return;
}

int lttng_event_field_value_enum_append_label_with_size(struct lttng_event_field_value *field_val,
							const char *label,
							size_t size)
{
	int ret;
	char *new_label;

	LTTNG_ASSERT(field_val);
	LTTNG_ASSERT(label);
	new_label = strndup(label, size);
	if (!new_label) {
		ret = -1;
		goto end;
	}

	ret = lttng_dynamic_pointer_array_add_pointer(
		&lttng::utils::container_of(field_val, &lttng_event_field_value_enum::parent)
			 ->labels,
		new_label);
	if (ret == 0) {
		new_label = nullptr;
	}

end:
	free(new_label);
	return ret;
}

int lttng_event_field_value_enum_append_label(struct lttng_event_field_value *field_val,
					      const char *label)
{
	LTTNG_ASSERT(label);
	return lttng_event_field_value_enum_append_label_with_size(field_val, label, strlen(label));
}

int lttng_event_field_value_array_append(struct lttng_event_field_value *array_field_val,
					 struct lttng_event_field_value *field_val)
{
	LTTNG_ASSERT(array_field_val);
	LTTNG_ASSERT(field_val);
	return lttng_dynamic_pointer_array_add_pointer(
		&lttng::utils::container_of(array_field_val, &lttng_event_field_value_array::parent)
			 ->elems,
		field_val);
}

int lttng_event_field_value_array_append_unavailable(struct lttng_event_field_value *array_field_val)
{
	LTTNG_ASSERT(array_field_val);
	return lttng_dynamic_pointer_array_add_pointer(
		&lttng::utils::container_of(array_field_val, &lttng_event_field_value_array::parent)
			 ->elems,
		nullptr);
}

enum lttng_event_field_value_type
lttng_event_field_value_get_type(const struct lttng_event_field_value *field_val)
{
	enum lttng_event_field_value_type type;

	if (!field_val) {
		type = LTTNG_EVENT_FIELD_VALUE_TYPE_INVALID;
		goto end;
	}

	type = field_val->type;

end:
	return type;
}

enum lttng_event_field_value_status
lttng_event_field_value_unsigned_int_get_value(const struct lttng_event_field_value *field_val,
					       uint64_t *val)
{
	enum lttng_event_field_value_status status;

	if (!field_val || !val) {
		status = LTTNG_EVENT_FIELD_VALUE_STATUS_INVALID;
		goto end;
	}

	switch (field_val->type) {
	case LTTNG_EVENT_FIELD_VALUE_TYPE_UNSIGNED_INT:
		*val = lttng::utils::container_of(field_val, &lttng_event_field_value_uint::parent)
			       ->val;
		break;
	case LTTNG_EVENT_FIELD_VALUE_TYPE_UNSIGNED_ENUM:
	{
		const struct lttng_event_field_value_enum *field_val_enum =
			lttng::utils::container_of(field_val,
						   &lttng_event_field_value_enum::parent);
		const struct lttng_event_field_value_enum_uint *field_val_enum_uint =
			lttng::utils::container_of(field_val_enum,
						   &lttng_event_field_value_enum_uint::parent);
		*val = field_val_enum_uint->val;
		break;
	}
	default:
		status = LTTNG_EVENT_FIELD_VALUE_STATUS_INVALID;
		goto end;
	}

	status = LTTNG_EVENT_FIELD_VALUE_STATUS_OK;

end:
	return status;
}

enum lttng_event_field_value_status
lttng_event_field_value_signed_int_get_value(const struct lttng_event_field_value *field_val,
					     int64_t *val)
{
	enum lttng_event_field_value_status status;

	if (!field_val || !val) {
		status = LTTNG_EVENT_FIELD_VALUE_STATUS_INVALID;
		goto end;
	}

	switch (field_val->type) {
	case LTTNG_EVENT_FIELD_VALUE_TYPE_SIGNED_INT:
		*val = lttng::utils::container_of(field_val, &lttng_event_field_value_int::parent)
			       ->val;
		break;
	case LTTNG_EVENT_FIELD_VALUE_TYPE_SIGNED_ENUM:
	{
		const struct lttng_event_field_value_enum *field_val_enum =
			lttng::utils::container_of(field_val,
						   &lttng_event_field_value_enum::parent);
		const struct lttng_event_field_value_enum_int *field_val_enum_uint =
			lttng::utils::container_of(field_val_enum,
						   &lttng_event_field_value_enum_int::parent);
		*val = field_val_enum_uint->val;
		break;
	}
	default:
		status = LTTNG_EVENT_FIELD_VALUE_STATUS_INVALID;
		goto end;
	}

	status = LTTNG_EVENT_FIELD_VALUE_STATUS_OK;

end:
	return status;
}

enum lttng_event_field_value_status
lttng_event_field_value_real_get_value(const struct lttng_event_field_value *field_val, double *val)
{
	enum lttng_event_field_value_status status;

	if (!field_val || field_val->type != LTTNG_EVENT_FIELD_VALUE_TYPE_REAL || !val) {
		status = LTTNG_EVENT_FIELD_VALUE_STATUS_INVALID;
		goto end;
	}

	*val = lttng::utils::container_of(field_val, &lttng_event_field_value_real::parent)->val;
	status = LTTNG_EVENT_FIELD_VALUE_STATUS_OK;

end:
	return status;
}

static bool is_enum_field_val(const struct lttng_event_field_value *field_val)
{
	return field_val->type == LTTNG_EVENT_FIELD_VALUE_TYPE_UNSIGNED_ENUM ||
		field_val->type == LTTNG_EVENT_FIELD_VALUE_TYPE_SIGNED_ENUM;
}

enum lttng_event_field_value_status
lttng_event_field_value_enum_get_label_count(const struct lttng_event_field_value *field_val,
					     unsigned int *count)
{
	enum lttng_event_field_value_status status;

	if (!field_val || !is_enum_field_val(field_val) || !count) {
		status = LTTNG_EVENT_FIELD_VALUE_STATUS_INVALID;
		goto end;
	}

	*count = (unsigned int) lttng_dynamic_pointer_array_get_count(
		&lttng::utils::container_of(field_val, &lttng_event_field_value_enum::parent)
			 ->labels);
	status = LTTNG_EVENT_FIELD_VALUE_STATUS_OK;

end:
	return status;
}

const char *
lttng_event_field_value_enum_get_label_at_index(const struct lttng_event_field_value *field_val,
						unsigned int index)
{
	const char *ret;
	const struct lttng_event_field_value_enum *enum_field_val;

	if (!field_val || !is_enum_field_val(field_val)) {
		ret = nullptr;
		goto end;
	}

	enum_field_val =
		lttng::utils::container_of(field_val, &lttng_event_field_value_enum::parent);

	if (index >= lttng_dynamic_pointer_array_get_count(&enum_field_val->labels)) {
		ret = nullptr;
		goto end;
	}

	ret = (const char *) lttng_dynamic_pointer_array_get_pointer(&enum_field_val->labels,
								     index);

end:
	return ret;
}

enum lttng_event_field_value_status
lttng_event_field_value_string_get_value(const struct lttng_event_field_value *field_val,
					 const char **value)
{
	enum lttng_event_field_value_status status;

	if (!field_val || field_val->type != LTTNG_EVENT_FIELD_VALUE_TYPE_STRING) {
		status = LTTNG_EVENT_FIELD_VALUE_STATUS_INVALID;
		goto end;
	}

	*value =
		lttng::utils::container_of(field_val, &lttng_event_field_value_string::parent)->val;
	status = LTTNG_EVENT_FIELD_VALUE_STATUS_OK;

end:
	return status;
}

enum lttng_event_field_value_status
lttng_event_field_value_array_get_length(const struct lttng_event_field_value *field_val,
					 unsigned int *length)
{
	enum lttng_event_field_value_status status;

	if (!field_val || field_val->type != LTTNG_EVENT_FIELD_VALUE_TYPE_ARRAY || !length) {
		status = LTTNG_EVENT_FIELD_VALUE_STATUS_INVALID;
		goto end;
	}

	*length = (unsigned int) lttng_dynamic_pointer_array_get_count(
		&lttng::utils::container_of(field_val, &lttng_event_field_value_array::parent)
			 ->elems);
	status = LTTNG_EVENT_FIELD_VALUE_STATUS_OK;

end:
	return status;
}

enum lttng_event_field_value_status lttng_event_field_value_array_get_element_at_index(
	const struct lttng_event_field_value *field_val,
	unsigned int index,
	const struct lttng_event_field_value **elem_field_val)
{
	enum lttng_event_field_value_status status;
	const struct lttng_event_field_value_array *array_field_val;

	if (!field_val || field_val->type != LTTNG_EVENT_FIELD_VALUE_TYPE_ARRAY ||
	    !elem_field_val) {
		status = LTTNG_EVENT_FIELD_VALUE_STATUS_INVALID;
		goto end;
	}

	array_field_val =
		lttng::utils::container_of(field_val, &lttng_event_field_value_array::parent);

	if (index >= lttng_dynamic_pointer_array_get_count(&array_field_val->elems)) {
		status = LTTNG_EVENT_FIELD_VALUE_STATUS_INVALID;
		goto end;
	}

	*elem_field_val = (lttng_event_field_value *) lttng_dynamic_pointer_array_get_pointer(
		&array_field_val->elems, index);
	if (*elem_field_val) {
		status = LTTNG_EVENT_FIELD_VALUE_STATUS_OK;
	} else {
		status = LTTNG_EVENT_FIELD_VALUE_STATUS_UNAVAILABLE;
	}

end:
	return status;
}
Commit	Line	Data
d28fcdec PP	1	/*
	2	* event-field-value.c
	3	*
	4	* Linux Trace Toolkit Control Library
	5	*
	6	* Copyright (C) 2020 Philippe Proulx <pproulx@efficios.com>
	7	*
	8	* SPDX-License-Identifier: LGPL-2.1-only
	9	*
	10	*/
	11
	12	#define _LGPL_SOURCE
c9e313bc SM	13	#include <common/error.hpp>
c9e313bc SM	14	#include <common/macros.hpp>
28ab034a	15
c9e313bc	16	#include <lttng/event-field-value-internal.hpp>
d28fcdec	17
28ab034a JG	18	#include <stdbool.h>
	19	#include <stddef.h>
	20
	21	static struct lttng_event_field_value *
	22	create_empty_field_val(enum lttng_event_field_value_type type, size_t size)
d28fcdec PP	23	{
	24	struct lttng_event_field_value *field_val;
	25
64803277	26	field_val = zmalloc<lttng_event_field_value>(size);
d28fcdec PP	27	if (!field_val) {
	28	goto end;
	29	}
	30
	31	field_val->type = type;
	32
	33	end:
	34	return field_val;
	35	}
	36
28ab034a	37	struct lttng_event_field_value *lttng_event_field_value_uint_create(uint64_t val)
d28fcdec PP	38	{
	39	struct lttng_event_field_value_uint *field_val;
	40
28ab034a JG	41	field_val = lttng::utils::container_of(
	42	create_empty_field_val(LTTNG_EVENT_FIELD_VALUE_TYPE_UNSIGNED_INT,
	43	sizeof(*field_val)),
	44	&lttng_event_field_value_uint::parent);
d28fcdec PP	45	if (!field_val) {
	46	goto error;
	47	}
	48
	49	field_val->val = val;
	50	goto end;
	51
	52	error:
	53	lttng_event_field_value_destroy(&field_val->parent);
	54
	55	end:
	56	return &field_val->parent;
	57	}
	58
28ab034a	59	struct lttng_event_field_value *lttng_event_field_value_int_create(int64_t val)
d28fcdec PP	60	{
	61	struct lttng_event_field_value_int *field_val;
	62
28ab034a JG	63	field_val = lttng::utils::container_of(
	64	create_empty_field_val(LTTNG_EVENT_FIELD_VALUE_TYPE_SIGNED_INT, sizeof(*field_val)),
	65	&lttng_event_field_value_int::parent);
d28fcdec PP	66	if (!field_val) {
	67	goto error;
	68	}
	69
	70	field_val->val = val;
	71	goto end;
	72
	73	error:
	74	lttng_event_field_value_destroy(&field_val->parent);
	75
	76	end:
	77	return &field_val->parent;
	78	}
	79
28ab034a JG	80	static struct lttng_event_field_value_enum *
28ab034a JG	81	create_enum_field_val(enum lttng_event_field_value_type type, size_t size)
d28fcdec PP	82	{
	83	struct lttng_event_field_value_enum *field_val;
	84
0114db0e	85	field_val = lttng::utils::container_of(create_empty_field_val(type, size),
28ab034a	86	&lttng_event_field_value_enum::parent);
d28fcdec PP	87	if (!field_val) {
	88	goto error;
	89	}
	90
	91	lttng_dynamic_pointer_array_init(&field_val->labels, free);
	92	goto end;
	93
	94	error:
	95	lttng_event_field_value_destroy(&field_val->parent);
	96
	97	end:
	98	return field_val;
	99	}
	100
28ab034a	101	struct lttng_event_field_value *lttng_event_field_value_enum_uint_create(uint64_t val)
d28fcdec PP	102	{
	103	struct lttng_event_field_value_enum_uint *field_val;
	104
28ab034a JG	105	field_val = lttng::utils::container_of(
	106	create_enum_field_val(LTTNG_EVENT_FIELD_VALUE_TYPE_UNSIGNED_ENUM,
	107	sizeof(*field_val)),
	108	&lttng_event_field_value_enum_uint::parent);
d28fcdec PP	109	if (!field_val) {
	110	goto error;
	111	}
	112
	113	field_val->val = val;
	114	goto end;
	115
	116	error:
	117	lttng_event_field_value_destroy(&field_val->parent.parent);
	118
	119	end:
	120	return &field_val->parent.parent;
	121	}
	122
28ab034a	123	struct lttng_event_field_value *lttng_event_field_value_enum_int_create(int64_t val)
d28fcdec PP	124	{
	125	struct lttng_event_field_value_enum_int *field_val;
	126
28ab034a JG	127	field_val = lttng::utils::container_of(
	128	create_enum_field_val(LTTNG_EVENT_FIELD_VALUE_TYPE_SIGNED_ENUM, sizeof(*field_val)),
	129	&lttng_event_field_value_enum_int::parent);
d28fcdec PP	130	if (!field_val) {
	131	goto error;
	132	}
	133
	134	field_val->val = val;
	135	goto end;
	136
	137	error:
	138	lttng_event_field_value_destroy(&field_val->parent.parent);
	139
	140	end:
	141	return &field_val->parent.parent;
	142	}
	143
d28fcdec PP	144	struct lttng_event_field_value *lttng_event_field_value_real_create(double val)
d28fcdec PP	145	{
0114db0e	146	struct lttng_event_field_value_real *field_val = lttng::utils::container_of(
28ab034a JG	147	create_empty_field_val(LTTNG_EVENT_FIELD_VALUE_TYPE_REAL, sizeof(*field_val)),
28ab034a JG	148	&lttng_event_field_value_real::parent);
d28fcdec PP	149
	150	if (!field_val) {
	151	goto error;
	152	}
	153
	154	field_val->val = val;
	155	goto end;
	156
	157	error:
	158	lttng_event_field_value_destroy(&field_val->parent);
	159
	160	end:
	161	return &field_val->parent;
	162	}
	163
28ab034a JG	164	struct lttng_event_field_value lttng_event_field_value_string_create_with_size(const char val,
28ab034a JG	165	size_t size)
d28fcdec	166	{
0114db0e	167	struct lttng_event_field_value_string *field_val = lttng::utils::container_of(
28ab034a JG	168	create_empty_field_val(LTTNG_EVENT_FIELD_VALUE_TYPE_STRING, sizeof(*field_val)),
28ab034a JG	169	&lttng_event_field_value_string::parent);
d28fcdec PP	170
	171	if (!field_val) {
	172	goto error;
	173	}
	174
ceaa850a MD	175	if (size) {
	176	LTTNG_ASSERT(val);
	177	field_val->val = strndup(val, size);
	178	} else {
	179	/*
	180	* User code do not expect a NULL string pointer. Populate with
	181	* an empty string when length is 0.
	182	*/
	183	field_val->val = strdup("");
	184	}
d28fcdec PP	185	if (!field_val->val) {
	186	goto error;
	187	}
	188
	189	goto end;
	190
	191	error:
	192	lttng_event_field_value_destroy(&field_val->parent);
	193
	194	end:
	195	return &field_val->parent;
	196	}
	197
28ab034a	198	struct lttng_event_field_value lttng_event_field_value_string_create(const char val)
d28fcdec	199	{
a0377dfe	200	LTTNG_ASSERT(val);
28ab034a	201	return lttng_event_field_value_string_create_with_size(val, strlen(val));
d28fcdec PP	202	}
d28fcdec PP	203
28ab034a	204	static void destroy_field_val(void *field_val)
d28fcdec	205	{
a6bc4ca9	206	lttng_event_field_value_destroy((lttng_event_field_value *) field_val);
d28fcdec PP	207	}
d28fcdec PP	208
cd9adb8b	209	struct lttng_event_field_value *lttng_event_field_value_array_create()
d28fcdec	210	{
0114db0e	211	struct lttng_event_field_value_array *field_val = lttng::utils::container_of(
28ab034a JG	212	create_empty_field_val(LTTNG_EVENT_FIELD_VALUE_TYPE_ARRAY, sizeof(*field_val)),
28ab034a JG	213	&lttng_event_field_value_array::parent);
d28fcdec PP	214
	215	if (!field_val) {
	216	goto error;
	217	}
	218
	219	lttng_dynamic_pointer_array_init(&field_val->elems, destroy_field_val);
	220	goto end;
	221
	222	error:
	223	lttng_event_field_value_destroy(&field_val->parent);
	224
	225	end:
	226	return &field_val->parent;
	227	}
	228
d28fcdec PP	229	void lttng_event_field_value_destroy(struct lttng_event_field_value *field_val)
	230	{
	231	if (!field_val) {
	232	goto end;
	233	}
	234
	235	switch (field_val->type) {
	236	case LTTNG_EVENT_FIELD_VALUE_TYPE_UNSIGNED_ENUM:
	237	case LTTNG_EVENT_FIELD_VALUE_TYPE_SIGNED_ENUM:
	238	{
28ab034a JG	239	struct lttng_event_field_value_enum *enum_field_val = lttng::utils::container_of(
28ab034a JG	240	field_val, &lttng_event_field_value_enum::parent);
d28fcdec PP	241
	242	lttng_dynamic_pointer_array_reset(&enum_field_val->labels);
	243	break;
	244	}
	245	case LTTNG_EVENT_FIELD_VALUE_TYPE_STRING:
	246	{
28ab034a JG	247	struct lttng_event_field_value_string *str_field_val = lttng::utils::container_of(
28ab034a JG	248	field_val, &lttng_event_field_value_string::parent);
d28fcdec PP	249
	250	free(str_field_val->val);
	251	break;
	252	}
	253	case LTTNG_EVENT_FIELD_VALUE_TYPE_ARRAY:
	254	{
28ab034a JG	255	struct lttng_event_field_value_array *array_field_expr = lttng::utils::container_of(
28ab034a JG	256	field_val, &lttng_event_field_value_array::parent);
d28fcdec PP	257
	258	lttng_dynamic_pointer_array_reset(&array_field_expr->elems);
	259	break;
	260	}
	261	default:
	262	break;
	263	}
	264
	265	free(field_val);
	266
	267	end:
	268	return;
	269	}
	270
28ab034a JG	271	int lttng_event_field_value_enum_append_label_with_size(struct lttng_event_field_value *field_val,
	272	const char *label,
	273	size_t size)
d28fcdec PP	274	{
	275	int ret;
	276	char *new_label;
	277
a0377dfe FD	278	LTTNG_ASSERT(field_val);
a0377dfe FD	279	LTTNG_ASSERT(label);
d28fcdec PP	280	new_label = strndup(label, size);
	281	if (!new_label) {
	282	ret = -1;
	283	goto end;
	284	}
	285
	286	ret = lttng_dynamic_pointer_array_add_pointer(
28ab034a JG	287	&lttng::utils::container_of(field_val, &lttng_event_field_value_enum::parent)
	288	->labels,
	289	new_label);
d28fcdec	290	if (ret == 0) {
cd9adb8b	291	new_label = nullptr;
d28fcdec PP	292	}
	293
	294	end:
	295	free(new_label);
	296	return ret;
	297	}
	298
28ab034a JG	299	int lttng_event_field_value_enum_append_label(struct lttng_event_field_value *field_val,
28ab034a JG	300	const char *label)
d28fcdec	301	{
a0377dfe	302	LTTNG_ASSERT(label);
28ab034a	303	return lttng_event_field_value_enum_append_label_with_size(field_val, label, strlen(label));
d28fcdec PP	304	}
d28fcdec PP	305
28ab034a JG	306	int lttng_event_field_value_array_append(struct lttng_event_field_value *array_field_val,
28ab034a JG	307	struct lttng_event_field_value *field_val)
d28fcdec	308	{
a0377dfe FD	309	LTTNG_ASSERT(array_field_val);
a0377dfe FD	310	LTTNG_ASSERT(field_val);
d28fcdec	311	return lttng_dynamic_pointer_array_add_pointer(
28ab034a JG	312	&lttng::utils::container_of(array_field_val, &lttng_event_field_value_array::parent)
	313	->elems,
	314	field_val);
d28fcdec PP	315	}
d28fcdec PP	316
28ab034a	317	int lttng_event_field_value_array_append_unavailable(struct lttng_event_field_value *array_field_val)
d28fcdec	318	{
a0377dfe	319	LTTNG_ASSERT(array_field_val);
d28fcdec	320	return lttng_dynamic_pointer_array_add_pointer(
28ab034a JG	321	&lttng::utils::container_of(array_field_val, &lttng_event_field_value_array::parent)
28ab034a JG	322	->elems,
cd9adb8b	323	nullptr);
d28fcdec PP	324	}
d28fcdec PP	325
28ab034a JG	326	enum lttng_event_field_value_type
28ab034a JG	327	lttng_event_field_value_get_type(const struct lttng_event_field_value *field_val)
d28fcdec PP	328	{
	329	enum lttng_event_field_value_type type;
	330
	331	if (!field_val) {
	332	type = LTTNG_EVENT_FIELD_VALUE_TYPE_INVALID;
	333	goto end;
	334	}
	335
	336	type = field_val->type;
	337
	338	end:
	339	return type;
	340	}
	341
	342	enum lttng_event_field_value_status
28ab034a JG	343	lttng_event_field_value_unsigned_int_get_value(const struct lttng_event_field_value *field_val,
28ab034a JG	344	uint64_t *val)
d28fcdec PP	345	{
	346	enum lttng_event_field_value_status status;
	347
	348	if (!field_val \|\| !val) {
	349	status = LTTNG_EVENT_FIELD_VALUE_STATUS_INVALID;
	350	goto end;
	351	}
	352
	353	switch (field_val->type) {
	354	case LTTNG_EVENT_FIELD_VALUE_TYPE_UNSIGNED_INT:
28ab034a JG	355	*val = lttng::utils::container_of(field_val, &lttng_event_field_value_uint::parent)
28ab034a JG	356	->val;
d28fcdec PP	357	break;
d28fcdec PP	358	case LTTNG_EVENT_FIELD_VALUE_TYPE_UNSIGNED_ENUM:
9918e00a	359	{
0114db0e	360	const struct lttng_event_field_value_enum *field_val_enum =
28ab034a JG	361	lttng::utils::container_of(field_val,
28ab034a JG	362	&lttng_event_field_value_enum::parent);
0114db0e	363	const struct lttng_event_field_value_enum_uint *field_val_enum_uint =
28ab034a JG	364	lttng::utils::container_of(field_val_enum,
28ab034a JG	365	&lttng_event_field_value_enum_uint::parent);
9918e00a	366	*val = field_val_enum_uint->val;
d28fcdec	367	break;
9918e00a	368	}
d28fcdec PP	369	default:
	370	status = LTTNG_EVENT_FIELD_VALUE_STATUS_INVALID;
	371	goto end;
	372	}
	373
	374	status = LTTNG_EVENT_FIELD_VALUE_STATUS_OK;
	375
	376	end:
	377	return status;
	378	}
	379
	380	enum lttng_event_field_value_status
28ab034a JG	381	lttng_event_field_value_signed_int_get_value(const struct lttng_event_field_value *field_val,
28ab034a JG	382	int64_t *val)
d28fcdec PP	383	{
	384	enum lttng_event_field_value_status status;
	385
	386	if (!field_val \|\| !val) {
	387	status = LTTNG_EVENT_FIELD_VALUE_STATUS_INVALID;
	388	goto end;
	389	}
	390
	391	switch (field_val->type) {
	392	case LTTNG_EVENT_FIELD_VALUE_TYPE_SIGNED_INT:
28ab034a JG	393	*val = lttng::utils::container_of(field_val, &lttng_event_field_value_int::parent)
28ab034a JG	394	->val;
d28fcdec PP	395	break;
d28fcdec PP	396	case LTTNG_EVENT_FIELD_VALUE_TYPE_SIGNED_ENUM:
9918e00a	397	{
28ab034a JG	398	const struct lttng_event_field_value_enum *field_val_enum =
	399	lttng::utils::container_of(field_val,
	400	&lttng_event_field_value_enum::parent);
0114db0e	401	const struct lttng_event_field_value_enum_int *field_val_enum_uint =
28ab034a JG	402	lttng::utils::container_of(field_val_enum,
28ab034a JG	403	&lttng_event_field_value_enum_int::parent);
9918e00a	404	*val = field_val_enum_uint->val;
d28fcdec	405	break;
9918e00a	406	}
d28fcdec PP	407	default:
	408	status = LTTNG_EVENT_FIELD_VALUE_STATUS_INVALID;
	409	goto end;
	410	}
	411
	412	status = LTTNG_EVENT_FIELD_VALUE_STATUS_OK;
	413
	414	end:
	415	return status;
	416	}
	417
	418	enum lttng_event_field_value_status
28ab034a	419	lttng_event_field_value_real_get_value(const struct lttng_event_field_value field_val, double val)
d28fcdec PP	420	{
	421	enum lttng_event_field_value_status status;
	422
28ab034a	423	if (!field_val \|\| field_val->type != LTTNG_EVENT_FIELD_VALUE_TYPE_REAL \|\| !val) {
d28fcdec PP	424	status = LTTNG_EVENT_FIELD_VALUE_STATUS_INVALID;
	425	goto end;
	426	}
	427
28ab034a	428	*val = lttng::utils::container_of(field_val, &lttng_event_field_value_real::parent)->val;
d28fcdec PP	429	status = LTTNG_EVENT_FIELD_VALUE_STATUS_OK;
	430
	431	end:
	432	return status;
	433	}
	434
28ab034a	435	static bool is_enum_field_val(const struct lttng_event_field_value *field_val)
d28fcdec PP	436	{
	437	return field_val->type == LTTNG_EVENT_FIELD_VALUE_TYPE_UNSIGNED_ENUM \|\|
	438	field_val->type == LTTNG_EVENT_FIELD_VALUE_TYPE_SIGNED_ENUM;
	439	}
	440
	441	enum lttng_event_field_value_status
28ab034a JG	442	lttng_event_field_value_enum_get_label_count(const struct lttng_event_field_value *field_val,
28ab034a JG	443	unsigned int *count)
d28fcdec PP	444	{
	445	enum lttng_event_field_value_status status;
	446
	447	if (!field_val \|\| !is_enum_field_val(field_val) \|\| !count) {
	448	status = LTTNG_EVENT_FIELD_VALUE_STATUS_INVALID;
	449	goto end;
	450	}
	451
	452	*count = (unsigned int) lttng_dynamic_pointer_array_get_count(
28ab034a JG	453	&lttng::utils::container_of(field_val, &lttng_event_field_value_enum::parent)
28ab034a JG	454	->labels);
d28fcdec PP	455	status = LTTNG_EVENT_FIELD_VALUE_STATUS_OK;
	456
	457	end:
	458	return status;
	459	}
	460
28ab034a JG	461	const char *
	462	lttng_event_field_value_enum_get_label_at_index(const struct lttng_event_field_value *field_val,
	463	unsigned int index)
d28fcdec PP	464	{
	465	const char *ret;
	466	const struct lttng_event_field_value_enum *enum_field_val;
	467
	468	if (!field_val \|\| !is_enum_field_val(field_val)) {
cd9adb8b	469	ret = nullptr;
d28fcdec PP	470	goto end;
	471	}
	472
28ab034a JG	473	enum_field_val =
28ab034a JG	474	lttng::utils::container_of(field_val, &lttng_event_field_value_enum::parent);
d28fcdec PP	475
d28fcdec PP	476	if (index >= lttng_dynamic_pointer_array_get_count(&enum_field_val->labels)) {
cd9adb8b	477	ret = nullptr;
d28fcdec PP	478	goto end;
	479	}
	480
a6bc4ca9	481	ret = (const char *) lttng_dynamic_pointer_array_get_pointer(&enum_field_val->labels,
28ab034a	482	index);
d28fcdec PP	483
	484	end:
	485	return ret;
	486	}
	487
28ab034a JG	488	enum lttng_event_field_value_status
	489	lttng_event_field_value_string_get_value(const struct lttng_event_field_value *field_val,
	490	const char **value)
d28fcdec	491	{
7c920b63	492	enum lttng_event_field_value_status status;
d28fcdec PP	493
d28fcdec PP	494	if (!field_val \|\| field_val->type != LTTNG_EVENT_FIELD_VALUE_TYPE_STRING) {
7c920b63	495	status = LTTNG_EVENT_FIELD_VALUE_STATUS_INVALID;
d28fcdec PP	496	goto end;
	497	}
	498
28ab034a JG	499	*value =
28ab034a JG	500	lttng::utils::container_of(field_val, &lttng_event_field_value_string::parent)->val;
7c920b63	501	status = LTTNG_EVENT_FIELD_VALUE_STATUS_OK;
d28fcdec PP	502
d28fcdec PP	503	end:
7c920b63	504	return status;
d28fcdec PP	505	}
d28fcdec PP	506
28ab034a JG	507	enum lttng_event_field_value_status
	508	lttng_event_field_value_array_get_length(const struct lttng_event_field_value *field_val,
	509	unsigned int *length)
d28fcdec PP	510	{
	511	enum lttng_event_field_value_status status;
	512
28ab034a	513	if (!field_val \|\| field_val->type != LTTNG_EVENT_FIELD_VALUE_TYPE_ARRAY \|\| !length) {
d28fcdec PP	514	status = LTTNG_EVENT_FIELD_VALUE_STATUS_INVALID;
	515	goto end;
	516	}
	517
	518	*length = (unsigned int) lttng_dynamic_pointer_array_get_count(
28ab034a JG	519	&lttng::utils::container_of(field_val, &lttng_event_field_value_array::parent)
28ab034a JG	520	->elems);
d28fcdec PP	521	status = LTTNG_EVENT_FIELD_VALUE_STATUS_OK;
	522
	523	end:
	524	return status;
	525	}
	526
28ab034a JG	527	enum lttng_event_field_value_status lttng_event_field_value_array_get_element_at_index(
	528	const struct lttng_event_field_value *field_val,
	529	unsigned int index,
	530	const struct lttng_event_field_value **elem_field_val)
d28fcdec PP	531	{
	532	enum lttng_event_field_value_status status;
	533	const struct lttng_event_field_value_array *array_field_val;
	534
	535	if (!field_val \|\| field_val->type != LTTNG_EVENT_FIELD_VALUE_TYPE_ARRAY \|\|
28ab034a	536	!elem_field_val) {
d28fcdec PP	537	status = LTTNG_EVENT_FIELD_VALUE_STATUS_INVALID;
	538	goto end;
	539	}
	540
28ab034a JG	541	array_field_val =
28ab034a JG	542	lttng::utils::container_of(field_val, &lttng_event_field_value_array::parent);
d28fcdec PP	543
	544	if (index >= lttng_dynamic_pointer_array_get_count(&array_field_val->elems)) {
	545	status = LTTNG_EVENT_FIELD_VALUE_STATUS_INVALID;
	546	goto end;
	547	}
	548
a6bc4ca9	549	elem_field_val = (lttng_event_field_value ) lttng_dynamic_pointer_array_get_pointer(
28ab034a	550	&array_field_val->elems, index);
d28fcdec PP	551	if (*elem_field_val) {
	552	status = LTTNG_EVENT_FIELD_VALUE_STATUS_OK;
	553	} else {
	554	status = LTTNG_EVENT_FIELD_VALUE_STATUS_UNAVAILABLE;
	555	}
	556
	557	end:
	558	return status;
	559	}