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

#ifndef BABELTRACE_CTF_WRITER_TRACE_INTERNAL_H
#define BABELTRACE_CTF_WRITER_TRACE_INTERNAL_H

/*
 * Copyright 2014 EfficiOS Inc.
 *
 * Author: Jérémie Galarneau <jeremie.galarneau@efficios.com>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 *
 * The Common Trace Format (CTF) Specification is available at
 * http://www.efficios.com/ctf
 */

#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_HIDDEN
bt_ctf_bool bt_ctf_trace_common_has_clock_class(struct bt_ctf_trace_common *trace,
		struct bt_ctf_clock_class *clock_class);

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

BT_HIDDEN
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;
}

BT_HIDDEN
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;
}

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

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

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

BT_HIDDEN
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);
}

BT_HIDDEN
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;
}

BT_HIDDEN
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;
}

BT_HIDDEN
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;
}

BT_HIDDEN
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.
 */
BT_HIDDEN
char *bt_ctf_trace_get_metadata_string(struct bt_ctf_trace *trace);

BT_HIDDEN
struct bt_ctf_trace *bt_ctf_trace_create(void);

BT_HIDDEN
int64_t bt_ctf_trace_get_clock_class_count(
		struct bt_ctf_trace *trace);

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

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

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

BT_HIDDEN
int64_t bt_ctf_trace_get_environment_field_count(
		struct bt_ctf_trace *trace);

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

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

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

#endif /* BABELTRACE_CTF_WRITER_TRACE_INTERNAL_H */
Commit	Line	Data
3dca2276 PP	1	#ifndef BABELTRACE_CTF_WRITER_TRACE_INTERNAL_H
	2	#define BABELTRACE_CTF_WRITER_TRACE_INTERNAL_H
	3
	4	/*
3dca2276 PP	5	* Copyright 2014 EfficiOS Inc.
	6	*
	7	* Author: Jérémie Galarneau <jeremie.galarneau@efficios.com>
	8	*
	9	* Permission is hereby granted, free of charge, to any person obtaining a copy
	10	* of this software and associated documentation files (the "Software"), to deal
	11	* in the Software without restriction, including without limitation the rights
	12	* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
	13	* copies of the Software, and to permit persons to whom the Software is
	14	* furnished to do so, subject to the following conditions:
	15	*
	16	* The above copyright notice and this permission notice shall be included in
	17	* all copies or substantial portions of the Software.
	18	*
	19	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	20	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	21	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
	22	* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
	23	* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
	24	* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
	25	* SOFTWARE.
	26	*
	27	* The Common Trace Format (CTF) Specification is available at
	28	* http://www.efficios.com/ctf
	29	*/
	30
91d81473	31	#include "common/macros.h"
6162e6b7	32	#include "common/uuid.h"
217cf9d3 PP	33	#include <babeltrace2-ctf-writer/field-types.h>
	34	#include <babeltrace2-ctf-writer/fields.h>
	35	#include <babeltrace2-ctf-writer/trace.h>
3fadfbc0	36	#include <babeltrace2/types.h>
16ca5ff0 PP	37	#include <glib.h>
	38	#include <sys/types.h>
	39
578e048b MJ	40	#include "assert-pre.h"
	41	#include "attributes.h"
	42	#include "clock-class.h"
	43	#include "object.h"
	44	#include "stream-class.h"
	45	#include "validation.h"
	46	#include "values.h"
	47
16ca5ff0	48	struct bt_ctf_trace_common {
e1e02a22	49	struct bt_ctf_object base;
16ca5ff0 PP	50	GString *name;
16ca5ff0 PP	51	int frozen;
6162e6b7	52	bt_uuid_t uuid;
00409097	53	bt_ctf_bool uuid_set;
16ca5ff0	54	enum bt_ctf_byte_order native_byte_order;
e1e02a22	55	struct bt_ctf_private_value *environment;
16ca5ff0 PP	56	GPtrArray clock_classes; / Array of pointers to bt_ctf_clock_class */
	57	GPtrArray stream_classes; / Array of ptrs to bt_ctf_stream_class_common */
	58	GPtrArray streams; / Array of ptrs to bt_ctf_stream_common */
	59	struct bt_ctf_field_type_common *packet_header_field_type;
	60	int64_t next_stream_id;
	61
	62	/*
	63	* This flag indicates if the trace is valid. A valid
	64	* trace is _always_ frozen.
	65	*/
	66	int valid;
	67	};
	68
	69	BT_HIDDEN
00409097	70	bt_ctf_bool bt_ctf_trace_common_has_clock_class(struct bt_ctf_trace_common *trace,
16ca5ff0 PP	71	struct bt_ctf_clock_class *clock_class);
	72
	73	BT_HIDDEN
	74	int bt_ctf_trace_common_initialize(struct bt_ctf_trace_common *trace,
e1e02a22	75	bt_ctf_object_release_func release_func);
16ca5ff0 PP	76
	77	BT_HIDDEN
	78	void bt_ctf_trace_common_finalize(struct bt_ctf_trace_common *trace);
	79
	80	static inline
	81	const char bt_ctf_trace_common_get_name(struct bt_ctf_trace_common trace)
	82	{
67d2ce02	83	BT_CTF_ASSERT_PRE_NON_NULL(trace, "Trace");
16ca5ff0 PP	84	return trace->name ? trace->name->str : NULL;
	85	}
	86
	87	BT_HIDDEN
	88	int bt_ctf_trace_common_set_name(struct bt_ctf_trace_common trace, const char name);
	89
	90	static inline
6162e6b7	91	const uint8_t bt_ctf_trace_common_get_uuid(struct bt_ctf_trace_common trace)
16ca5ff0	92	{
67d2ce02	93	BT_CTF_ASSERT_PRE_NON_NULL(trace, "Trace");
16ca5ff0 PP	94	return trace->uuid_set ? trace->uuid : NULL;
	95	}
	96
	97	BT_HIDDEN
6162e6b7	98	int bt_ctf_trace_common_set_uuid(struct bt_ctf_trace_common trace, const uint8_t uuid);
16ca5ff0 PP	99
	100	BT_HIDDEN
	101	int bt_ctf_trace_common_set_environment_field(struct bt_ctf_trace_common *trace,
e1e02a22	102	const char name, struct bt_ctf_private_value value);
16ca5ff0 PP	103
	104	BT_HIDDEN
	105	int bt_ctf_trace_common_set_environment_field_string(struct bt_ctf_trace_common *trace,
	106	const char name, const char value);
	107
	108	BT_HIDDEN
	109	int bt_ctf_trace_common_set_environment_field_integer(struct bt_ctf_trace_common *trace,
	110	const char *name, int64_t value);
	111
	112	static inline
	113	int64_t bt_ctf_trace_common_get_environment_field_count(
	114	struct bt_ctf_trace_common *trace)
	115	{
	116	int64_t ret;
	117
67d2ce02	118	BT_CTF_ASSERT_PRE_NON_NULL(trace, "Trace");
16ca5ff0	119	ret = bt_ctf_attributes_get_count(trace->environment);
98b15851	120	BT_ASSERT_DBG(ret >= 0);
16ca5ff0 PP	121	return ret;
	122	}
	123
	124	static inline
	125	const char *
	126	bt_ctf_trace_common_get_environment_field_name_by_index(
	127	struct bt_ctf_trace_common *trace, uint64_t index)
	128	{
67d2ce02	129	BT_CTF_ASSERT_PRE_NON_NULL(trace, "Trace");
16ca5ff0 PP	130	return bt_ctf_attributes_get_field_name(trace->environment, index);
	131	}
	132
	133	static inline
e1e02a22	134	struct bt_ctf_private_value *
da91b29a	135	bt_ctf_trace_common_borrow_environment_field_value_by_index(
16ca5ff0 PP	136	struct bt_ctf_trace_common *trace, uint64_t index)
16ca5ff0 PP	137	{
67d2ce02	138	BT_CTF_ASSERT_PRE_NON_NULL(trace, "Trace");
16ca5ff0 PP	139	return bt_ctf_attributes_borrow_field_value(trace->environment, index);
	140	}
	141
	142	static inline
e1e02a22	143	struct bt_ctf_private_value *
da91b29a	144	bt_ctf_trace_common_borrow_environment_field_value_by_name(
16ca5ff0 PP	145	struct bt_ctf_trace_common trace, const char name)
16ca5ff0 PP	146	{
67d2ce02 MJ	147	BT_CTF_ASSERT_PRE_NON_NULL(trace, "Trace");
67d2ce02 MJ	148	BT_CTF_ASSERT_PRE_NON_NULL(name, "Name");
16ca5ff0 PP	149	return bt_ctf_attributes_borrow_field_value_by_name(trace->environment,
	150	name);
	151	}
	152
	153	BT_HIDDEN
	154	int bt_ctf_trace_common_add_clock_class(struct bt_ctf_trace_common *trace,
	155	struct bt_ctf_clock_class *clock_class);
	156
	157	static inline
	158	int64_t bt_ctf_trace_common_get_clock_class_count(struct bt_ctf_trace_common *trace)
	159	{
67d2ce02	160	BT_CTF_ASSERT_PRE_NON_NULL(trace, "Trace");
16ca5ff0 PP	161	return trace->clock_classes->len;
	162	}
	163
	164	static inline
	165	struct bt_ctf_clock_class *bt_ctf_trace_common_borrow_clock_class_by_index(
	166	struct bt_ctf_trace_common *trace, uint64_t index)
	167	{
67d2ce02 MJ	168	BT_CTF_ASSERT_PRE_NON_NULL(trace, "Trace");
67d2ce02 MJ	169	BT_CTF_ASSERT_PRE(index < trace->clock_classes->len,
16ca5ff0 PP	170	"Index is out of bounds: index=%" PRIu64 ", "
	171	"count=%u",
	172	index, trace->clock_classes->len);
	173	return g_ptr_array_index(trace->clock_classes, index);
	174	}
	175
	176	static inline
	177	int64_t bt_ctf_trace_common_get_stream_count(struct bt_ctf_trace_common *trace)
	178	{
67d2ce02	179	BT_CTF_ASSERT_PRE_NON_NULL(trace, "Trace");
16ca5ff0 PP	180	return (int64_t) trace->streams->len;
	181	}
	182
	183	static inline
	184	struct bt_ctf_stream_common *bt_ctf_trace_common_borrow_stream_by_index(
	185	struct bt_ctf_trace_common *trace,
	186	uint64_t index)
	187	{
67d2ce02 MJ	188	BT_CTF_ASSERT_PRE_NON_NULL(trace, "Trace");
67d2ce02 MJ	189	BT_CTF_ASSERT_PRE(index < trace->streams->len,
16ca5ff0 PP	190	"Index is out of bounds: index=%" PRIu64 ", "
	191	"count=%u",
	192	index, trace->streams->len);
	193	return g_ptr_array_index(trace->streams, index);
	194	}
	195
	196	static inline
	197	int64_t bt_ctf_trace_common_get_stream_class_count(struct bt_ctf_trace_common *trace)
	198	{
67d2ce02	199	BT_CTF_ASSERT_PRE_NON_NULL(trace, "Trace");
16ca5ff0 PP	200	return (int64_t) trace->stream_classes->len;
	201	}
	202
	203	static inline
	204	struct bt_ctf_stream_class_common *bt_ctf_trace_common_borrow_stream_class_by_index(
	205	struct bt_ctf_trace_common *trace, uint64_t index)
	206	{
67d2ce02 MJ	207	BT_CTF_ASSERT_PRE_NON_NULL(trace, "Trace");
67d2ce02 MJ	208	BT_CTF_ASSERT_PRE(index < trace->stream_classes->len,
16ca5ff0 PP	209	"Index is out of bounds: index=%" PRIu64 ", "
	210	"count=%u",
	211	index, trace->stream_classes->len);
	212	return g_ptr_array_index(trace->stream_classes, index);
	213	}
	214
	215	static inline
	216	struct bt_ctf_stream_class_common *bt_ctf_trace_common_borrow_stream_class_by_id(
	217	struct bt_ctf_trace_common *trace, uint64_t id_param)
	218	{
	219	int i;
	220	struct bt_ctf_stream_class_common *stream_class = NULL;
	221	int64_t id = (int64_t) id_param;
	222
67d2ce02 MJ	223	BT_CTF_ASSERT_PRE_NON_NULL(trace, "Trace");
67d2ce02 MJ	224	BT_CTF_ASSERT_PRE(id >= 0,
16ca5ff0 PP	225	"Invalid stream class ID: %" PRIu64, id_param);
	226
	227	for (i = 0; i < trace->stream_classes->len; i++) {
	228	struct bt_ctf_stream_class_common *stream_class_candidate;
	229
	230	stream_class_candidate =
	231	g_ptr_array_index(trace->stream_classes, i);
	232
	233	if (bt_ctf_stream_class_common_get_id(stream_class_candidate) ==
	234	(int64_t) id) {
	235	stream_class = stream_class_candidate;
	236	goto end;
	237	}
	238	}
	239
	240	end:
	241	return stream_class;
	242	}
	243
	244	static inline
	245	struct bt_ctf_clock_class *bt_ctf_trace_common_borrow_clock_class_by_name(
	246	struct bt_ctf_trace_common trace, const char name)
	247	{
	248	size_t i;
	249	struct bt_ctf_clock_class *clock_class = NULL;
	250
67d2ce02 MJ	251	BT_CTF_ASSERT_PRE_NON_NULL(trace, "Trace");
67d2ce02 MJ	252	BT_CTF_ASSERT_PRE_NON_NULL(name, "Name");
16ca5ff0 PP	253
	254	for (i = 0; i < trace->clock_classes->len; i++) {
	255	struct bt_ctf_clock_class *cur_clk =
	256	g_ptr_array_index(trace->clock_classes, i);
	257	const char *cur_clk_name = bt_ctf_clock_class_get_name(cur_clk);
	258
	259	if (!cur_clk_name) {
	260	goto end;
	261	}
	262
	263	if (!strcmp(cur_clk_name, name)) {
	264	clock_class = cur_clk;
	265	goto end;
	266	}
	267	}
	268
	269	end:
	270	return clock_class;
	271	}
	272
	273	static inline
	274	enum bt_ctf_byte_order bt_ctf_trace_common_get_native_byte_order(
	275	struct bt_ctf_trace_common *trace)
	276	{
67d2ce02	277	BT_CTF_ASSERT_PRE_NON_NULL(trace, "Trace");
16ca5ff0 PP	278	return trace->native_byte_order;
	279	}
	280
	281	BT_HIDDEN
	282	int bt_ctf_trace_common_set_native_byte_order(struct bt_ctf_trace_common *trace,
	283	enum bt_ctf_byte_order byte_order, bool allow_unspecified);
	284
	285	static inline
	286	struct bt_ctf_field_type_common *bt_ctf_trace_common_borrow_packet_header_field_type(
	287	struct bt_ctf_trace_common *trace)
	288	{
67d2ce02	289	BT_CTF_ASSERT_PRE_NON_NULL(trace, "Trace");
16ca5ff0 PP	290	return trace->packet_header_field_type;
	291	}
	292
	293	BT_HIDDEN
	294	int bt_ctf_trace_common_set_packet_header_field_type(struct bt_ctf_trace_common *trace,
	295	struct bt_ctf_field_type_common *packet_header_field_type);
	296
	297	static inline
	298	void bt_ctf_trace_common_freeze(struct bt_ctf_trace_common *trace)
	299	{
	300	int i;
	301
	302	if (trace->frozen) {
	303	return;
	304	}
	305
	306	BT_LOGD("Freezing trace: addr=%p, name=\"%s\"",
	307	trace, bt_ctf_trace_common_get_name(trace));
	308	BT_LOGD_STR("Freezing packet header field type.");
	309	bt_ctf_field_type_common_freeze(trace->packet_header_field_type);
	310	BT_LOGD_STR("Freezing environment attributes.");
	311	bt_ctf_attributes_freeze(trace->environment);
	312
	313	if (trace->clock_classes->len > 0) {
	314	BT_LOGD_STR("Freezing clock classes.");
	315	}
	316
	317	for (i = 0; i < trace->clock_classes->len; i++) {
	318	struct bt_ctf_clock_class *clock_class =
	319	g_ptr_array_index(trace->clock_classes, i);
	320
	321	bt_ctf_clock_class_freeze(clock_class);
	322	}
	323
	324	trace->frozen = 1;
	325	}
	326
	327	BT_HIDDEN
	328	int bt_ctf_trace_common_add_stream_class(struct bt_ctf_trace_common *trace,
	329	struct bt_ctf_stream_class_common *stream_class,
	330	bt_ctf_validation_flag_copy_field_type_func copy_field_type_func,
	331	struct bt_ctf_clock_class *init_expected_clock_class,
	332	int (map_clock_classes_func)(struct bt_ctf_stream_class_common stream_class,
	333	struct bt_ctf_field_type_common *packet_context_field_type,
	334	struct bt_ctf_field_type_common *event_header_field_type),
	335	bool check_ts_begin_end_mapped);
3dca2276 PP	336
3dca2276 PP	337	struct bt_ctf_trace {
16ca5ff0	338	struct bt_ctf_trace_common common;
3dca2276 PP	339	};
	340
	341	/*
	342	* bt_ctf_trace_get_metadata_string: get metadata string.
	343	*
	344	* Get the trace's TSDL metadata. The caller assumes the ownership of the
	345	* returned string.
	346	*
	347	* @param trace Trace instance.
	348	*
	349	* Returns the metadata string on success, NULL on error.
	350	*/
	351	BT_HIDDEN
	352	char bt_ctf_trace_get_metadata_string(struct bt_ctf_trace trace);
	353
	354	BT_HIDDEN
	355	struct bt_ctf_trace *bt_ctf_trace_create(void);
	356
16ca5ff0 PP	357	BT_HIDDEN
	358	int64_t bt_ctf_trace_get_clock_class_count(
	359	struct bt_ctf_trace *trace);
	360
	361	BT_HIDDEN
	362	struct bt_ctf_clock_class *bt_ctf_trace_get_clock_class_by_index(
	363	struct bt_ctf_trace *trace, uint64_t index);
	364
	365	BT_HIDDEN
	366	struct bt_ctf_clock_class *bt_ctf_trace_get_clock_class_by_name(
	367	struct bt_ctf_trace trace, const char name);
	368
	369	BT_HIDDEN
	370	int bt_ctf_trace_add_clock_class(struct bt_ctf_trace *trace,
	371	struct bt_ctf_clock_class *clock_class);
	372
e1e02a22 PP	373	BT_HIDDEN
	374	int64_t bt_ctf_trace_get_environment_field_count(
	375	struct bt_ctf_trace *trace);
	376
	377	BT_HIDDEN
	378	const char *bt_ctf_trace_get_environment_field_name_by_index(
	379	struct bt_ctf_trace *trace, uint64_t index);
	380
	381	BT_HIDDEN
	382	struct bt_ctf_value *
	383	bt_ctf_trace_get_environment_field_value_by_index(struct bt_ctf_trace *trace,
	384	uint64_t index);
	385
	386	BT_HIDDEN
	387	struct bt_ctf_value *
	388	bt_ctf_trace_get_environment_field_value_by_name(
	389	struct bt_ctf_trace trace, const char name);
	390
3dca2276	391	#endif /* BABELTRACE_CTF_WRITER_TRACE_INTERNAL_H */