sessiond: return raw pointer to packet header

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

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

#include "field.hpp"

#include <common/exception.hpp>
#include <common/format.hpp>

#include <set>

namespace lst = lttng::sessiond::trace;

namespace {
template <class FieldTypeSet>
bool fields_are_equal(const FieldTypeSet& a, const FieldTypeSet& b)
{
	if (a.size() != b.size()) {
		return false;
	}

	return std::equal(a.cbegin(), a.cend(), b.cbegin(),
			[](typename FieldTypeSet::const_reference field_a,
					typename FieldTypeSet::const_reference field_b) {
				return *field_a == *field_b;
			});
}
} /* namespace */

lst::type::type(unsigned int in_alignment) : alignment{in_alignment}
{
}

lst::type::~type()
{
}

bool lst::type::operator==(const lst::type& other) const noexcept
{
	return typeid(*this) == typeid(other) &&
		alignment == other.alignment &&
		/* defer to concrete type comparison */
		this->_is_equal(other);
}

bool lst::type::operator!=(const lst::type& other) const noexcept
{
	return !(*this == other);
}

lst::field::field(std::string in_name, lst::type::cuptr in_type) :
	name{std::move(in_name)}, _type{std::move(in_type)}
{
}

void lst::field::accept(lst::field_visitor& visitor) const
{
	visitor.visit(*this);
}

bool lst::field::operator==(const lst::field& other) const noexcept
{
	return name == other.name && *_type == *other._type;
}

lst::integer_type::integer_type(unsigned int in_alignment,
		enum lst::byte_order in_byte_order,
		unsigned int in_size,
		enum lst::integer_type::signedness in_signedness,
		enum lst::integer_type::base in_base,
		roles in_roles) :
	type(in_alignment),
	byte_order{in_byte_order},
	size{in_size},
	signedness_{in_signedness},
	base_{in_base},
	roles_{std::move(in_roles)}
{
}

bool lst::integer_type::_is_equal(const type &base_other) const noexcept
{
	const auto& other = static_cast<decltype(*this)&>(base_other);

	return this->byte_order == other.byte_order &&
		this->size == other.size &&
		this->signedness_ == other.signedness_ &&
		this->base_ == other.base_ &&
		this->roles_ == other.roles_;
}

void lst::integer_type::accept(type_visitor& visitor) const
{
	visitor.visit(*this);
}

lst::byte_order lst::type::reverse_byte_order(lst::byte_order byte_order) noexcept
{
	if (byte_order == lst::byte_order::BIG_ENDIAN_) {
		return lst::byte_order::LITTLE_ENDIAN_;
	} else {
		return lst::byte_order::BIG_ENDIAN_;
	}
}

lst::floating_point_type::floating_point_type(unsigned int in_alignment,
		lst::byte_order in_byte_order,
		unsigned int in_exponent_digits,
		unsigned int in_mantissa_digits) :
	type(in_alignment),
	byte_order(in_byte_order),
	exponent_digits{in_exponent_digits},
	mantissa_digits(in_mantissa_digits)
{
	/* Allowed (exponent, mantissa) pairs. */
	static const std::set<std::pair<unsigned int, unsigned int>> allowed_pairs{
			{5, 11}, /* binary16 */
			{8, 24}, /* binary32 */
			{11, 53}, /* binary64 */
			{15, 113}, /* binary128 */
	};

	if (allowed_pairs.find({exponent_digits, mantissa_digits}) != allowed_pairs.end()) {
		/* mantissa and exponent digits is a valid pair. */
		return;
	}

	LTTNG_THROW_INVALID_ARGUMENT_ERROR(
			fmt::format("Invalid exponent/mantissa values provided while creating {}",
					typeid(*this)));
}

void lst::floating_point_type::accept(type_visitor& visitor) const
{
	visitor.visit(*this);
}

bool lst::floating_point_type::_is_equal(const type& base_other) const noexcept
{
	const auto& other = static_cast<decltype(*this)&>(base_other);

	return this->byte_order == other.byte_order &&
			this->exponent_digits == other.exponent_digits &&
			this->mantissa_digits == other.mantissa_digits;
}

lst::enumeration_type::enumeration_type(unsigned int in_alignment,
		enum lst::byte_order in_byte_order,
		unsigned int in_size,
		enum signedness in_signedness,
		enum base in_base,
		lst::integer_type::roles in_roles) :
	integer_type(in_alignment,
			in_byte_order,
			in_size,
			in_signedness,
			in_base,
			std::move(in_roles))
{
}

namespace lttng {
namespace sessiond {
namespace trace {
template <>
void lst::signed_enumeration_type::accept(type_visitor& visitor) const
{
	visitor.visit(*this);
}

template <>
void lst::unsigned_enumeration_type::accept(type_visitor& visitor) const
{
	visitor.visit(*this);
}
} /* namespace trace */
} /* namespace sessiond */
} /* namespace lttng */

lst::array_type::array_type(unsigned int in_alignment, type::cuptr in_element_type) :
	type(in_alignment), element_type{std::move(in_element_type)}
{
}

bool lst::array_type::_is_equal(const type& base_other) const noexcept
{
	const auto& other = static_cast<decltype(*this)&>(base_other);

	return *this->element_type == *other.element_type;
}

lst::static_length_array_type::static_length_array_type(unsigned int in_alignment,
		type::cuptr in_element_type,
		uint64_t in_length) :
	array_type(in_alignment, std::move(in_element_type)),
	length{in_length}
{
}

bool lst::static_length_array_type::_is_equal(const type& base_other) const noexcept
{
	const auto& other = static_cast<decltype(*this)&>(base_other);

	return array_type::_is_equal(base_other) && this->length == other.length;
}

void lst::static_length_array_type::accept(type_visitor& visitor) const
{
	visitor.visit(*this);
}

lst::dynamic_length_array_type::dynamic_length_array_type(unsigned int in_alignment,
		type::cuptr in_element_type,
		std::string in_length_field_name) :
	array_type(in_alignment, std::move(in_element_type)),
	length_field_name{std::move(in_length_field_name)}
{
}

bool lst::dynamic_length_array_type::_is_equal(const type& base_other) const noexcept
{
	const auto& other = static_cast<decltype(*this)&>(base_other);

	return array_type::_is_equal(base_other) &&
			this->length_field_name == other.length_field_name;
}

void lst::dynamic_length_array_type::accept(type_visitor& visitor) const
{
	visitor.visit(*this);
}

lst::static_length_blob_type::static_length_blob_type(
		unsigned int in_alignment, uint64_t in_length_bytes, roles in_roles) :
	type(in_alignment), length_bytes{in_length_bytes}, roles_{std::move(in_roles)}
{
}

bool lst::static_length_blob_type::_is_equal(const type& base_other) const noexcept
{
	const auto& other = static_cast<decltype(*this)&>(base_other);

	return length_bytes == other.length_bytes && roles_ == other.roles_;
}

void lst::static_length_blob_type::accept(type_visitor& visitor) const
{
	visitor.visit(*this);
}

lst::dynamic_length_blob_type::dynamic_length_blob_type(
		unsigned int in_alignment, std::string in_length_field_name) :
	type(in_alignment), length_field_name{std::move(in_length_field_name)}
{
}

bool lst::dynamic_length_blob_type::_is_equal(const type& base_other) const noexcept
{
	const auto& other = dynamic_cast<decltype(*this)&>(base_other);

	return length_field_name == other.length_field_name;
}

void lst::dynamic_length_blob_type::accept(type_visitor& visitor) const
{
	visitor.visit(*this);
}

lst::string_type::string_type(unsigned int in_alignment, enum encoding in_encoding) :
	type(in_alignment), encoding_{in_encoding}
{
}

bool lst::string_type::_is_equal(const type& base_other) const noexcept
{
	const auto& other = static_cast<decltype(*this)&>(base_other);

	return this->encoding_ == other.encoding_;
}

lst::static_length_string_type::static_length_string_type(
		unsigned int in_alignment, enum encoding in_encoding, uint64_t in_length) :
	string_type(in_alignment, in_encoding), length{in_length}
{
}

bool lst::static_length_string_type::_is_equal(const type& base_other) const noexcept
{
	const auto& other = static_cast<decltype(*this)&>(base_other);

	return string_type::_is_equal(base_other) && this->length == other.length;
}

void lst::static_length_string_type::accept(type_visitor& visitor) const
{
	visitor.visit(*this);
}

lst::dynamic_length_string_type::dynamic_length_string_type(unsigned int in_alignment,
		enum encoding in_encoding,
		std::string in_length_field_name) :
	string_type(in_alignment, in_encoding), length_field_name{std::move(in_length_field_name)}
{
}

bool lst::dynamic_length_string_type::_is_equal(const type& base_other) const noexcept
{
	const auto& other = static_cast<decltype(*this)&>(base_other);

	return string_type::_is_equal(base_other) &&
			this->length_field_name == other.length_field_name;
}

void lst::dynamic_length_string_type::accept(type_visitor& visitor) const
{
	visitor.visit(*this);
}

lst::null_terminated_string_type::null_terminated_string_type(unsigned int in_alignment,
		enum encoding in_encoding) :
	string_type(in_alignment, in_encoding)
{
}

void lst::null_terminated_string_type::accept(type_visitor& visitor) const
{
	visitor.visit(*this);
}

lst::structure_type::structure_type(unsigned int in_alignment, fields in_fields) :
	type(in_alignment), _fields{std::move(in_fields)}
{
}

bool lst::structure_type::_is_equal(const type& base_other) const noexcept
{
	const auto &other = static_cast<decltype(*this)&>(base_other);

	return fields_are_equal(this->_fields, other._fields);
}

void lst::structure_type::accept(type_visitor& visitor) const
{
	visitor.visit(*this);
}

lst::variant_type::variant_type(unsigned int in_alignment,
		std::string in_tag_name,
		choices in_choices) :
	type(in_alignment),
	tag_name{std::move(in_tag_name)},
	_choices{std::move(in_choices)}
{
}

bool lst::variant_type::_is_equal(const type& base_other) const noexcept
{
	const auto &other = static_cast<decltype(*this)&>(base_other);

	return this->tag_name == other.tag_name &&
			fields_are_equal(this->_choices, other._choices);
}

void lst::variant_type::accept(type_visitor& visitor) const
{
	visitor.visit(*this);
}