[babeltrace.git] / src / ctf-writer / trace.h

/*
 * SPDX-License-Identifier: MIT
 *
 * Copyright 2014 EfficiOS Inc.
 *
 * The Common Trace Format (CTF) Specification is available at
 * http://www.efficios.com/ctf
 */

#ifndef BABELTRACE_CTF_WRITER_TRACE_INTERNAL_H
#define BABELTRACE_CTF_WRITER_TRACE_INTERNAL_H

#include "common/macros.h"
#include "common/uuid.h"
#include <babeltrace2-ctf-writer/field-types.h>
#include <babeltrace2-ctf-writer/fields.h>
#include <babeltrace2-ctf-writer/trace.h>
#include <babeltrace2/types.h>
#include <glib.h>
#include <sys/types.h>

#include "assert-pre.h"
#include "attributes.h"
#include "clock-class.h"
#include "object.h"
#include "stream-class.h"
#include "validation.h"
#include "values.h"

struct bt_ctf_trace_common {
	struct bt_ctf_object base;
	GString *name;
	int frozen;
	bt_uuid_t uuid;
	bt_ctf_bool uuid_set;
	enum bt_ctf_byte_order native_byte_order;
	struct bt_ctf_private_value *environment;
	GPtrArray *clock_classes; /* Array of pointers to bt_ctf_clock_class */
	GPtrArray *stream_classes; /* Array of ptrs to bt_ctf_stream_class_common */
	GPtrArray *streams; /* Array of ptrs to bt_ctf_stream_common */
	struct bt_ctf_field_type_common *packet_header_field_type;
	int64_t next_stream_id;

	/*
	 * This flag indicates if the trace is valid. A valid
	 * trace is _always_ frozen.
	 */
	int valid;
};

bt_ctf_bool bt_ctf_trace_common_has_clock_class(struct bt_ctf_trace_common *trace,
		struct bt_ctf_clock_class *clock_class);

int bt_ctf_trace_common_initialize(struct bt_ctf_trace_common *trace,
		bt_ctf_object_release_func release_func);

void bt_ctf_trace_common_finalize(struct bt_ctf_trace_common *trace);

static inline
const char *bt_ctf_trace_common_get_name(struct bt_ctf_trace_common *trace)
{
	BT_CTF_ASSERT_PRE_NON_NULL(trace, "Trace");
	return trace->name ? trace->name->str : NULL;
}

int bt_ctf_trace_common_set_name(struct bt_ctf_trace_common *trace, const char *name);

static inline
const uint8_t *bt_ctf_trace_common_get_uuid(struct bt_ctf_trace_common *trace)
{
	BT_CTF_ASSERT_PRE_NON_NULL(trace, "Trace");
	return trace->uuid_set ? trace->uuid : NULL;
}

int bt_ctf_trace_common_set_uuid(struct bt_ctf_trace_common *trace, const uint8_t *uuid);

int bt_ctf_trace_common_set_environment_field(struct bt_ctf_trace_common *trace,
		const char *name, struct bt_ctf_private_value *value);

int bt_ctf_trace_common_set_environment_field_string(struct bt_ctf_trace_common *trace,
		const char *name, const char *value);

int bt_ctf_trace_common_set_environment_field_integer(struct bt_ctf_trace_common *trace,
		const char *name, int64_t value);

static inline
int64_t bt_ctf_trace_common_get_environment_field_count(
		struct bt_ctf_trace_common *trace)
{
	int64_t ret;

	BT_CTF_ASSERT_PRE_NON_NULL(trace, "Trace");
	ret = bt_ctf_attributes_get_count(trace->environment);
	BT_ASSERT_DBG(ret >= 0);
	return ret;
}

static inline
const char *
bt_ctf_trace_common_get_environment_field_name_by_index(
		struct bt_ctf_trace_common *trace, uint64_t index)
{
	BT_CTF_ASSERT_PRE_NON_NULL(trace, "Trace");
	return bt_ctf_attributes_get_field_name(trace->environment, index);
}

static inline
struct bt_ctf_private_value *
bt_ctf_trace_common_borrow_environment_field_value_by_index(
		struct bt_ctf_trace_common *trace, uint64_t index)
{
	BT_CTF_ASSERT_PRE_NON_NULL(trace, "Trace");
	return bt_ctf_attributes_borrow_field_value(trace->environment, index);
}

static inline
struct bt_ctf_private_value *
bt_ctf_trace_common_borrow_environment_field_value_by_name(
		struct bt_ctf_trace_common *trace, const char *name)
{
	BT_CTF_ASSERT_PRE_NON_NULL(trace, "Trace");
	BT_CTF_ASSERT_PRE_NON_NULL(name, "Name");
	return bt_ctf_attributes_borrow_field_value_by_name(trace->environment,
		name);
}

int bt_ctf_trace_common_add_clock_class(struct bt_ctf_trace_common *trace,
		struct bt_ctf_clock_class *clock_class);

static inline
int64_t bt_ctf_trace_common_get_clock_class_count(struct bt_ctf_trace_common *trace)
{
	BT_CTF_ASSERT_PRE_NON_NULL(trace, "Trace");
	return trace->clock_classes->len;
}

static inline
struct bt_ctf_clock_class *bt_ctf_trace_common_borrow_clock_class_by_index(
		struct bt_ctf_trace_common *trace, uint64_t index)
{
	BT_CTF_ASSERT_PRE_NON_NULL(trace, "Trace");
	BT_CTF_ASSERT_PRE(index < trace->clock_classes->len,
		"Index is out of bounds: index=%" PRIu64 ", "
		"count=%u",
		index, trace->clock_classes->len);
	return g_ptr_array_index(trace->clock_classes, index);
}

static inline
int64_t bt_ctf_trace_common_get_stream_count(struct bt_ctf_trace_common *trace)
{
	BT_CTF_ASSERT_PRE_NON_NULL(trace, "Trace");
	return (int64_t) trace->streams->len;
}

static inline
struct bt_ctf_stream_common *bt_ctf_trace_common_borrow_stream_by_index(
		struct bt_ctf_trace_common *trace,
		uint64_t index)
{
	BT_CTF_ASSERT_PRE_NON_NULL(trace, "Trace");
	BT_CTF_ASSERT_PRE(index < trace->streams->len,
		"Index is out of bounds: index=%" PRIu64 ", "
		"count=%u",
		index, trace->streams->len);
	return g_ptr_array_index(trace->streams, index);
}

static inline
int64_t bt_ctf_trace_common_get_stream_class_count(struct bt_ctf_trace_common *trace)
{
	BT_CTF_ASSERT_PRE_NON_NULL(trace, "Trace");
	return (int64_t) trace->stream_classes->len;
}

static inline
struct bt_ctf_stream_class_common *bt_ctf_trace_common_borrow_stream_class_by_index(
		struct bt_ctf_trace_common *trace, uint64_t index)
{
	BT_CTF_ASSERT_PRE_NON_NULL(trace, "Trace");
	BT_CTF_ASSERT_PRE(index < trace->stream_classes->len,
		"Index is out of bounds: index=%" PRIu64 ", "
		"count=%u",
		index, trace->stream_classes->len);
	return g_ptr_array_index(trace->stream_classes, index);
}

static inline
struct bt_ctf_stream_class_common *bt_ctf_trace_common_borrow_stream_class_by_id(
		struct bt_ctf_trace_common *trace, uint64_t id_param)
{
	int i;
	struct bt_ctf_stream_class_common *stream_class = NULL;
	int64_t id = (int64_t) id_param;

	BT_CTF_ASSERT_PRE_NON_NULL(trace, "Trace");
	BT_CTF_ASSERT_PRE(id >= 0,
		"Invalid stream class ID: %" PRIu64, id_param);

	for (i = 0; i < trace->stream_classes->len; i++) {
		struct bt_ctf_stream_class_common *stream_class_candidate;

		stream_class_candidate =
			g_ptr_array_index(trace->stream_classes, i);

		if (bt_ctf_stream_class_common_get_id(stream_class_candidate) ==
				(int64_t) id) {
			stream_class = stream_class_candidate;
			goto end;
		}
	}

end:
	return stream_class;
}

static inline
struct bt_ctf_clock_class *bt_ctf_trace_common_borrow_clock_class_by_name(
		struct bt_ctf_trace_common *trace, const char *name)
{
	size_t i;
	struct bt_ctf_clock_class *clock_class = NULL;

	BT_CTF_ASSERT_PRE_NON_NULL(trace, "Trace");
	BT_CTF_ASSERT_PRE_NON_NULL(name, "Name");

	for (i = 0; i < trace->clock_classes->len; i++) {
		struct bt_ctf_clock_class *cur_clk =
			g_ptr_array_index(trace->clock_classes, i);
		const char *cur_clk_name = bt_ctf_clock_class_get_name(cur_clk);

		if (!cur_clk_name) {
			goto end;
		}

		if (!strcmp(cur_clk_name, name)) {
			clock_class = cur_clk;
			goto end;
		}
	}

end:
	return clock_class;
}

static inline
enum bt_ctf_byte_order bt_ctf_trace_common_get_native_byte_order(
		struct bt_ctf_trace_common *trace)
{
	BT_CTF_ASSERT_PRE_NON_NULL(trace, "Trace");
	return trace->native_byte_order;
}

int bt_ctf_trace_common_set_native_byte_order(struct bt_ctf_trace_common *trace,
		enum bt_ctf_byte_order byte_order, bool allow_unspecified);

static inline
struct bt_ctf_field_type_common *bt_ctf_trace_common_borrow_packet_header_field_type(
		struct bt_ctf_trace_common *trace)
{
	BT_CTF_ASSERT_PRE_NON_NULL(trace, "Trace");
	return trace->packet_header_field_type;
}

int bt_ctf_trace_common_set_packet_header_field_type(struct bt_ctf_trace_common *trace,
		struct bt_ctf_field_type_common *packet_header_field_type);

static inline
void bt_ctf_trace_common_freeze(struct bt_ctf_trace_common *trace)
{
	int i;

	if (trace->frozen) {
		return;
	}

	BT_LOGD("Freezing trace: addr=%p, name=\"%s\"",
		trace, bt_ctf_trace_common_get_name(trace));
	BT_LOGD_STR("Freezing packet header field type.");
	bt_ctf_field_type_common_freeze(trace->packet_header_field_type);
	BT_LOGD_STR("Freezing environment attributes.");
	bt_ctf_attributes_freeze(trace->environment);

	if (trace->clock_classes->len > 0) {
		BT_LOGD_STR("Freezing clock classes.");
	}

	for (i = 0; i < trace->clock_classes->len; i++) {
		struct bt_ctf_clock_class *clock_class =
			g_ptr_array_index(trace->clock_classes, i);

		bt_ctf_clock_class_freeze(clock_class);
	}

	trace->frozen = 1;
}

int bt_ctf_trace_common_add_stream_class(struct bt_ctf_trace_common *trace,
		struct bt_ctf_stream_class_common *stream_class,
		bt_ctf_validation_flag_copy_field_type_func copy_field_type_func,
		struct bt_ctf_clock_class *init_expected_clock_class,
		int (*map_clock_classes_func)(struct bt_ctf_stream_class_common *stream_class,
			struct bt_ctf_field_type_common *packet_context_field_type,
			struct bt_ctf_field_type_common *event_header_field_type),
		bool check_ts_begin_end_mapped);

struct bt_ctf_trace {
	struct bt_ctf_trace_common common;
};

/*
 * bt_ctf_trace_get_metadata_string: get metadata string.
 *
 * Get the trace's TSDL metadata. The caller assumes the ownership of the
 * returned string.
 *
 * @param trace Trace instance.
 *
 * Returns the metadata string on success, NULL on error.
 */
char *bt_ctf_trace_get_metadata_string(struct bt_ctf_trace *trace);

struct bt_ctf_trace *bt_ctf_trace_create(void);

int64_t bt_ctf_trace_get_clock_class_count(
		struct bt_ctf_trace *trace);

struct bt_ctf_clock_class *bt_ctf_trace_get_clock_class_by_index(
		struct bt_ctf_trace *trace, uint64_t index);

struct bt_ctf_clock_class *bt_ctf_trace_get_clock_class_by_name(
		struct bt_ctf_trace *trace, const char *name);

int bt_ctf_trace_add_clock_class(struct bt_ctf_trace *trace,
		struct bt_ctf_clock_class *clock_class);

int64_t bt_ctf_trace_get_environment_field_count(
		struct bt_ctf_trace *trace);

const char *bt_ctf_trace_get_environment_field_name_by_index(
		struct bt_ctf_trace *trace, uint64_t index);

struct bt_ctf_value *
bt_ctf_trace_get_environment_field_value_by_index(struct bt_ctf_trace *trace,
		uint64_t index);

struct bt_ctf_value *
bt_ctf_trace_get_environment_field_value_by_name(
		struct bt_ctf_trace *trace, const char *name);

int bt_ctf_trace_visit(struct bt_ctf_trace *trace,
		bt_ctf_visitor visitor, void *data);

#endif /* BABELTRACE_CTF_WRITER_TRACE_INTERNAL_H */
Commit	Line	Data
3dca2276	1	/*
0235b0db	2	* SPDX-License-Identifier: MIT
3dca2276	3	*
0235b0db	4	* Copyright 2014 EfficiOS Inc.
3dca2276 PP	5	*
	6	* The Common Trace Format (CTF) Specification is available at
	7	* http://www.efficios.com/ctf
	8	*/
	9
0235b0db MJ	10	#ifndef BABELTRACE_CTF_WRITER_TRACE_INTERNAL_H
	11	#define BABELTRACE_CTF_WRITER_TRACE_INTERNAL_H
	12
91d81473	13	#include "common/macros.h"
6162e6b7	14	#include "common/uuid.h"
217cf9d3 PP	15	#include <babeltrace2-ctf-writer/field-types.h>
	16	#include <babeltrace2-ctf-writer/fields.h>
	17	#include <babeltrace2-ctf-writer/trace.h>
3fadfbc0	18	#include <babeltrace2/types.h>
16ca5ff0 PP	19	#include <glib.h>
	20	#include <sys/types.h>
	21
578e048b MJ	22	#include "assert-pre.h"
	23	#include "attributes.h"
	24	#include "clock-class.h"
	25	#include "object.h"
	26	#include "stream-class.h"
	27	#include "validation.h"
	28	#include "values.h"
	29
16ca5ff0	30	struct bt_ctf_trace_common {
e1e02a22	31	struct bt_ctf_object base;
16ca5ff0 PP	32	GString *name;
16ca5ff0 PP	33	int frozen;
6162e6b7	34	bt_uuid_t uuid;
00409097	35	bt_ctf_bool uuid_set;
16ca5ff0	36	enum bt_ctf_byte_order native_byte_order;
e1e02a22	37	struct bt_ctf_private_value *environment;
16ca5ff0 PP	38	GPtrArray clock_classes; / Array of pointers to bt_ctf_clock_class */
	39	GPtrArray stream_classes; / Array of ptrs to bt_ctf_stream_class_common */
	40	GPtrArray streams; / Array of ptrs to bt_ctf_stream_common */
	41	struct bt_ctf_field_type_common *packet_header_field_type;
	42	int64_t next_stream_id;
	43
	44	/*
	45	* This flag indicates if the trace is valid. A valid
	46	* trace is _always_ frozen.
	47	*/
	48	int valid;
	49	};
	50
00409097	51	bt_ctf_bool bt_ctf_trace_common_has_clock_class(struct bt_ctf_trace_common *trace,
16ca5ff0 PP	52	struct bt_ctf_clock_class *clock_class);
16ca5ff0 PP	53
16ca5ff0	54	int bt_ctf_trace_common_initialize(struct bt_ctf_trace_common *trace,
e1e02a22	55	bt_ctf_object_release_func release_func);
16ca5ff0	56
16ca5ff0 PP	57	void bt_ctf_trace_common_finalize(struct bt_ctf_trace_common *trace);
	58
	59	static inline
	60	const char bt_ctf_trace_common_get_name(struct bt_ctf_trace_common trace)
	61	{
67d2ce02	62	BT_CTF_ASSERT_PRE_NON_NULL(trace, "Trace");
16ca5ff0 PP	63	return trace->name ? trace->name->str : NULL;
	64	}
	65
16ca5ff0 PP	66	int bt_ctf_trace_common_set_name(struct bt_ctf_trace_common trace, const char name);
	67
	68	static inline
6162e6b7	69	const uint8_t bt_ctf_trace_common_get_uuid(struct bt_ctf_trace_common trace)
16ca5ff0	70	{
67d2ce02	71	BT_CTF_ASSERT_PRE_NON_NULL(trace, "Trace");
16ca5ff0 PP	72	return trace->uuid_set ? trace->uuid : NULL;
	73	}
	74
6162e6b7	75	int bt_ctf_trace_common_set_uuid(struct bt_ctf_trace_common trace, const uint8_t uuid);
16ca5ff0	76
16ca5ff0	77	int bt_ctf_trace_common_set_environment_field(struct bt_ctf_trace_common *trace,
e1e02a22	78	const char name, struct bt_ctf_private_value value);
16ca5ff0	79
16ca5ff0 PP	80	int bt_ctf_trace_common_set_environment_field_string(struct bt_ctf_trace_common *trace,
	81	const char name, const char value);
	82
16ca5ff0 PP	83	int bt_ctf_trace_common_set_environment_field_integer(struct bt_ctf_trace_common *trace,
	84	const char *name, int64_t value);
	85
	86	static inline
	87	int64_t bt_ctf_trace_common_get_environment_field_count(
	88	struct bt_ctf_trace_common *trace)
	89	{
	90	int64_t ret;
	91
67d2ce02	92	BT_CTF_ASSERT_PRE_NON_NULL(trace, "Trace");
16ca5ff0	93	ret = bt_ctf_attributes_get_count(trace->environment);
98b15851	94	BT_ASSERT_DBG(ret >= 0);
16ca5ff0 PP	95	return ret;
	96	}
	97
	98	static inline
	99	const char *
	100	bt_ctf_trace_common_get_environment_field_name_by_index(
	101	struct bt_ctf_trace_common *trace, uint64_t index)
	102	{
67d2ce02	103	BT_CTF_ASSERT_PRE_NON_NULL(trace, "Trace");
16ca5ff0 PP	104	return bt_ctf_attributes_get_field_name(trace->environment, index);
	105	}
	106
	107	static inline
e1e02a22	108	struct bt_ctf_private_value *
da91b29a	109	bt_ctf_trace_common_borrow_environment_field_value_by_index(
16ca5ff0 PP	110	struct bt_ctf_trace_common *trace, uint64_t index)
16ca5ff0 PP	111	{
67d2ce02	112	BT_CTF_ASSERT_PRE_NON_NULL(trace, "Trace");
16ca5ff0 PP	113	return bt_ctf_attributes_borrow_field_value(trace->environment, index);
	114	}
	115
	116	static inline
e1e02a22	117	struct bt_ctf_private_value *
da91b29a	118	bt_ctf_trace_common_borrow_environment_field_value_by_name(
16ca5ff0 PP	119	struct bt_ctf_trace_common trace, const char name)
16ca5ff0 PP	120	{
67d2ce02 MJ	121	BT_CTF_ASSERT_PRE_NON_NULL(trace, "Trace");
67d2ce02 MJ	122	BT_CTF_ASSERT_PRE_NON_NULL(name, "Name");
16ca5ff0 PP	123	return bt_ctf_attributes_borrow_field_value_by_name(trace->environment,
	124	name);
	125	}
	126
16ca5ff0 PP	127	int bt_ctf_trace_common_add_clock_class(struct bt_ctf_trace_common *trace,
	128	struct bt_ctf_clock_class *clock_class);
	129
	130	static inline
	131	int64_t bt_ctf_trace_common_get_clock_class_count(struct bt_ctf_trace_common *trace)
	132	{
67d2ce02	133	BT_CTF_ASSERT_PRE_NON_NULL(trace, "Trace");
16ca5ff0 PP	134	return trace->clock_classes->len;
	135	}
	136
	137	static inline
	138	struct bt_ctf_clock_class *bt_ctf_trace_common_borrow_clock_class_by_index(
	139	struct bt_ctf_trace_common *trace, uint64_t index)
	140	{
67d2ce02 MJ	141	BT_CTF_ASSERT_PRE_NON_NULL(trace, "Trace");
67d2ce02 MJ	142	BT_CTF_ASSERT_PRE(index < trace->clock_classes->len,
16ca5ff0 PP	143	"Index is out of bounds: index=%" PRIu64 ", "
	144	"count=%u",
	145	index, trace->clock_classes->len);
	146	return g_ptr_array_index(trace->clock_classes, index);
	147	}
	148
	149	static inline
	150	int64_t bt_ctf_trace_common_get_stream_count(struct bt_ctf_trace_common *trace)
	151	{
67d2ce02	152	BT_CTF_ASSERT_PRE_NON_NULL(trace, "Trace");
16ca5ff0 PP	153	return (int64_t) trace->streams->len;
	154	}
	155
	156	static inline
	157	struct bt_ctf_stream_common *bt_ctf_trace_common_borrow_stream_by_index(
	158	struct bt_ctf_trace_common *trace,
	159	uint64_t index)
	160	{
67d2ce02 MJ	161	BT_CTF_ASSERT_PRE_NON_NULL(trace, "Trace");
67d2ce02 MJ	162	BT_CTF_ASSERT_PRE(index < trace->streams->len,
16ca5ff0 PP	163	"Index is out of bounds: index=%" PRIu64 ", "
	164	"count=%u",
	165	index, trace->streams->len);
	166	return g_ptr_array_index(trace->streams, index);
	167	}
	168
	169	static inline
	170	int64_t bt_ctf_trace_common_get_stream_class_count(struct bt_ctf_trace_common *trace)
	171	{
67d2ce02	172	BT_CTF_ASSERT_PRE_NON_NULL(trace, "Trace");
16ca5ff0 PP	173	return (int64_t) trace->stream_classes->len;
	174	}
	175
	176	static inline
	177	struct bt_ctf_stream_class_common *bt_ctf_trace_common_borrow_stream_class_by_index(
	178	struct bt_ctf_trace_common *trace, uint64_t index)
	179	{
67d2ce02 MJ	180	BT_CTF_ASSERT_PRE_NON_NULL(trace, "Trace");
67d2ce02 MJ	181	BT_CTF_ASSERT_PRE(index < trace->stream_classes->len,
16ca5ff0 PP	182	"Index is out of bounds: index=%" PRIu64 ", "
	183	"count=%u",
	184	index, trace->stream_classes->len);
	185	return g_ptr_array_index(trace->stream_classes, index);
	186	}
	187
	188	static inline
	189	struct bt_ctf_stream_class_common *bt_ctf_trace_common_borrow_stream_class_by_id(
	190	struct bt_ctf_trace_common *trace, uint64_t id_param)
	191	{
	192	int i;
	193	struct bt_ctf_stream_class_common *stream_class = NULL;
	194	int64_t id = (int64_t) id_param;
	195
67d2ce02 MJ	196	BT_CTF_ASSERT_PRE_NON_NULL(trace, "Trace");
67d2ce02 MJ	197	BT_CTF_ASSERT_PRE(id >= 0,
16ca5ff0 PP	198	"Invalid stream class ID: %" PRIu64, id_param);
	199
	200	for (i = 0; i < trace->stream_classes->len; i++) {
	201	struct bt_ctf_stream_class_common *stream_class_candidate;
	202
	203	stream_class_candidate =
	204	g_ptr_array_index(trace->stream_classes, i);
	205
	206	if (bt_ctf_stream_class_common_get_id(stream_class_candidate) ==
	207	(int64_t) id) {
	208	stream_class = stream_class_candidate;
	209	goto end;
	210	}
	211	}
	212
	213	end:
	214	return stream_class;
	215	}
	216
	217	static inline
	218	struct bt_ctf_clock_class *bt_ctf_trace_common_borrow_clock_class_by_name(
	219	struct bt_ctf_trace_common trace, const char name)
	220	{
	221	size_t i;
	222	struct bt_ctf_clock_class *clock_class = NULL;
	223
67d2ce02 MJ	224	BT_CTF_ASSERT_PRE_NON_NULL(trace, "Trace");
67d2ce02 MJ	225	BT_CTF_ASSERT_PRE_NON_NULL(name, "Name");
16ca5ff0 PP	226
	227	for (i = 0; i < trace->clock_classes->len; i++) {
	228	struct bt_ctf_clock_class *cur_clk =
	229	g_ptr_array_index(trace->clock_classes, i);
	230	const char *cur_clk_name = bt_ctf_clock_class_get_name(cur_clk);
	231
	232	if (!cur_clk_name) {
	233	goto end;
	234	}
	235
	236	if (!strcmp(cur_clk_name, name)) {
	237	clock_class = cur_clk;
	238	goto end;
	239	}
	240	}
	241
	242	end:
	243	return clock_class;
	244	}
	245
	246	static inline
	247	enum bt_ctf_byte_order bt_ctf_trace_common_get_native_byte_order(
	248	struct bt_ctf_trace_common *trace)
	249	{
67d2ce02	250	BT_CTF_ASSERT_PRE_NON_NULL(trace, "Trace");
16ca5ff0 PP	251	return trace->native_byte_order;
	252	}
	253
16ca5ff0 PP	254	int bt_ctf_trace_common_set_native_byte_order(struct bt_ctf_trace_common *trace,
	255	enum bt_ctf_byte_order byte_order, bool allow_unspecified);
	256
	257	static inline
	258	struct bt_ctf_field_type_common *bt_ctf_trace_common_borrow_packet_header_field_type(
	259	struct bt_ctf_trace_common *trace)
	260	{
67d2ce02	261	BT_CTF_ASSERT_PRE_NON_NULL(trace, "Trace");
16ca5ff0 PP	262	return trace->packet_header_field_type;
	263	}
	264
16ca5ff0 PP	265	int bt_ctf_trace_common_set_packet_header_field_type(struct bt_ctf_trace_common *trace,
	266	struct bt_ctf_field_type_common *packet_header_field_type);
	267
	268	static inline
	269	void bt_ctf_trace_common_freeze(struct bt_ctf_trace_common *trace)
	270	{
	271	int i;
	272
	273	if (trace->frozen) {
	274	return;
	275	}
	276
	277	BT_LOGD("Freezing trace: addr=%p, name=\"%s\"",
	278	trace, bt_ctf_trace_common_get_name(trace));
	279	BT_LOGD_STR("Freezing packet header field type.");
	280	bt_ctf_field_type_common_freeze(trace->packet_header_field_type);
	281	BT_LOGD_STR("Freezing environment attributes.");
	282	bt_ctf_attributes_freeze(trace->environment);
	283
	284	if (trace->clock_classes->len > 0) {
	285	BT_LOGD_STR("Freezing clock classes.");
	286	}
	287
	288	for (i = 0; i < trace->clock_classes->len; i++) {
	289	struct bt_ctf_clock_class *clock_class =
	290	g_ptr_array_index(trace->clock_classes, i);
	291
	292	bt_ctf_clock_class_freeze(clock_class);
	293	}
	294
	295	trace->frozen = 1;
	296	}
	297
16ca5ff0 PP	298	int bt_ctf_trace_common_add_stream_class(struct bt_ctf_trace_common *trace,
	299	struct bt_ctf_stream_class_common *stream_class,
	300	bt_ctf_validation_flag_copy_field_type_func copy_field_type_func,
	301	struct bt_ctf_clock_class *init_expected_clock_class,
	302	int (map_clock_classes_func)(struct bt_ctf_stream_class_common stream_class,
	303	struct bt_ctf_field_type_common *packet_context_field_type,
	304	struct bt_ctf_field_type_common *event_header_field_type),
	305	bool check_ts_begin_end_mapped);
3dca2276 PP	306
3dca2276 PP	307	struct bt_ctf_trace {
16ca5ff0	308	struct bt_ctf_trace_common common;
3dca2276 PP	309	};
	310
	311	/*
	312	* bt_ctf_trace_get_metadata_string: get metadata string.
	313	*
	314	* Get the trace's TSDL metadata. The caller assumes the ownership of the
	315	* returned string.
	316	*
	317	* @param trace Trace instance.
	318	*
	319	* Returns the metadata string on success, NULL on error.
	320	*/
3dca2276 PP	321	char bt_ctf_trace_get_metadata_string(struct bt_ctf_trace trace);
3dca2276 PP	322
3dca2276 PP	323	struct bt_ctf_trace *bt_ctf_trace_create(void);
3dca2276 PP	324
16ca5ff0 PP	325	int64_t bt_ctf_trace_get_clock_class_count(
	326	struct bt_ctf_trace *trace);
	327
16ca5ff0 PP	328	struct bt_ctf_clock_class *bt_ctf_trace_get_clock_class_by_index(
	329	struct bt_ctf_trace *trace, uint64_t index);
	330
16ca5ff0 PP	331	struct bt_ctf_clock_class *bt_ctf_trace_get_clock_class_by_name(
	332	struct bt_ctf_trace trace, const char name);
	333
16ca5ff0 PP	334	int bt_ctf_trace_add_clock_class(struct bt_ctf_trace *trace,
	335	struct bt_ctf_clock_class *clock_class);
	336
e1e02a22 PP	337	int64_t bt_ctf_trace_get_environment_field_count(
	338	struct bt_ctf_trace *trace);
	339
e1e02a22 PP	340	const char *bt_ctf_trace_get_environment_field_name_by_index(
	341	struct bt_ctf_trace *trace, uint64_t index);
	342
e1e02a22 PP	343	struct bt_ctf_value *
	344	bt_ctf_trace_get_environment_field_value_by_index(struct bt_ctf_trace *trace,
	345	uint64_t index);
	346
e1e02a22 PP	347	struct bt_ctf_value *
	348	bt_ctf_trace_get_environment_field_value_by_name(
	349	struct bt_ctf_trace trace, const char name);
	350
7c7301d5 SM	351	int bt_ctf_trace_visit(struct bt_ctf_trace *trace,
	352	bt_ctf_visitor visitor, void *data);
	353
3dca2276	354	#endif /* BABELTRACE_CTF_WRITER_TRACE_INTERNAL_H */