[babeltrace.git] / include / babeltrace2 / ctf-writer / stream-class-internal.h

#ifndef BABELTRACE_CTF_WRITER_STREAM_CLASS_INTERNAL_H
#define BABELTRACE_CTF_WRITER_STREAM_CLASS_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 <babeltrace2/assert-internal.h>
#include <babeltrace2/babeltrace-internal.h>
#include <babeltrace2/common-internal.h>
#include <babeltrace2/ctf-writer/clock-internal.h>
#include <babeltrace2/ctf-writer/field-types-internal.h>
#include <babeltrace2/ctf-writer/field-types.h>
#include <babeltrace2/ctf-writer/stream-class-internal.h>
#include <babeltrace2/ctf-writer/utils-internal.h>
#include <babeltrace2/ctf-writer/validation-internal.h>
#include <babeltrace2/ctf-writer/visitor.h>
#include <babeltrace2/ctf-writer/object-internal.h>
#include <inttypes.h>

struct bt_ctf_stream_class_common {
	struct bt_ctf_object base;
	GString *name;

	/* Array of pointers to event class addresses */
	GPtrArray *event_classes;

	/* event class id (int64_t) to event class address */
	GHashTable *event_classes_ht;
	int id_set;
	int64_t id;
	int64_t next_event_id;
	struct bt_ctf_field_type_common *packet_context_field_type;
	struct bt_ctf_field_type_common *event_header_field_type;
	struct bt_ctf_field_type_common *event_context_field_type;
	int frozen;
	int byte_order;

	/*
	 * This flag indicates if the stream class is valid. A valid
	 * stream class is _always_ frozen.
	 */
	int valid;

	/*
	 * Unique clock class mapped to any field type within this
	 * stream class, including all the stream class's event class
	 * field types. This is only set if the stream class is frozen.
	 *
	 * If the stream class is frozen and this is still NULL, it is
	 * still possible that it becomes non-NULL because
	 * bt_ctf_stream_class_add_event_class() can add an event class
	 * containing a field type mapped to some clock class. In this
	 * case, this is the mapped clock class, and at this point, both
	 * the new event class and the stream class are frozen, so the
	 * next added event classes are expected to contain field types
	 * which only map to this specific clock class.
	 *
	 * If this is a CTF writer stream class, then this is the
	 * backing clock class of the `clock` member above.
	 */
	struct bt_ctf_clock_class *clock_class;
};

struct bt_ctf_event_class_common;

BT_HIDDEN
int bt_ctf_stream_class_common_initialize(struct bt_ctf_stream_class_common *stream_class,
		const char *name, bt_ctf_object_release_func release_func);

BT_HIDDEN
void bt_ctf_stream_class_common_finalize(struct bt_ctf_stream_class_common *stream_class);

BT_HIDDEN
void bt_ctf_stream_class_common_freeze(struct bt_ctf_stream_class_common *stream_class);

static inline
const char *bt_ctf_stream_class_common_get_name(
		struct bt_ctf_stream_class_common *stream_class)
{
	BT_CTF_ASSERT_PRE_NON_NULL(stream_class, "Stream class");
	return stream_class->name->len > 0 ? stream_class->name->str : NULL;
}

static inline
int64_t bt_ctf_stream_class_common_get_id(
		struct bt_ctf_stream_class_common *stream_class)
{
	int64_t ret;

	BT_CTF_ASSERT_PRE_NON_NULL(stream_class, "Stream class");

	if (!stream_class->id_set) {
		BT_LOGV("Stream class's ID is not set: addr=%p, name=\"%s\"",
			stream_class,
			bt_ctf_stream_class_common_get_name(stream_class));
		ret = (int64_t) -1;
		goto end;
	}

	ret = stream_class->id;

end:
	return ret;
}

BT_HIDDEN
void bt_ctf_stream_class_common_set_byte_order(
		struct bt_ctf_stream_class_common *stream_class, int byte_order);

BT_HIDDEN
int bt_ctf_stream_class_common_validate_single_clock_class(
		struct bt_ctf_stream_class_common *stream_class,
		struct bt_ctf_clock_class **expected_clock_class);

BT_HIDDEN
int bt_ctf_stream_class_common_add_event_class(
		struct bt_ctf_stream_class_common *stream_class,
		struct bt_ctf_event_class_common *event_class,
		bt_ctf_validation_flag_copy_field_type_func copy_field_type_func);

BT_HIDDEN
int bt_ctf_stream_class_common_visit(struct bt_ctf_stream_class_common *stream_class,
		bt_ctf_visitor visitor, void *data);

BT_HIDDEN
int bt_ctf_stream_class_visit(struct bt_ctf_stream_class *stream_class,
		bt_ctf_visitor visitor, void *data);

static inline
struct bt_ctf_trace_common *bt_ctf_stream_class_common_borrow_trace(
		struct bt_ctf_stream_class_common *stream_class)
{
	BT_ASSERT(stream_class);
	return (void *) bt_ctf_object_borrow_parent(&stream_class->base);
}

static inline
int bt_ctf_stream_class_common_set_name(struct bt_ctf_stream_class_common *stream_class,
		const char *name)
{
	int ret = 0;

	if (!stream_class) {
		BT_LOGW_STR("Invalid parameter: stream class is NULL.");
		ret = -1;
		goto end;
	}

	if (stream_class->frozen) {
		BT_LOGW("Invalid parameter: stream class is frozen: "
			"addr=%p, name=\"%s\", id=%" PRId64,
			stream_class,
			bt_ctf_stream_class_common_get_name(stream_class),
			bt_ctf_stream_class_common_get_id(stream_class));
		ret = -1;
		goto end;
	}

	if (!name) {
		g_string_assign(stream_class->name, "");
	} else {
		if (strlen(name) == 0) {
			BT_LOGW("Invalid parameter: name is empty.");
			ret = -1;
			goto end;
		}

		g_string_assign(stream_class->name, name);
	}

	BT_LOGV("Set stream class's name: "
		"addr=%p, name=\"%s\", id=%" PRId64,
		stream_class, bt_ctf_stream_class_common_get_name(stream_class),
		bt_ctf_stream_class_common_get_id(stream_class));
end:
	return ret;
}

static inline
void _bt_ctf_stream_class_common_set_id(
		struct bt_ctf_stream_class_common *stream_class, int64_t id)
{
	BT_ASSERT(stream_class);
	stream_class->id = id;
	stream_class->id_set = 1;
	BT_LOGV("Set stream class's ID (internal): "
		"addr=%p, name=\"%s\", id=%" PRId64,
		stream_class, bt_ctf_stream_class_common_get_name(stream_class),
		bt_ctf_stream_class_common_get_id(stream_class));
}

static inline
int bt_ctf_stream_class_common_set_id_no_check(
		struct bt_ctf_stream_class_common *stream_class, int64_t id)
{
	_bt_ctf_stream_class_common_set_id(stream_class, id);
	return 0;
}

static inline
int bt_ctf_stream_class_common_set_id(struct bt_ctf_stream_class_common *stream_class,
		uint64_t id_param)
{
	int ret = 0;
	int64_t id = (int64_t) id_param;

	if (!stream_class) {
		BT_LOGW_STR("Invalid parameter: stream class is NULL.");
		ret = -1;
		goto end;
	}

	if (stream_class->frozen) {
		BT_LOGW("Invalid parameter: stream class is frozen: "
			"addr=%p, name=\"%s\", id=%" PRId64,
			stream_class,
			bt_ctf_stream_class_common_get_name(stream_class),
			bt_ctf_stream_class_common_get_id(stream_class));
		ret = -1;
		goto end;
	}

	if (id < 0) {
		BT_LOGW("Invalid parameter: invalid stream class's ID: "
			"stream-class-addr=%p, stream-class-name=\"%s\", "
			"stream-class-id=%" PRId64 ", id=%" PRIu64,
			stream_class,
			bt_ctf_stream_class_common_get_name(stream_class),
			bt_ctf_stream_class_common_get_id(stream_class),
			id_param);
		ret = -1;
		goto end;
	}

	ret = bt_ctf_stream_class_common_set_id_no_check(stream_class, id);
	if (ret == 0) {
		BT_LOGV("Set stream class's ID: "
			"addr=%p, name=\"%s\", id=%" PRId64,
			stream_class,
			bt_ctf_stream_class_common_get_name(stream_class),
			bt_ctf_stream_class_common_get_id(stream_class));
	}
end:
	return ret;
}

static inline
int64_t bt_ctf_stream_class_common_get_event_class_count(
		struct bt_ctf_stream_class_common *stream_class)
{
	int64_t ret;

	if (!stream_class) {
		BT_LOGW_STR("Invalid parameter: stream class is NULL.");
		ret = (int64_t) -1;
		goto end;
	}

	ret = (int64_t) stream_class->event_classes->len;
end:
	return ret;
}

static inline
struct bt_ctf_event_class_common *bt_ctf_stream_class_common_borrow_event_class_by_index(
		struct bt_ctf_stream_class_common *stream_class, uint64_t index)
{
	BT_CTF_ASSERT_PRE_NON_NULL(stream_class, "Stream class");
	BT_CTF_ASSERT_PRE(index < stream_class->event_classes->len,
		"Index is out of bounds: index=%" PRIu64 ", "
		"count=%u",
		index, stream_class->event_classes->len);
	return g_ptr_array_index(stream_class->event_classes, index);
}

static inline
struct bt_ctf_event_class_common *bt_ctf_stream_class_common_borrow_event_class_by_id(
		struct bt_ctf_stream_class_common *stream_class, uint64_t id)
{
	int64_t id_key = (int64_t) id;

	BT_CTF_ASSERT_PRE_NON_NULL(stream_class, "Stream class");
	BT_CTF_ASSERT_PRE(id_key >= 0,
		"Invalid event class ID: %" PRIu64, id);
	return g_hash_table_lookup(stream_class->event_classes_ht,
			&id_key);
}

static inline
struct bt_ctf_field_type_common *
bt_ctf_stream_class_common_borrow_packet_context_field_type(
		struct bt_ctf_stream_class_common *stream_class)
{
	BT_CTF_ASSERT_PRE_NON_NULL(stream_class, "Stream class");
	return stream_class->packet_context_field_type;
}

static inline
int bt_ctf_stream_class_common_set_packet_context_field_type(
		struct bt_ctf_stream_class_common *stream_class,
		struct bt_ctf_field_type_common *packet_context_type)
{
	int ret = 0;

	if (!stream_class) {
		BT_LOGW_STR("Invalid parameter: stream class is NULL.");
		ret = -1;
		goto end;
	}

	if (stream_class->frozen) {
		BT_LOGW("Invalid parameter: stream class is frozen: "
			"addr=%p, name=\"%s\", id=%" PRId64,
			stream_class, bt_ctf_stream_class_common_get_name(stream_class),
			bt_ctf_stream_class_common_get_id(stream_class));
		ret = -1;
		goto end;
	}

	if (packet_context_type &&
			bt_ctf_field_type_common_get_type_id(packet_context_type) !=
				BT_CTF_FIELD_TYPE_ID_STRUCT) {
		/* A packet context must be a structure. */
		BT_LOGW("Invalid parameter: stream class's packet context field type must be a structure: "
			"addr=%p, name=\"%s\", id=%" PRId64 ", "
			"packet-context-ft-addr=%p, packet-context-ft-id=%s",
			stream_class, bt_ctf_stream_class_common_get_name(stream_class),
			bt_ctf_stream_class_common_get_id(stream_class),
			packet_context_type,
			bt_ctf_field_type_id_string(
				bt_ctf_field_type_common_get_type_id(packet_context_type)));
		ret = -1;
		goto end;
	}

	bt_ctf_object_put_ref(stream_class->packet_context_field_type);
	stream_class->packet_context_field_type = packet_context_type;
	bt_ctf_object_get_ref(stream_class->packet_context_field_type);
	BT_LOGV("Set stream class's packet context field type: "
		"addr=%p, name=\"%s\", id=%" PRId64 ", "
		"packet-context-ft-addr=%p",
		stream_class, bt_ctf_stream_class_common_get_name(stream_class),
		bt_ctf_stream_class_common_get_id(stream_class),
		packet_context_type);

end:
	return ret;
}

static inline
struct bt_ctf_field_type_common *
bt_ctf_stream_class_common_borrow_event_header_field_type(
		struct bt_ctf_stream_class_common *stream_class)
{
	struct bt_ctf_field_type_common *ret = NULL;

	BT_CTF_ASSERT_PRE_NON_NULL(stream_class, "Stream class");

	if (!stream_class->event_header_field_type) {
		BT_LOGV("Stream class has no event header field type: "
			"addr=%p, name=\"%s\", id=%" PRId64,
			stream_class,
			bt_ctf_stream_class_common_get_name(stream_class),
			bt_ctf_stream_class_common_get_id(stream_class));
		goto end;
	}

	ret = stream_class->event_header_field_type;

end:
	return ret;
}

static inline
int bt_ctf_stream_class_common_set_event_header_field_type(
		struct bt_ctf_stream_class_common *stream_class,
		struct bt_ctf_field_type_common *event_header_type)
{
	int ret = 0;

	if (!stream_class) {
		BT_LOGW_STR("Invalid parameter: stream class is NULL.");
		ret = -1;
		goto end;
	}

	if (stream_class->frozen) {
		BT_LOGW("Invalid parameter: stream class is frozen: "
			"addr=%p, name=\"%s\", id=%" PRId64,
			stream_class,
			bt_ctf_stream_class_common_get_name(stream_class),
			bt_ctf_stream_class_common_get_id(stream_class));
		ret = -1;
		goto end;
	}

	if (event_header_type &&
			bt_ctf_field_type_common_get_type_id(event_header_type) !=
				BT_CTF_FIELD_TYPE_ID_STRUCT) {
		/* An event header must be a structure. */
		BT_LOGW("Invalid parameter: stream class's event header field type must be a structure: "
			"addr=%p, name=\"%s\", id=%" PRId64 ", "
			"event-header-ft-addr=%p, event-header-ft-id=%s",
			stream_class, bt_ctf_stream_class_common_get_name(stream_class),
			bt_ctf_stream_class_common_get_id(stream_class),
			event_header_type,
			bt_ctf_field_type_id_string(
				bt_ctf_field_type_common_get_type_id(event_header_type)));
		ret = -1;
		goto end;
	}

	bt_ctf_object_put_ref(stream_class->event_header_field_type);
	stream_class->event_header_field_type = event_header_type;
	bt_ctf_object_get_ref(stream_class->event_header_field_type);
	BT_LOGV("Set stream class's event header field type: "
		"addr=%p, name=\"%s\", id=%" PRId64 ", "
		"event-header-ft-addr=%p",
		stream_class, bt_ctf_stream_class_common_get_name(stream_class),
		bt_ctf_stream_class_common_get_id(stream_class),
		event_header_type);
end:
	return ret;
}

static inline
struct bt_ctf_field_type_common *
bt_ctf_stream_class_common_borrow_event_context_field_type(
		struct bt_ctf_stream_class_common *stream_class)
{
	struct bt_ctf_field_type_common *ret = NULL;

	BT_CTF_ASSERT_PRE_NON_NULL(stream_class, "Stream class");

	if (!stream_class->event_context_field_type) {
		goto end;
	}

	ret = stream_class->event_context_field_type;

end:
	return ret;
}

static inline
int bt_ctf_stream_class_common_set_event_context_field_type(
		struct bt_ctf_stream_class_common *stream_class,
		struct bt_ctf_field_type_common *event_context_type)
{
	int ret = 0;

	if (!stream_class) {
		BT_LOGW_STR("Invalid parameter: stream class is NULL.");
		ret = -1;
		goto end;
	}

	if (stream_class->frozen) {
		BT_LOGW("Invalid parameter: stream class is frozen: "
			"addr=%p, name=\"%s\", id=%" PRId64,
			stream_class, bt_ctf_stream_class_common_get_name(stream_class),
			bt_ctf_stream_class_common_get_id(stream_class));
		ret = -1;
		goto end;
	}

	if (event_context_type &&
			bt_ctf_field_type_common_get_type_id(event_context_type) !=
				BT_CTF_FIELD_TYPE_ID_STRUCT) {
		/* A packet context must be a structure. */
		BT_LOGW("Invalid parameter: stream class's event context field type must be a structure: "
			"addr=%p, name=\"%s\", id=%" PRId64 ", "
			"event-context-ft-addr=%p, event-context-ft-id=%s",
			stream_class, bt_ctf_stream_class_common_get_name(stream_class),
			bt_ctf_stream_class_common_get_id(stream_class),
			event_context_type,
			bt_ctf_field_type_id_string(
				bt_ctf_field_type_common_get_type_id(event_context_type)));
		ret = -1;
		goto end;
	}

	bt_ctf_object_put_ref(stream_class->event_context_field_type);
	stream_class->event_context_field_type = event_context_type;
	bt_ctf_object_get_ref(stream_class->event_context_field_type);
	BT_LOGV("Set stream class's event context field type: "
		"addr=%p, name=\"%s\", id=%" PRId64 ", "
		"event-context-ft-addr=%p",
		stream_class, bt_ctf_stream_class_common_get_name(stream_class),
		bt_ctf_stream_class_common_get_id(stream_class),
		event_context_type);
end:
	return ret;
}

struct bt_ctf_stream_class {
	struct bt_ctf_stream_class_common common;
	struct bt_ctf_clock *clock;
	int64_t next_stream_id;
};

struct metadata_context;

BT_HIDDEN
int bt_ctf_stream_class_serialize(struct bt_ctf_stream_class *stream_class,
		struct metadata_context *context);

BT_HIDDEN
int bt_ctf_stream_class_map_clock_class(
		struct bt_ctf_stream_class *stream_class,
		struct bt_ctf_field_type *packet_context_type,
		struct bt_ctf_field_type *event_header_type);

#endif /* BABELTRACE_CTF_WRITER_STREAM_CLASS_INTERNAL_H */
Commit	Line	Data
3dca2276 PP	1	#ifndef BABELTRACE_CTF_WRITER_STREAM_CLASS_INTERNAL_H
	2	#define BABELTRACE_CTF_WRITER_STREAM_CLASS_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
3fadfbc0 MJ	31	#include <babeltrace2/assert-internal.h>
	32	#include <babeltrace2/babeltrace-internal.h>
	33	#include <babeltrace2/common-internal.h>
	34	#include <babeltrace2/ctf-writer/clock-internal.h>
	35	#include <babeltrace2/ctf-writer/field-types-internal.h>
	36	#include <babeltrace2/ctf-writer/field-types.h>
	37	#include <babeltrace2/ctf-writer/stream-class-internal.h>
	38	#include <babeltrace2/ctf-writer/utils-internal.h>
	39	#include <babeltrace2/ctf-writer/validation-internal.h>
	40	#include <babeltrace2/ctf-writer/visitor.h>
	41	#include <babeltrace2/ctf-writer/object-internal.h>
16ca5ff0 PP	42	#include <inttypes.h>
	43
	44	struct bt_ctf_stream_class_common {
e1e02a22	45	struct bt_ctf_object base;
16ca5ff0 PP	46	GString *name;
	47
	48	/* Array of pointers to event class addresses */
	49	GPtrArray *event_classes;
	50
	51	/* event class id (int64_t) to event class address */
	52	GHashTable *event_classes_ht;
	53	int id_set;
	54	int64_t id;
	55	int64_t next_event_id;
	56	struct bt_ctf_field_type_common *packet_context_field_type;
	57	struct bt_ctf_field_type_common *event_header_field_type;
	58	struct bt_ctf_field_type_common *event_context_field_type;
	59	int frozen;
	60	int byte_order;
	61
	62	/*
	63	* This flag indicates if the stream class is valid. A valid
	64	* stream class is _always_ frozen.
	65	*/
	66	int valid;
	67
	68	/*
	69	* Unique clock class mapped to any field type within this
	70	* stream class, including all the stream class's event class
	71	* field types. This is only set if the stream class is frozen.
	72	*
	73	* If the stream class is frozen and this is still NULL, it is
	74	* still possible that it becomes non-NULL because
	75	* bt_ctf_stream_class_add_event_class() can add an event class
	76	* containing a field type mapped to some clock class. In this
	77	* case, this is the mapped clock class, and at this point, both
	78	* the new event class and the stream class are frozen, so the
	79	* next added event classes are expected to contain field types
	80	* which only map to this specific clock class.
	81	*
	82	* If this is a CTF writer stream class, then this is the
	83	* backing clock class of the `clock` member above.
	84	*/
	85	struct bt_ctf_clock_class *clock_class;
	86	};
	87
	88	struct bt_ctf_event_class_common;
	89
	90	BT_HIDDEN
	91	int bt_ctf_stream_class_common_initialize(struct bt_ctf_stream_class_common *stream_class,
e1e02a22	92	const char *name, bt_ctf_object_release_func release_func);
16ca5ff0 PP	93
	94	BT_HIDDEN
	95	void bt_ctf_stream_class_common_finalize(struct bt_ctf_stream_class_common *stream_class);
	96
	97	BT_HIDDEN
	98	void bt_ctf_stream_class_common_freeze(struct bt_ctf_stream_class_common *stream_class);
	99
	100	static inline
	101	const char *bt_ctf_stream_class_common_get_name(
	102	struct bt_ctf_stream_class_common *stream_class)
	103	{
67d2ce02	104	BT_CTF_ASSERT_PRE_NON_NULL(stream_class, "Stream class");
16ca5ff0 PP	105	return stream_class->name->len > 0 ? stream_class->name->str : NULL;
	106	}
	107
	108	static inline
	109	int64_t bt_ctf_stream_class_common_get_id(
	110	struct bt_ctf_stream_class_common *stream_class)
	111	{
	112	int64_t ret;
	113
67d2ce02	114	BT_CTF_ASSERT_PRE_NON_NULL(stream_class, "Stream class");
16ca5ff0 PP	115
	116	if (!stream_class->id_set) {
	117	BT_LOGV("Stream class's ID is not set: addr=%p, name=\"%s\"",
	118	stream_class,
	119	bt_ctf_stream_class_common_get_name(stream_class));
	120	ret = (int64_t) -1;
	121	goto end;
	122	}
	123
	124	ret = stream_class->id;
	125
	126	end:
	127	return ret;
	128	}
	129
	130	BT_HIDDEN
	131	void bt_ctf_stream_class_common_set_byte_order(
	132	struct bt_ctf_stream_class_common *stream_class, int byte_order);
	133
	134	BT_HIDDEN
	135	int bt_ctf_stream_class_common_validate_single_clock_class(
	136	struct bt_ctf_stream_class_common *stream_class,
	137	struct bt_ctf_clock_class **expected_clock_class);
	138
	139	BT_HIDDEN
	140	int bt_ctf_stream_class_common_add_event_class(
	141	struct bt_ctf_stream_class_common *stream_class,
	142	struct bt_ctf_event_class_common *event_class,
	143	bt_ctf_validation_flag_copy_field_type_func copy_field_type_func);
	144
	145	BT_HIDDEN
	146	int bt_ctf_stream_class_common_visit(struct bt_ctf_stream_class_common *stream_class,
	147	bt_ctf_visitor visitor, void *data);
	148
	149	BT_HIDDEN
	150	int bt_ctf_stream_class_visit(struct bt_ctf_stream_class *stream_class,
	151	bt_ctf_visitor visitor, void *data);
	152
	153	static inline
	154	struct bt_ctf_trace_common *bt_ctf_stream_class_common_borrow_trace(
	155	struct bt_ctf_stream_class_common *stream_class)
	156	{
	157	BT_ASSERT(stream_class);
e1e02a22	158	return (void *) bt_ctf_object_borrow_parent(&stream_class->base);
16ca5ff0 PP	159	}
	160
	161	static inline
	162	int bt_ctf_stream_class_common_set_name(struct bt_ctf_stream_class_common *stream_class,
	163	const char *name)
	164	{
	165	int ret = 0;
	166
	167	if (!stream_class) {
	168	BT_LOGW_STR("Invalid parameter: stream class is NULL.");
	169	ret = -1;
	170	goto end;
	171	}
	172
	173	if (stream_class->frozen) {
	174	BT_LOGW("Invalid parameter: stream class is frozen: "
	175	"addr=%p, name=\"%s\", id=%" PRId64,
	176	stream_class,
	177	bt_ctf_stream_class_common_get_name(stream_class),
	178	bt_ctf_stream_class_common_get_id(stream_class));
	179	ret = -1;
	180	goto end;
	181	}
	182
	183	if (!name) {
	184	g_string_assign(stream_class->name, "");
	185	} else {
	186	if (strlen(name) == 0) {
	187	BT_LOGW("Invalid parameter: name is empty.");
	188	ret = -1;
	189	goto end;
	190	}
	191
	192	g_string_assign(stream_class->name, name);
	193	}
	194
	195	BT_LOGV("Set stream class's name: "
	196	"addr=%p, name=\"%s\", id=%" PRId64,
	197	stream_class, bt_ctf_stream_class_common_get_name(stream_class),
	198	bt_ctf_stream_class_common_get_id(stream_class));
	199	end:
	200	return ret;
	201	}
	202
	203	static inline
	204	void _bt_ctf_stream_class_common_set_id(
	205	struct bt_ctf_stream_class_common *stream_class, int64_t id)
	206	{
	207	BT_ASSERT(stream_class);
	208	stream_class->id = id;
	209	stream_class->id_set = 1;
	210	BT_LOGV("Set stream class's ID (internal): "
	211	"addr=%p, name=\"%s\", id=%" PRId64,
	212	stream_class, bt_ctf_stream_class_common_get_name(stream_class),
	213	bt_ctf_stream_class_common_get_id(stream_class));
	214	}
	215
	216	static inline
	217	int bt_ctf_stream_class_common_set_id_no_check(
	218	struct bt_ctf_stream_class_common *stream_class, int64_t id)
	219	{
	220	_bt_ctf_stream_class_common_set_id(stream_class, id);
	221	return 0;
	222	}
223
224	static inline
225	int bt_ctf_stream_class_common_set_id(struct bt_ctf_stream_class_common *stream_class,
226	uint64_t id_param)
227	{
228	int ret = 0;
229	int64_t id = (int64_t) id_param;
230
231	if (!stream_class) {
232	BT_LOGW_STR("Invalid parameter: stream class is NULL.");
233	ret = -1;
234	goto end;
235	}
236
237	if (stream_class->frozen) {
238	BT_LOGW("Invalid parameter: stream class is frozen: "
239	"addr=%p, name=\"%s\", id=%" PRId64,
240	stream_class,
241	bt_ctf_stream_class_common_get_name(stream_class),
242	bt_ctf_stream_class_common_get_id(stream_class));
243	ret = -1;
244	goto end;
245	}
246
247	if (id < 0) {
248	BT_LOGW("Invalid parameter: invalid stream class's ID: "
249	"stream-class-addr=%p, stream-class-name=\"%s\", "
250	"stream-class-id=%" PRId64 ", id=%" PRIu64,
251	stream_class,
252	bt_ctf_stream_class_common_get_name(stream_class),
253	bt_ctf_stream_class_common_get_id(stream_class),
254	id_param);
255	ret = -1;
256	goto end;
257	}
258
259	ret = bt_ctf_stream_class_common_set_id_no_check(stream_class, id);
260	if (ret == 0) {
261	BT_LOGV("Set stream class's ID: "
262	"addr=%p, name=\"%s\", id=%" PRId64,
263	stream_class,
264	bt_ctf_stream_class_common_get_name(stream_class),
265	bt_ctf_stream_class_common_get_id(stream_class));
266	}
267	end:
268	return ret;
269	}
270
271	static inline
272	int64_t bt_ctf_stream_class_common_get_event_class_count(
273	struct bt_ctf_stream_class_common *stream_class)
274	{
275	int64_t ret;
276
277	if (!stream_class) {
278	BT_LOGW_STR("Invalid parameter: stream class is NULL.");
279	ret = (int64_t) -1;
280	goto end;
281	}
282
283	ret = (int64_t) stream_class->event_classes->len;
284	end:
285	return ret;
286	}
287
288	static inline
289	struct bt_ctf_event_class_common *bt_ctf_stream_class_common_borrow_event_class_by_index(
290	struct bt_ctf_stream_class_common *stream_class, uint64_t index)
291	{
67d2ce02 MJ	292	BT_CTF_ASSERT_PRE_NON_NULL(stream_class, "Stream class");
67d2ce02 MJ	293	BT_CTF_ASSERT_PRE(index < stream_class->event_classes->len,
16ca5ff0 PP	294	"Index is out of bounds: index=%" PRIu64 ", "
	295	"count=%u",
	296	index, stream_class->event_classes->len);
	297	return g_ptr_array_index(stream_class->event_classes, index);
	298	}
	299
	300	static inline
	301	struct bt_ctf_event_class_common *bt_ctf_stream_class_common_borrow_event_class_by_id(
	302	struct bt_ctf_stream_class_common *stream_class, uint64_t id)
	303	{
	304	int64_t id_key = (int64_t) id;
	305
67d2ce02 MJ	306	BT_CTF_ASSERT_PRE_NON_NULL(stream_class, "Stream class");
67d2ce02 MJ	307	BT_CTF_ASSERT_PRE(id_key >= 0,
16ca5ff0 PP	308	"Invalid event class ID: %" PRIu64, id);
	309	return g_hash_table_lookup(stream_class->event_classes_ht,
	310	&id_key);
	311	}
	312
	313	static inline
	314	struct bt_ctf_field_type_common *
	315	bt_ctf_stream_class_common_borrow_packet_context_field_type(
	316	struct bt_ctf_stream_class_common *stream_class)
	317	{
67d2ce02	318	BT_CTF_ASSERT_PRE_NON_NULL(stream_class, "Stream class");
16ca5ff0 PP	319	return stream_class->packet_context_field_type;
	320	}
	321
	322	static inline
	323	int bt_ctf_stream_class_common_set_packet_context_field_type(
	324	struct bt_ctf_stream_class_common *stream_class,
	325	struct bt_ctf_field_type_common *packet_context_type)
	326	{
	327	int ret = 0;
	328
	329	if (!stream_class) {
	330	BT_LOGW_STR("Invalid parameter: stream class is NULL.");
	331	ret = -1;
	332	goto end;
	333	}
	334
	335	if (stream_class->frozen) {
	336	BT_LOGW("Invalid parameter: stream class is frozen: "
	337	"addr=%p, name=\"%s\", id=%" PRId64,
	338	stream_class, bt_ctf_stream_class_common_get_name(stream_class),
	339	bt_ctf_stream_class_common_get_id(stream_class));
	340	ret = -1;
	341	goto end;
	342	}
	343
	344	if (packet_context_type &&
	345	bt_ctf_field_type_common_get_type_id(packet_context_type) !=
	346	BT_CTF_FIELD_TYPE_ID_STRUCT) {
	347	/* A packet context must be a structure. */
	348	BT_LOGW("Invalid parameter: stream class's packet context field type must be a structure: "
	349	"addr=%p, name=\"%s\", id=%" PRId64 ", "
	350	"packet-context-ft-addr=%p, packet-context-ft-id=%s",
	351	stream_class, bt_ctf_stream_class_common_get_name(stream_class),
	352	bt_ctf_stream_class_common_get_id(stream_class),
	353	packet_context_type,
	354	bt_ctf_field_type_id_string(
	355	bt_ctf_field_type_common_get_type_id(packet_context_type)));
	356	ret = -1;
	357	goto end;
	358	}
	359
e1e02a22	360	bt_ctf_object_put_ref(stream_class->packet_context_field_type);
16ca5ff0	361	stream_class->packet_context_field_type = packet_context_type;
e1e02a22	362	bt_ctf_object_get_ref(stream_class->packet_context_field_type);
16ca5ff0 PP	363	BT_LOGV("Set stream class's packet context field type: "
	364	"addr=%p, name=\"%s\", id=%" PRId64 ", "
	365	"packet-context-ft-addr=%p",
	366	stream_class, bt_ctf_stream_class_common_get_name(stream_class),
	367	bt_ctf_stream_class_common_get_id(stream_class),
	368	packet_context_type);
	369
	370	end:
	371	return ret;
	372	}
	373
	374	static inline
	375	struct bt_ctf_field_type_common *
	376	bt_ctf_stream_class_common_borrow_event_header_field_type(
	377	struct bt_ctf_stream_class_common *stream_class)
	378	{
	379	struct bt_ctf_field_type_common *ret = NULL;
	380
67d2ce02	381	BT_CTF_ASSERT_PRE_NON_NULL(stream_class, "Stream class");
16ca5ff0 PP	382
	383	if (!stream_class->event_header_field_type) {
	384	BT_LOGV("Stream class has no event header field type: "
	385	"addr=%p, name=\"%s\", id=%" PRId64,
	386	stream_class,
	387	bt_ctf_stream_class_common_get_name(stream_class),
	388	bt_ctf_stream_class_common_get_id(stream_class));
	389	goto end;
	390	}
	391
	392	ret = stream_class->event_header_field_type;
	393
	394	end:
	395	return ret;
	396	}
	397
	398	static inline
	399	int bt_ctf_stream_class_common_set_event_header_field_type(
	400	struct bt_ctf_stream_class_common *stream_class,
	401	struct bt_ctf_field_type_common *event_header_type)
	402	{
	403	int ret = 0;
	404
	405	if (!stream_class) {
	406	BT_LOGW_STR("Invalid parameter: stream class is NULL.");
	407	ret = -1;
	408	goto end;
	409	}
	410
	411	if (stream_class->frozen) {
	412	BT_LOGW("Invalid parameter: stream class is frozen: "
	413	"addr=%p, name=\"%s\", id=%" PRId64,
	414	stream_class,
	415	bt_ctf_stream_class_common_get_name(stream_class),
	416	bt_ctf_stream_class_common_get_id(stream_class));
	417	ret = -1;
	418	goto end;
	419	}
	420
	421	if (event_header_type &&
	422	bt_ctf_field_type_common_get_type_id(event_header_type) !=
	423	BT_CTF_FIELD_TYPE_ID_STRUCT) {
	424	/* An event header must be a structure. */
	425	BT_LOGW("Invalid parameter: stream class's event header field type must be a structure: "
	426	"addr=%p, name=\"%s\", id=%" PRId64 ", "
	427	"event-header-ft-addr=%p, event-header-ft-id=%s",
	428	stream_class, bt_ctf_stream_class_common_get_name(stream_class),
	429	bt_ctf_stream_class_common_get_id(stream_class),
	430	event_header_type,
	431	bt_ctf_field_type_id_string(
	432	bt_ctf_field_type_common_get_type_id(event_header_type)));
	433	ret = -1;
	434	goto end;
	435	}
	436
e1e02a22 PP	437	bt_ctf_object_put_ref(stream_class->event_header_field_type);
	438	stream_class->event_header_field_type = event_header_type;
	439	bt_ctf_object_get_ref(stream_class->event_header_field_type);
16ca5ff0 PP	440	BT_LOGV("Set stream class's event header field type: "
	441	"addr=%p, name=\"%s\", id=%" PRId64 ", "
	442	"event-header-ft-addr=%p",
	443	stream_class, bt_ctf_stream_class_common_get_name(stream_class),
	444	bt_ctf_stream_class_common_get_id(stream_class),
	445	event_header_type);
	446	end:
	447	return ret;
	448	}
	449
	450	static inline
	451	struct bt_ctf_field_type_common *
	452	bt_ctf_stream_class_common_borrow_event_context_field_type(
	453	struct bt_ctf_stream_class_common *stream_class)
	454	{
	455	struct bt_ctf_field_type_common *ret = NULL;
	456
67d2ce02	457	BT_CTF_ASSERT_PRE_NON_NULL(stream_class, "Stream class");
16ca5ff0 PP	458
	459	if (!stream_class->event_context_field_type) {
	460	goto end;
	461	}
	462
	463	ret = stream_class->event_context_field_type;
	464
	465	end:
	466	return ret;
	467	}
	468
	469	static inline
	470	int bt_ctf_stream_class_common_set_event_context_field_type(
	471	struct bt_ctf_stream_class_common *stream_class,
	472	struct bt_ctf_field_type_common *event_context_type)
	473	{
	474	int ret = 0;
	475
	476	if (!stream_class) {
	477	BT_LOGW_STR("Invalid parameter: stream class is NULL.");
	478	ret = -1;
	479	goto end;
	480	}
	481
	482	if (stream_class->frozen) {
	483	BT_LOGW("Invalid parameter: stream class is frozen: "
	484	"addr=%p, name=\"%s\", id=%" PRId64,
	485	stream_class, bt_ctf_stream_class_common_get_name(stream_class),
	486	bt_ctf_stream_class_common_get_id(stream_class));
	487	ret = -1;
	488	goto end;
	489	}
	490
	491	if (event_context_type &&
	492	bt_ctf_field_type_common_get_type_id(event_context_type) !=
	493	BT_CTF_FIELD_TYPE_ID_STRUCT) {
	494	/* A packet context must be a structure. */
	495	BT_LOGW("Invalid parameter: stream class's event context field type must be a structure: "
	496	"addr=%p, name=\"%s\", id=%" PRId64 ", "
	497	"event-context-ft-addr=%p, event-context-ft-id=%s",
	498	stream_class, bt_ctf_stream_class_common_get_name(stream_class),
	499	bt_ctf_stream_class_common_get_id(stream_class),
	500	event_context_type,
	501	bt_ctf_field_type_id_string(
	502	bt_ctf_field_type_common_get_type_id(event_context_type)));
	503	ret = -1;
	504	goto end;
	505	}
	506
e1e02a22 PP	507	bt_ctf_object_put_ref(stream_class->event_context_field_type);
	508	stream_class->event_context_field_type = event_context_type;
	509	bt_ctf_object_get_ref(stream_class->event_context_field_type);
16ca5ff0 PP	510	BT_LOGV("Set stream class's event context field type: "
	511	"addr=%p, name=\"%s\", id=%" PRId64 ", "
	512	"event-context-ft-addr=%p",
	513	stream_class, bt_ctf_stream_class_common_get_name(stream_class),
	514	bt_ctf_stream_class_common_get_id(stream_class),
	515	event_context_type);
	516	end:
	517	return ret;
	518	}
3dca2276 PP	519
3dca2276 PP	520	struct bt_ctf_stream_class {
16ca5ff0	521	struct bt_ctf_stream_class_common common;
3dca2276 PP	522	struct bt_ctf_clock *clock;
	523	int64_t next_stream_id;
	524	};
	525
	526	struct metadata_context;
	527
	528	BT_HIDDEN
	529	int bt_ctf_stream_class_serialize(struct bt_ctf_stream_class *stream_class,
	530	struct metadata_context *context);
	531
	532	BT_HIDDEN
	533	int bt_ctf_stream_class_map_clock_class(
	534	struct bt_ctf_stream_class *stream_class,
	535	struct bt_ctf_field_type *packet_context_type,
	536	struct bt_ctf_field_type *event_header_type);
	537
	538	#endif /* BABELTRACE_CTF_WRITER_STREAM_CLASS_INTERNAL_H */