X-Git-Url: https://git.lttng.org/?a=blobdiff_plain;f=src%2Fbin%2Flttng-sessiond%2Ffield.cpp;h=e46e06631eae121b4736547b31995839783bd381;hb=4f2da8b8c0f8fad2ae35dbdb9f29769da52a3dc1;hp=df2808841e6c2dfb324a635c0aa85ec1e520fd64;hpb=65cd3c0cfa205aa6f67ff974f561882d5eafdd89;p=lttng-tools.git diff --git a/src/bin/lttng-sessiond/field.cpp b/src/bin/lttng-sessiond/field.cpp index df2808841..e46e06631 100644 --- a/src/bin/lttng-sessiond/field.cpp +++ b/src/bin/lttng-sessiond/field.cpp @@ -30,6 +30,18 @@ bool fields_are_equal(const FieldTypeSet& a, const FieldTypeSet& b) } } /* namespace */ +lst::field_location::field_location(lst::field_location::root in_lookup_root, + lst::field_location::elements in_elements) : + root_{in_lookup_root}, elements_{std::move(in_elements)} +{ +} + +bool lst::field_location::operator==(const lst::field_location& other) const noexcept +{ + return root_ == other.root_ && + elements_ == other.elements_; +} + lst::type::type(unsigned int in_alignment) : alignment{in_alignment} { } @@ -54,6 +66,9 @@ bool lst::type::operator!=(const lst::type& other) const noexcept lst::field::field(std::string in_name, lst::type::cuptr in_type) : name{std::move(in_name)}, _type{std::move(in_type)} { + if (!_type) { + LTTNG_THROW_ERROR(fmt::format("Invalid type used to create field: field name = `{}`", name)); + } } void lst::field::accept(lst::field_visitor& visitor) const @@ -66,19 +81,41 @@ bool lst::field::operator==(const lst::field& other) const noexcept return name == other.name && *_type == *other._type; } +lst::type::cuptr lst::field::move_type() noexcept +{ + return std::move(_type); +} + +const lst::type &lst::field::get_type() const +{ + if (_type) { + return *_type; + } else { + LTTNG_THROW_ERROR(fmt::format("Invalid attempt to access field type after transfer: field name = `{}`", name)); + } +} + 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) : + 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} + base_{in_base}, + roles_{std::move(in_roles)} { } +lst::type::cuptr lst::integer_type::copy() const +{ + return lttng::make_unique( + alignment, byte_order, size, signedness_, base_, roles_); +} + bool lst::integer_type::_is_equal(const type &base_other) const noexcept { const auto& other = static_cast(base_other); @@ -86,7 +123,8 @@ bool lst::integer_type::_is_equal(const type &base_other) const noexcept return this->byte_order == other.byte_order && this->size == other.size && this->signedness_ == other.signedness_ && - this->base_ == other.base_; + this->base_ == other.base_ && + this->roles_ == other.roles_; } void lst::integer_type::accept(type_visitor& visitor) const @@ -130,6 +168,12 @@ lst::floating_point_type::floating_point_type(unsigned int in_alignment, typeid(*this))); } +lst::type::cuptr lst::floating_point_type::copy() const +{ + return lttng::make_unique( + alignment, byte_order, exponent_digits, mantissa_digits); +} + void lst::floating_point_type::accept(type_visitor& visitor) const { visitor.visit(*this); @@ -148,22 +192,53 @@ 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) : - integer_type(in_alignment, in_byte_order, in_size, in_signedness, in_base) + 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)) +{ +} + +/* + * Due to a bug in g++ < 7.1, these specializations must be enclosed in the namespaces + * rather than using the usual `namespace::namespace::function` notation: + * see https://gcc.gnu.org/bugzilla/show_bug.cgi?id=56480. + */ +namespace lttng { +namespace sessiond { +namespace trace { +template <> +void signed_enumeration_type::accept(type_visitor& visitor) const { + visitor.visit(*this); +} + +template <> +void unsigned_enumeration_type::accept(type_visitor& visitor) const +{ + visitor.visit(*this); } template <> -void lst::signed_enumeration_type::accept(type_visitor& visitor) const +void variant_type::accept( + lst::type_visitor& visitor) const { visitor.visit(*this); } template <> -void lst::unsigned_enumeration_type::accept(type_visitor& visitor) const +void variant_type::accept( + lst::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)} @@ -192,6 +267,12 @@ bool lst::static_length_array_type::_is_equal(const type& base_other) const noex return array_type::_is_equal(base_other) && this->length == other.length; } +lst::type::cuptr lst::static_length_array_type::copy() const +{ + return lttng::make_unique( + alignment, element_type->copy(), length); +} + void lst::static_length_array_type::accept(type_visitor& visitor) const { visitor.visit(*this); @@ -199,9 +280,9 @@ void lst::static_length_array_type::accept(type_visitor& visitor) const lst::dynamic_length_array_type::dynamic_length_array_type(unsigned int in_alignment, type::cuptr in_element_type, - std::string in_length_field_name) : + lst::field_location in_length_field_location) : array_type(in_alignment, std::move(in_element_type)), - length_field_name{std::move(in_length_field_name)} + length_field_location{std::move(in_length_field_location)} { } @@ -210,7 +291,13 @@ bool lst::dynamic_length_array_type::_is_equal(const type& base_other) const noe const auto& other = static_cast(base_other); return array_type::_is_equal(base_other) && - this->length_field_name == other.length_field_name; + this->length_field_location == other.length_field_location; +} + +lst::type::cuptr lst::dynamic_length_array_type::copy() const +{ + return lttng::make_unique( + alignment, element_type->copy(), length_field_location); } void lst::dynamic_length_array_type::accept(type_visitor& visitor) const @@ -218,6 +305,52 @@ 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(base_other); + + return length_bytes == other.length_bytes && roles_ == other.roles_; +} + +lst::type::cuptr lst::static_length_blob_type::copy() const +{ + return lttng::make_unique(alignment, length_bytes, 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, lst::field_location in_length_field_location) : + type(in_alignment), length_field_location{std::move(in_length_field_location)} +{ +} + +bool lst::dynamic_length_blob_type::_is_equal(const type& base_other) const noexcept +{ + const auto& other = dynamic_cast(base_other); + + return length_field_location == other.length_field_location; +} + +lst::type::cuptr lst::dynamic_length_blob_type::copy() const +{ + return lttng::make_unique(alignment, length_field_location); +} + +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} { @@ -243,6 +376,11 @@ bool lst::static_length_string_type::_is_equal(const type& base_other) const noe return string_type::_is_equal(base_other) && this->length == other.length; } +lst::type::cuptr lst::static_length_string_type::copy() const +{ + return lttng::make_unique(alignment, encoding_, length); +} + void lst::static_length_string_type::accept(type_visitor& visitor) const { visitor.visit(*this); @@ -250,8 +388,9 @@ void lst::static_length_string_type::accept(type_visitor& visitor) const 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)} + field_location in_length_field_location) : + string_type(in_alignment, in_encoding), + length_field_location{std::move(in_length_field_location)} { } @@ -260,7 +399,13 @@ bool lst::dynamic_length_string_type::_is_equal(const type& base_other) const no const auto& other = static_cast(base_other); return string_type::_is_equal(base_other) && - this->length_field_name == other.length_field_name; + this->length_field_location == other.length_field_location; +} + +lst::type::cuptr lst::dynamic_length_string_type::copy() const +{ + return lttng::make_unique( + alignment, encoding_, length_field_location); } void lst::dynamic_length_string_type::accept(type_visitor& visitor) const @@ -274,13 +419,18 @@ lst::null_terminated_string_type::null_terminated_string_type(unsigned int in_al { } +lst::type::cuptr lst::null_terminated_string_type::copy() const +{ + return lttng::make_unique(alignment, 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)} + type(in_alignment), fields_{std::move(in_fields)} { } @@ -288,32 +438,23 @@ bool lst::structure_type::_is_equal(const type& base_other) const noexcept { const auto &other = static_cast(base_other); - return fields_are_equal(this->_fields, other._fields); + return fields_are_equal(this->fields_, other.fields_); } -void lst::structure_type::accept(type_visitor& visitor) const +lst::type::cuptr lst::structure_type::copy() const { - visitor.visit(*this); -} + structure_type::fields copy_of_fields; -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(base_other); + copy_of_fields.reserve(fields_.size()); + for (const auto& field : fields_) { + copy_of_fields.emplace_back(lttng::make_unique( + field->name, field->get_type().copy())); + } - return this->tag_name == other.tag_name && - fields_are_equal(this->_choices, other._choices); + return lttng::make_unique(alignment, std::move(copy_of_fields)); } -void lst::variant_type::accept(type_visitor& visitor) const +void lst::structure_type::accept(type_visitor& visitor) const { visitor.visit(*this); }