[lttng-tools.git] / src / bin / lttng-sessiond / field.hpp

/*
 * Copyright (C) 2022 Jérémie Galarneau <jeremie.galarneau@efficios.com>
 *
 * SPDX-License-Identifier: GPL-2.0-only
 *
 */

#ifndef LTTNG_FIELD_H
#define LTTNG_FIELD_H

#include <common/format.hpp>

#include <vendor/optional.hpp>

#include <memory>
#include <string>
#include <type_traits>
#include <vector>

namespace lttng {
namespace sessiond {
namespace trace {

class field_visitor;
class type_visitor;

enum class byte_order {
	BIG_ENDIAN_,
	LITTLE_ENDIAN_,
};

class field_location {
public:
	enum class root {
		PACKET_HEADER,
		PACKET_CONTEXT,
		EVENT_RECORD_HEADER,
		EVENT_RECORD_COMMON_CONTEXT,
		EVENT_RECORD_SPECIFIC_CONTEXT,
		EVENT_RECORD_PAYLOAD,
	};

	using elements = std::vector<std::string>;

	field_location(root lookup_root, elements elements);
	bool operator==(const field_location& other) const noexcept;

	const root root_;
	const elements elements_;
};

/*
 * Field, and the various field types, represents fields as exposed by the
 * LTTng tracers. These classes do not attempt to describe the complete spectrum of the CTF
 * specification.
 */

class type {
public:
	using cuptr = std::unique_ptr<const type>;

	static byte_order reverse_byte_order(byte_order byte_order) noexcept;

	bool operator==(const type& other) const noexcept;
	bool operator!=(const type& other) const noexcept;
	virtual ~type();
	virtual void accept(type_visitor& visitor) const = 0;

	const unsigned int alignment;

protected:
	type(unsigned int alignment);

private:
	virtual bool _is_equal(const type& rhs) const noexcept = 0;
};

class field {
public:
	using cuptr = std::unique_ptr<const field>;

	field(std::string name, type::cuptr type);
	void accept(field_visitor& visitor) const;
	bool operator==(const field& other) const noexcept;

	const std::string name;
	const type::cuptr _type;
};

class integer_type : public type {
public:
	enum class signedness {
		SIGNED,
		UNSIGNED,
	};

	enum class base {
		BINARY = 2,
		OCTAL = 8,
		DECIMAL = 10,
		HEXADECIMAL = 16,
	};

	enum class role {
		DEFAULT_CLOCK_TIMESTAMP,
		/* Packet header field class specific roles. */
		DATA_STREAM_CLASS_ID,
		DATA_STREAM_ID,
		PACKET_MAGIC_NUMBER,
		/* Packet context field class specific roles. */
		DISCARDED_EVENT_RECORD_COUNTER_SNAPSHOT,
		PACKET_CONTENT_LENGTH,
		PACKET_END_DEFAULT_CLOCK_TIMESTAMP,
		PACKET_SEQUENCE_NUMBER,
		PACKET_TOTAL_LENGTH,
		/* Event record field class roles. */
		EVENT_RECORD_CLASS_ID,
	};

	using roles = std::vector<role>;

	integer_type(unsigned int alignment,
			byte_order byte_order,
			unsigned int size,
			signedness signedness,
			base base,
			roles roles = {});

	virtual void accept(type_visitor& visitor) const override;

	const enum byte_order byte_order;
	const unsigned int size;
	/*
	 * signedness and base are suffixed with '_' to work-around a bug in older
	 * GCCs (before 6) that do not recognize hidden/shadowed enumeration as valid
	 * nested-name-specifiers.
	 */
	const signedness signedness_;
	const base base_;
	const roles roles_;

protected:
	virtual bool _is_equal(const type& other) const noexcept override;
};

class floating_point_type : public type {
public:
	floating_point_type(unsigned int alignment,
			byte_order byte_order,
			unsigned int exponent_digits,
			unsigned int mantissa_digits);

	virtual void accept(type_visitor& visitor) const override final;

	const enum byte_order byte_order;
	const unsigned int exponent_digits;
	const unsigned int mantissa_digits;

private:
	virtual bool _is_equal(const type& other) const noexcept override final;
};

class enumeration_type : public integer_type {
protected:
	enumeration_type(unsigned int alignment,
			enum byte_order byte_order,
			unsigned int size,
			enum signedness signedness,
			enum base base,
			integer_type::roles roles = {});

	virtual void accept(type_visitor& visitor) const = 0;
};

namespace details {
template <class MappingIntegerType>
class enumeration_mapping_range {
public:
	using range_integer_t = MappingIntegerType;

	enumeration_mapping_range(MappingIntegerType in_begin, MappingIntegerType in_end) :
		begin{in_begin}, end{in_end}
	{
	}

	const range_integer_t begin, end;
};

template <class MappingIntegerType>
bool operator==(const enumeration_mapping_range<MappingIntegerType>& lhs,
		const enumeration_mapping_range<MappingIntegerType>& rhs) noexcept
{
	return lhs.begin == rhs.begin && lhs.end == rhs.end;
}

template <class MappingIntegerType>
class enumeration_mapping {
public:
	using range_t = enumeration_mapping_range<MappingIntegerType>;

	enumeration_mapping(const enumeration_mapping<MappingIntegerType>& other) = delete;
	enumeration_mapping(const enumeration_mapping<MappingIntegerType>&& other) :
		name{std::move(other.name)}, range{other.range}
	{
	}

	/* Mapping with an implicit value. */
	enumeration_mapping(std::string in_name) : name{std::move(in_name)}
	{
	}

	enumeration_mapping(std::string in_name, range_t in_range) : name{std::move(in_name)}, range{in_range}
	{
	}

	const std::string name;
	const nonstd::optional<range_t> range;
};

template <class MappingIntegerType>
bool operator==(const enumeration_mapping<MappingIntegerType>& lhs,
		const enumeration_mapping<MappingIntegerType>& rhs) noexcept
{
	return lhs.name == rhs.name && lhs.range == rhs.range;
}
} /* namespace details */

template <class MappingIntegerType>
class typed_enumeration_type : public enumeration_type {
public:
	using mapping = details::enumeration_mapping<MappingIntegerType>;
	using mappings = std::vector<mapping>;

	static_assert(std::is_integral<MappingIntegerType>::value &&
					sizeof(MappingIntegerType) == 8,
			"MappingIntegerType must be either int64_t or uint64_t");

	typed_enumeration_type(unsigned int in_alignment,
			enum byte_order in_byte_order,
			unsigned int in_size,
			enum base in_base,
			const std::shared_ptr<const mappings>& in_mappings,
			integer_type::roles in_roles = {}) :
		enumeration_type(in_alignment,
				in_byte_order,
				in_size,
				std::is_signed<MappingIntegerType>::value ?
						integer_type::signedness::SIGNED :
						      integer_type::signedness::UNSIGNED,
				in_base,
				std::move(in_roles)),
		_mappings{std::move(in_mappings)}
	{
	}

	virtual void accept(type_visitor& visitor) const override final;

	const std::shared_ptr<const mappings> _mappings;

private:
	virtual bool _is_equal(const type& base_other) const noexcept override final
	{
		const auto& other = static_cast<const typed_enumeration_type<MappingIntegerType>&>(
				base_other);

		return integer_type::_is_equal(base_other) && *this->_mappings == *other._mappings;
	}
};

/* Aliases for all allowed enumeration mapping types. */
using signed_enumeration_type = typed_enumeration_type<int64_t>;
using unsigned_enumeration_type = typed_enumeration_type<uint64_t>;

class array_type : public type {
public:
	array_type(unsigned int alignment, type::cuptr element_type);

	const type::cuptr element_type;

protected:
	virtual bool _is_equal(const type& base_other) const noexcept override;
};

class static_length_array_type : public array_type {
public:
	static_length_array_type(unsigned int alignment,
			type::cuptr element_type,
			uint64_t in_length);

	virtual void accept(type_visitor& visitor) const override final;

	const uint64_t length;

private:
	virtual bool _is_equal(const type& base_other) const noexcept override final;
};

class dynamic_length_array_type : public array_type {
public:
	dynamic_length_array_type(unsigned int alignment,
			type::cuptr element_type,
			field_location length_field_location);

	virtual void accept(type_visitor& visitor) const override final;

	const field_location length_field_location;

private:
	virtual bool _is_equal(const type& base_other) const noexcept override final;
};

class static_length_blob_type : public type {
public:
	enum class role {
		/* Packet header field class specific role. */
		TRACE_CLASS_UUID,
	};

	using roles = std::vector<role>;

	static_length_blob_type(unsigned int alignment, uint64_t in_length_bytes, roles roles = {});

	virtual void accept(type_visitor& visitor) const override final;

	const uint64_t length_bytes;
	const roles roles_;

private:
	virtual bool _is_equal(const type& base_other) const noexcept override final;
};

class dynamic_length_blob_type : public type {
public:
	dynamic_length_blob_type(unsigned int alignment, field_location length_field_location);

	virtual void accept(type_visitor& visitor) const override final;

	const field_location length_field_location;

private:
	virtual bool _is_equal(const type& base_other) const noexcept override final;
};

class string_type : public type {
public:
	enum class encoding {
		ASCII,
		UTF8,
	};

	string_type(unsigned int alignment, enum encoding encoding);

	/*
	 * encoding is suffixed with '_' to work-around a bug in older
	 * GCCs (before 6) that do not recognize hidden/shadowed enumeration as valid
	 * nested-name-specifiers.
	 */
	const encoding encoding_;

protected:
	virtual bool _is_equal(const type& base_other) const noexcept override;
};

class static_length_string_type : public string_type {
public:
	static_length_string_type(
			unsigned int alignment, enum encoding in_encoding, uint64_t length);
	virtual void accept(type_visitor& visitor) const override final;

	const uint64_t length;

private:
	virtual bool _is_equal(const type& base_other) const noexcept override final;
};

class dynamic_length_string_type : public string_type {
public:
	dynamic_length_string_type(unsigned int alignment,
			enum encoding in_encoding,
			field_location length_field_location);
	virtual void accept(type_visitor& visitor) const override final;

	const field_location length_field_location;

private:
	virtual bool _is_equal(const type& base_other) const noexcept override final;
};

class null_terminated_string_type : public string_type {
public:
	null_terminated_string_type(unsigned int alignment, enum encoding in_encoding);
	virtual void accept(type_visitor& visitor) const override final;
};

class structure_type : public type {
public:
	using fields = std::vector<field::cuptr>;

	structure_type(unsigned int alignment, fields in_fields);

	virtual void accept(type_visitor& visitor) const override final;

	const fields _fields;

private:
	virtual bool _is_equal(const type& base_other) const noexcept override final;
};

class variant_type : public type {
public:
	using choices = std::vector<field::cuptr>;

	variant_type(unsigned int alignment,
			field_location selector_field_location,
			choices in_choices);

	virtual void accept(type_visitor& visitor) const override final;

	const field_location selector_field_location;
	const choices _choices;
;

private:
	virtual bool _is_equal(const type& base_other) const noexcept override final;
};

class field_visitor {
public:
	virtual ~field_visitor() = default;
	virtual void visit(const field& field) = 0;

protected:
	field_visitor() = default;
};

class type_visitor {
public:
	virtual ~type_visitor() = default;
	virtual void visit(const integer_type& type) = 0;
	virtual void visit(const floating_point_type& type) = 0;
	virtual void visit(const signed_enumeration_type& type) = 0;
	virtual void visit(const unsigned_enumeration_type& type) = 0;
	virtual void visit(const static_length_array_type& type) = 0;
	virtual void visit(const dynamic_length_array_type& type) = 0;
	virtual void visit(const static_length_blob_type& type) = 0;
	virtual void visit(const dynamic_length_blob_type& type) = 0;
	virtual void visit(const null_terminated_string_type& type) = 0;
	virtual void visit(const static_length_string_type& type) = 0;
	virtual void visit(const dynamic_length_string_type& type) = 0;
	virtual void visit(const structure_type& type) = 0;
	virtual void visit(const variant_type& type) = 0;

protected:
	type_visitor() = default;
};

} /* namespace trace */
} /* namespace sessiond */
} /* namespace lttng */

/*
 * Due to a bug in g++ < 7.1, this specialization must be enclosed in the fmt namespace,
 * see https://gcc.gnu.org/bugzilla/show_bug.cgi?id=56480.
 */
namespace fmt {
template <>
struct formatter<lttng::sessiond::trace::field_location> : formatter<std::string> {
	template <typename FormatCtx>
	typename FormatCtx::iterator format(
			const lttng::sessiond::trace::field_location& location, FormatCtx& ctx)
	{
		std::string location_str{"["};

		switch (location.root_) {
		case lttng::sessiond::trace::field_location::root::PACKET_HEADER:
			location_str += "\"packet-header\"";
			break;
		case lttng::sessiond::trace::field_location::root::PACKET_CONTEXT:
			location_str += "\"packet-context\"";
			break;
		case lttng::sessiond::trace::field_location::root::EVENT_RECORD_HEADER:
			location_str += "\"event-record-header\"";
			break;
		case lttng::sessiond::trace::field_location::root::EVENT_RECORD_COMMON_CONTEXT:
			location_str += "\"event-record-common-context\"";
			break;
		case lttng::sessiond::trace::field_location::root::EVENT_RECORD_SPECIFIC_CONTEXT:
			location_str += "\"event-record-specific-context\"";
			break;
		case lttng::sessiond::trace::field_location::root::EVENT_RECORD_PAYLOAD:
			location_str += "\"event-record-payload\"";
			break;
		}

		for (const auto &name : location.elements_) {
			location_str += ", \"" + name + "\"";
		}

		location_str += "]";
		return format_to(ctx.out(), location_str);
	}
};
} /* namespace fmt */

#endif /* LTTNG_FIELD_H */
Commit	Line	Data
0220be14 JG	1	/*
	2	* Copyright (C) 2022 Jérémie Galarneau <jeremie.galarneau@efficios.com>
	3	*
	4	* SPDX-License-Identifier: GPL-2.0-only
	5	*
	6	*/
	7
	8	#ifndef LTTNG_FIELD_H
	9	#define LTTNG_FIELD_H
	10
6e01cdc6 JG	11	#include <common/format.hpp>
	12
	13	#include <vendor/optional.hpp>
	14
0220be14 JG	15	#include <memory>
	16	#include <string>
	17	#include <type_traits>
	18	#include <vector>
	19
0220be14 JG	20	namespace lttng {
	21	namespace sessiond {
	22	namespace trace {
	23
	24	class field_visitor;
	25	class type_visitor;
	26
24ed18f2 JG	27	enum class byte_order {
	28	BIG_ENDIAN_,
	29	LITTLE_ENDIAN_,
	30	};
	31
eda1aa02 JG	32	class field_location {
	33	public:
	34	enum class root {
	35	PACKET_HEADER,
	36	PACKET_CONTEXT,
	37	EVENT_RECORD_HEADER,
	38	EVENT_RECORD_COMMON_CONTEXT,
	39	EVENT_RECORD_SPECIFIC_CONTEXT,
	40	EVENT_RECORD_PAYLOAD,
	41	};
	42
	43	using elements = std::vector<std::string>;
	44
	45	field_location(root lookup_root, elements elements);
	46	bool operator==(const field_location& other) const noexcept;
	47
	48	const root root_;
	49	const elements elements_;
	50	};
	51
0220be14 JG	52	/*
	53	* Field, and the various field types, represents fields as exposed by the
	54	* LTTng tracers. These classes do not attempt to describe the complete spectrum of the CTF
	55	* specification.
	56	*/
	57
	58	class type {
	59	public:
	60	using cuptr = std::unique_ptr<const type>;
	61
	62	static byte_order reverse_byte_order(byte_order byte_order) noexcept;
	63
	64	bool operator==(const type& other) const noexcept;
	65	bool operator!=(const type& other) const noexcept;
	66	virtual ~type();
	67	virtual void accept(type_visitor& visitor) const = 0;
	68
	69	const unsigned int alignment;
	70
	71	protected:
	72	type(unsigned int alignment);
	73
	74	private:
	75	virtual bool _is_equal(const type& rhs) const noexcept = 0;
	76	};
	77
	78	class field {
	79	public:
	80	using cuptr = std::unique_ptr<const field>;
	81
	82	field(std::string name, type::cuptr type);
	83	void accept(field_visitor& visitor) const;
	84	bool operator==(const field& other) const noexcept;
	85
	86	const std::string name;
	87	const type::cuptr _type;
	88	};
	89
	90	class integer_type : public type {
	91	public:
	92	enum class signedness {
	93	SIGNED,
	94	UNSIGNED,
	95	};
	96
	97	enum class base {
	98	BINARY = 2,
	99	OCTAL = 8,
	100	DECIMAL = 10,
	101	HEXADECIMAL = 16,
	102	};
	103
e7360180 JG	104	enum class role {
	105	DEFAULT_CLOCK_TIMESTAMP,
	106	/* Packet header field class specific roles. */
	107	DATA_STREAM_CLASS_ID,
	108	DATA_STREAM_ID,
	109	PACKET_MAGIC_NUMBER,
	110	/* Packet context field class specific roles. */
	111	DISCARDED_EVENT_RECORD_COUNTER_SNAPSHOT,
	112	PACKET_CONTENT_LENGTH,
	113	PACKET_END_DEFAULT_CLOCK_TIMESTAMP,
	114	PACKET_SEQUENCE_NUMBER,
	115	PACKET_TOTAL_LENGTH,
	116	/* Event record field class roles. */
	117	EVENT_RECORD_CLASS_ID,
	118	};
	119
	120	using roles = std::vector<role>;
	121
0220be14 JG	122	integer_type(unsigned int alignment,
	123	byte_order byte_order,
	124	unsigned int size,
	125	signedness signedness,
e7360180 JG	126	base base,
e7360180 JG	127	roles roles = {});
0220be14 JG	128
	129	virtual void accept(type_visitor& visitor) const override;
	130
	131	const enum byte_order byte_order;
	132	const unsigned int size;
65cd3c0c JG	133	/*
	134	* signedness and base are suffixed with '_' to work-around a bug in older
	135	* GCCs (before 6) that do not recognize hidden/shadowed enumeration as valid
	136	* nested-name-specifiers.
	137	*/
	138	const signedness signedness_;
	139	const base base_;
e7360180	140	const roles roles_;
0220be14 JG	141
	142	protected:
	143	virtual bool _is_equal(const type& other) const noexcept override;
	144	};
	145
	146	class floating_point_type : public type {
	147	public:
	148	floating_point_type(unsigned int alignment,
	149	byte_order byte_order,
	150	unsigned int exponent_digits,
	151	unsigned int mantissa_digits);
	152
	153	virtual void accept(type_visitor& visitor) const override final;
	154
	155	const enum byte_order byte_order;
	156	const unsigned int exponent_digits;
	157	const unsigned int mantissa_digits;
	158
	159	private:
	160	virtual bool _is_equal(const type& other) const noexcept override final;
	161	};
	162
	163	class enumeration_type : public integer_type {
	164	protected:
	165	enumeration_type(unsigned int alignment,
	166	enum byte_order byte_order,
	167	unsigned int size,
	168	enum signedness signedness,
e7360180 JG	169	enum base base,
e7360180 JG	170	integer_type::roles roles = {});
0220be14 JG	171
	172	virtual void accept(type_visitor& visitor) const = 0;
	173	};
	174
	175	namespace details {
	176	template <class MappingIntegerType>
	177	class enumeration_mapping_range {
	178	public:
	179	using range_integer_t = MappingIntegerType;
	180
	181	enumeration_mapping_range(MappingIntegerType in_begin, MappingIntegerType in_end) :
	182	begin{in_begin}, end{in_end}
	183	{
	184	}
	185
	186	const range_integer_t begin, end;
	187	};
	188
	189	template <class MappingIntegerType>
	190	bool operator==(const enumeration_mapping_range<MappingIntegerType>& lhs,
	191	const enumeration_mapping_range<MappingIntegerType>& rhs) noexcept
	192	{
	193	return lhs.begin == rhs.begin && lhs.end == rhs.end;
	194	}
	195
	196	template <class MappingIntegerType>
	197	class enumeration_mapping {
	198	public:
	199	using range_t = enumeration_mapping_range<MappingIntegerType>;
	200
	201	enumeration_mapping(const enumeration_mapping<MappingIntegerType>& other) = delete;
	202	enumeration_mapping(const enumeration_mapping<MappingIntegerType>&& other) :
	203	name{std::move(other.name)}, range{other.range}
	204	{
	205	}
	206
	207	/* Mapping with an implicit value. */
	208	enumeration_mapping(std::string in_name) : name{std::move(in_name)}
	209	{
	210	}
	211
	212	enumeration_mapping(std::string in_name, range_t in_range) : name{std::move(in_name)}, range{in_range}
	213	{
	214	}
	215
	216	const std::string name;
	217	const nonstd::optional<range_t> range;
	218	};
	219
	220	template <class MappingIntegerType>
	221	bool operator==(const enumeration_mapping<MappingIntegerType>& lhs,
	222	const enumeration_mapping<MappingIntegerType>& rhs) noexcept
	223	{
	224	return lhs.name == rhs.name && lhs.range == rhs.range;
	225	}
	226	} /* namespace details */
	227
	228	template <class MappingIntegerType>
	229	class typed_enumeration_type : public enumeration_type {
	230	public:
	231	using mapping = details::enumeration_mapping<MappingIntegerType>;
	232	using mappings = std::vector<mapping>;
	233
	234	static_assert(std::is_integral<MappingIntegerType>::value &&
235	sizeof(MappingIntegerType) == 8,
236	"MappingIntegerType must be either int64_t or uint64_t");
237
238	typed_enumeration_type(unsigned int in_alignment,
239	enum byte_order in_byte_order,
240	unsigned int in_size,
0220be14	241	enum base in_base,
e7360180 JG	242	const std::shared_ptr<const mappings>& in_mappings,
e7360180 JG	243	integer_type::roles in_roles = {}) :
0220be14 JG	244	enumeration_type(in_alignment,
	245	in_byte_order,
	246	in_size,
e7360180 JG	247	std::is_signed<MappingIntegerType>::value ?
	248	integer_type::signedness::SIGNED :
	249	integer_type::signedness::UNSIGNED,
	250	in_base,
	251	std::move(in_roles)),
0220be14 JG	252	_mappings{std::move(in_mappings)}
	253	{
	254	}
	255
	256	virtual void accept(type_visitor& visitor) const override final;
	257
	258	const std::shared_ptr<const mappings> _mappings;
	259
	260	private:
	261	virtual bool _is_equal(const type& base_other) const noexcept override final
	262	{
	263	const auto& other = static_cast<const typed_enumeration_type<MappingIntegerType>&>(
	264	base_other);
	265
	266	return integer_type::_is_equal(base_other) && this->_mappings == other._mappings;
	267	}
	268	};
	269
	270	/* Aliases for all allowed enumeration mapping types. */
	271	using signed_enumeration_type = typed_enumeration_type<int64_t>;
	272	using unsigned_enumeration_type = typed_enumeration_type<uint64_t>;
	273
	274	class array_type : public type {
	275	public:
	276	array_type(unsigned int alignment, type::cuptr element_type);
	277
d7bfb9b0	278	const type::cuptr element_type;
0220be14 JG	279
	280	protected:
	281	virtual bool _is_equal(const type& base_other) const noexcept override;
	282	};
	283
	284	class static_length_array_type : public array_type {
	285	public:
	286	static_length_array_type(unsigned int alignment,
	287	type::cuptr element_type,
	288	uint64_t in_length);
	289
	290	virtual void accept(type_visitor& visitor) const override final;
	291
	292	const uint64_t length;
	293
	294	private:
	295	virtual bool _is_equal(const type& base_other) const noexcept override final;
	296	};
	297
	298	class dynamic_length_array_type : public array_type {
	299	public:
	300	dynamic_length_array_type(unsigned int alignment,
	301	type::cuptr element_type,
eda1aa02	302	field_location length_field_location);
0220be14 JG	303
	304	virtual void accept(type_visitor& visitor) const override final;
	305
eda1aa02	306	const field_location length_field_location;
0220be14 JG	307
	308	private:
	309	virtual bool _is_equal(const type& base_other) const noexcept override final;
	310	};
	311
e7360180 JG	312	class static_length_blob_type : public type {
	313	public:
	314	enum class role {
	315	/* Packet header field class specific role. */
	316	TRACE_CLASS_UUID,
	317	};
	318
	319	using roles = std::vector<role>;
	320
	321	static_length_blob_type(unsigned int alignment, uint64_t in_length_bytes, roles roles = {});
	322
	323	virtual void accept(type_visitor& visitor) const override final;
	324
	325	const uint64_t length_bytes;
	326	const roles roles_;
	327
	328	private:
	329	virtual bool _is_equal(const type& base_other) const noexcept override final;
	330	};
	331
	332	class dynamic_length_blob_type : public type {
	333	public:
eda1aa02	334	dynamic_length_blob_type(unsigned int alignment, field_location length_field_location);
e7360180 JG	335
	336	virtual void accept(type_visitor& visitor) const override final;
	337
eda1aa02	338	const field_location length_field_location;
e7360180 JG	339
	340	private:
	341	virtual bool _is_equal(const type& base_other) const noexcept override final;
	342	};
	343
0220be14 JG	344	class string_type : public type {
	345	public:
	346	enum class encoding {
	347	ASCII,
	348	UTF8,
	349	};
	350
	351	string_type(unsigned int alignment, enum encoding encoding);
	352
65cd3c0c JG	353	/*
	354	* encoding is suffixed with '_' to work-around a bug in older
	355	* GCCs (before 6) that do not recognize hidden/shadowed enumeration as valid
	356	* nested-name-specifiers.
	357	*/
	358	const encoding encoding_;
0220be14 JG	359
	360	protected:
	361	virtual bool _is_equal(const type& base_other) const noexcept override;
	362	};
	363
	364	class static_length_string_type : public string_type {
	365	public:
	366	static_length_string_type(
	367	unsigned int alignment, enum encoding in_encoding, uint64_t length);
	368	virtual void accept(type_visitor& visitor) const override final;
	369
	370	const uint64_t length;
	371
	372	private:
	373	virtual bool _is_equal(const type& base_other) const noexcept override final;
	374	};
	375
	376	class dynamic_length_string_type : public string_type {
	377	public:
	378	dynamic_length_string_type(unsigned int alignment,
	379	enum encoding in_encoding,
eda1aa02	380	field_location length_field_location);
0220be14 JG	381	virtual void accept(type_visitor& visitor) const override final;
0220be14 JG	382
eda1aa02	383	const field_location length_field_location;
0220be14 JG	384
	385	private:
	386	virtual bool _is_equal(const type& base_other) const noexcept override final;
	387	};
	388
	389	class null_terminated_string_type : public string_type {
	390	public:
	391	null_terminated_string_type(unsigned int alignment, enum encoding in_encoding);
	392	virtual void accept(type_visitor& visitor) const override final;
	393	};
	394
	395	class structure_type : public type {
	396	public:
	397	using fields = std::vector<field::cuptr>;
	398
	399	structure_type(unsigned int alignment, fields in_fields);
	400
	401	virtual void accept(type_visitor& visitor) const override final;
	402
	403	const fields _fields;
	404
	405	private:
	406	virtual bool _is_equal(const type& base_other) const noexcept override final;
	407	};
	408
	409	class variant_type : public type {
	410	public:
	411	using choices = std::vector<field::cuptr>;
	412
eda1aa02 JG	413	variant_type(unsigned int alignment,
	414	field_location selector_field_location,
	415	choices in_choices);
0220be14 JG	416
	417	virtual void accept(type_visitor& visitor) const override final;
	418
eda1aa02	419	const field_location selector_field_location;
0220be14	420	const choices _choices;
eda1aa02	421	;
0220be14 JG	422
	423	private:
	424	virtual bool _is_equal(const type& base_other) const noexcept override final;
	425	};
	426
	427	class field_visitor {
	428	public:
	429	virtual ~field_visitor() = default;
	430	virtual void visit(const field& field) = 0;
	431
	432	protected:
	433	field_visitor() = default;
	434	};
	435
	436	class type_visitor {
	437	public:
	438	virtual ~type_visitor() = default;
	439	virtual void visit(const integer_type& type) = 0;
	440	virtual void visit(const floating_point_type& type) = 0;
	441	virtual void visit(const signed_enumeration_type& type) = 0;
	442	virtual void visit(const unsigned_enumeration_type& type) = 0;
	443	virtual void visit(const static_length_array_type& type) = 0;
	444	virtual void visit(const dynamic_length_array_type& type) = 0;
e7360180 JG	445	virtual void visit(const static_length_blob_type& type) = 0;
e7360180 JG	446	virtual void visit(const dynamic_length_blob_type& type) = 0;
0220be14 JG	447	virtual void visit(const null_terminated_string_type& type) = 0;
	448	virtual void visit(const static_length_string_type& type) = 0;
	449	virtual void visit(const dynamic_length_string_type& type) = 0;
	450	virtual void visit(const structure_type& type) = 0;
	451	virtual void visit(const variant_type& type) = 0;
	452
	453	protected:
	454	type_visitor() = default;
	455	};
	456
	457	} /* namespace trace */
	458	} /* namespace sessiond */
	459	} /* namespace lttng */
	460
6e01cdc6 JG	461	/*
	462	* Due to a bug in g++ < 7.1, this specialization must be enclosed in the fmt namespace,
	463	* see https://gcc.gnu.org/bugzilla/show_bug.cgi?id=56480.
	464	*/
	465	namespace fmt {
	466	template <>
	467	struct formatter<lttng::sessiond::trace::field_location> : formatter<std::string> {
	468	template <typename FormatCtx>
	469	typename FormatCtx::iterator format(
	470	const lttng::sessiond::trace::field_location& location, FormatCtx& ctx)
	471	{
	472	std::string location_str{"["};
	473
	474	switch (location.root_) {
	475	case lttng::sessiond::trace::field_location::root::PACKET_HEADER:
	476	location_str += "\"packet-header\"";
	477	break;
	478	case lttng::sessiond::trace::field_location::root::PACKET_CONTEXT:
	479	location_str += "\"packet-context\"";
	480	break;
	481	case lttng::sessiond::trace::field_location::root::EVENT_RECORD_HEADER:
	482	location_str += "\"event-record-header\"";
	483	break;
	484	case lttng::sessiond::trace::field_location::root::EVENT_RECORD_COMMON_CONTEXT:
	485	location_str += "\"event-record-common-context\"";
	486	break;
	487	case lttng::sessiond::trace::field_location::root::EVENT_RECORD_SPECIFIC_CONTEXT:
	488	location_str += "\"event-record-specific-context\"";
	489	break;
	490	case lttng::sessiond::trace::field_location::root::EVENT_RECORD_PAYLOAD:
	491	location_str += "\"event-record-payload\"";
	492	break;
	493	}
	494
	495	for (const auto &name : location.elements_) {
	496	location_str += ", \"" + name + "\"";
	497	}
	498
	499	location_str += "]";
	500	return format_to(ctx.out(), location_str);
	501	}
	502	};
	503	} /* namespace fmt */
	504
0220be14	505	#endif /* LTTNG_FIELD_H */