diff --git a/.gitignore b/.gitignore index b3ddd54..1feee30 100644 --- a/.gitignore +++ b/.gitignore @@ -1,6 +1,4 @@ build/ .cache -*.pb.cc -*.pb.h diff --git a/include/SimCore/Messages/Protos/Control.pb.cc b/include/SimCore/Messages/Protos/Control.pb.cc new file mode 100644 index 0000000..6b8153c --- /dev/null +++ b/include/SimCore/Messages/Protos/Control.pb.cc @@ -0,0 +1,461 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: Control.proto + +#include "Control.pb.h" + +#include +#include "google/protobuf/io/coded_stream.h" +#include "google/protobuf/extension_set.h" +#include "google/protobuf/wire_format_lite.h" +#include "google/protobuf/descriptor.h" +#include "google/protobuf/generated_message_reflection.h" +#include "google/protobuf/reflection_ops.h" +#include "google/protobuf/wire_format.h" +#include "google/protobuf/generated_message_tctable_impl.h" +// @@protoc_insertion_point(includes) + +// Must be included last. +#include "google/protobuf/port_def.inc" +PROTOBUF_PRAGMA_INIT_SEG +namespace _pb = ::google::protobuf; +namespace _pbi = ::google::protobuf::internal; +namespace _fl = ::google::protobuf::internal::field_layout; +namespace messages { +namespace control { + +inline constexpr control::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : _cached_size_{0}, + data_( + &::google::protobuf::internal::fixed_address_empty_string, + ::_pbi::ConstantInitialized()), + identifier_{nullptr}, + timestamp_{::uint64_t{0u}}, + type_{0u} {} + +template +PROTOBUF_CONSTEXPR control::control(::_pbi::ConstantInitialized) + : _impl_(::_pbi::ConstantInitialized()) {} +struct controlDefaultTypeInternal { + PROTOBUF_CONSTEXPR controlDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~controlDefaultTypeInternal() {} + union { + control _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 controlDefaultTypeInternal _control_default_instance_; +} // namespace control +} // namespace messages +static ::_pb::Metadata file_level_metadata_Control_2eproto[1]; +static constexpr const ::_pb::EnumDescriptor** + file_level_enum_descriptors_Control_2eproto = nullptr; +static constexpr const ::_pb::ServiceDescriptor** + file_level_service_descriptors_Control_2eproto = nullptr; +const ::uint32_t + TableStruct_Control_2eproto::offsets[] ABSL_ATTRIBUTE_SECTION_VARIABLE( + protodesc_cold) = { + PROTOBUF_FIELD_OFFSET(::messages::control::control, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::messages::control::control, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + ~0u, // no _split_ + ~0u, // no sizeof(Split) + PROTOBUF_FIELD_OFFSET(::messages::control::control, _impl_.identifier_), + PROTOBUF_FIELD_OFFSET(::messages::control::control, _impl_.type_), + PROTOBUF_FIELD_OFFSET(::messages::control::control, _impl_.data_), + PROTOBUF_FIELD_OFFSET(::messages::control::control, _impl_.timestamp_), + 0, + ~0u, + ~0u, + 1, +}; + +static const ::_pbi::MigrationSchema + schemas[] ABSL_ATTRIBUTE_SECTION_VARIABLE(protodesc_cold) = { + {0, 12, -1, sizeof(::messages::control::control)}, +}; + +static const ::_pb::Message* const file_default_instances[] = { + &::messages::control::_control_default_instance_._instance, +}; +const char descriptor_table_protodef_Control_2eproto[] ABSL_ATTRIBUTE_SECTION_VARIABLE( + protodesc_cold) = { + "\n\rControl.proto\022\020messages.control\032\020Ident" + "ifier.proto\"{\n\007control\022.\n\nIdentifier\030\001 \001" + "(\0132\032.messages.track.Identifier\022\014\n\004type\030\002" + " \001(\r\022\014\n\004data\030\003 \001(\t\022\026\n\ttimestamp\030\004 \001(\004H\000\210" + "\001\001B\014\n\n_timestampb\006proto3" +}; +static const ::_pbi::DescriptorTable* const descriptor_table_Control_2eproto_deps[1] = + { + &::descriptor_table_Identifier_2eproto, +}; +static ::absl::once_flag descriptor_table_Control_2eproto_once; +const ::_pbi::DescriptorTable descriptor_table_Control_2eproto = { + false, + false, + 184, + descriptor_table_protodef_Control_2eproto, + "Control.proto", + &descriptor_table_Control_2eproto_once, + descriptor_table_Control_2eproto_deps, + 1, + 1, + schemas, + file_default_instances, + TableStruct_Control_2eproto::offsets, + file_level_metadata_Control_2eproto, + file_level_enum_descriptors_Control_2eproto, + file_level_service_descriptors_Control_2eproto, +}; + +// This function exists to be marked as weak. +// It can significantly speed up compilation by breaking up LLVM's SCC +// in the .pb.cc translation units. Large translation units see a +// reduction of more than 35% of walltime for optimized builds. Without +// the weak attribute all the messages in the file, including all the +// vtables and everything they use become part of the same SCC through +// a cycle like: +// GetMetadata -> descriptor table -> default instances -> +// vtables -> GetMetadata +// By adding a weak function here we break the connection from the +// individual vtables back into the descriptor table. +PROTOBUF_ATTRIBUTE_WEAK const ::_pbi::DescriptorTable* descriptor_table_Control_2eproto_getter() { + return &descriptor_table_Control_2eproto; +} +// Force running AddDescriptors() at dynamic initialization time. +PROTOBUF_ATTRIBUTE_INIT_PRIORITY2 +static ::_pbi::AddDescriptorsRunner dynamic_init_dummy_Control_2eproto(&descriptor_table_Control_2eproto); +namespace messages { +namespace control { +// =================================================================== + +class control::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(control, _impl_._has_bits_); + static const ::messages::track::Identifier& identifier(const control* msg); + static void set_has_identifier(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_timestamp(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } +}; + +const ::messages::track::Identifier& control::_Internal::identifier(const control* msg) { + return *msg->_impl_.identifier_; +} +void control::clear_identifier() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + if (_impl_.identifier_ != nullptr) _impl_.identifier_->Clear(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +control::control(::google::protobuf::Arena* arena) + : ::google::protobuf::Message(arena) { + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:messages.control.control) +} +inline PROTOBUF_NDEBUG_INLINE control::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, + const Impl_& from) + : _has_bits_{from._has_bits_}, + _cached_size_{0}, + data_(arena, from.data_) {} + +control::control( + ::google::protobuf::Arena* arena, + const control& from) + : ::google::protobuf::Message(arena) { + control* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_); + ::uint32_t cached_has_bits = _impl_._has_bits_[0]; + _impl_.identifier_ = (cached_has_bits & 0x00000001u) + ? CreateMaybeMessage<::messages::track::Identifier>(arena, *from._impl_.identifier_) + : nullptr; + ::memcpy(reinterpret_cast(&_impl_) + + offsetof(Impl_, timestamp_), + reinterpret_cast(&from._impl_) + + offsetof(Impl_, timestamp_), + offsetof(Impl_, type_) - + offsetof(Impl_, timestamp_) + + sizeof(Impl_::type_)); + + // @@protoc_insertion_point(copy_constructor:messages.control.control) +} +inline PROTOBUF_NDEBUG_INLINE control::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : _cached_size_{0}, + data_(arena) {} + +inline void control::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + ::memset(reinterpret_cast(&_impl_) + + offsetof(Impl_, identifier_), + 0, + offsetof(Impl_, type_) - + offsetof(Impl_, identifier_) + + sizeof(Impl_::type_)); +} +control::~control() { + // @@protoc_insertion_point(destructor:messages.control.control) + _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + SharedDtor(); +} +inline void control::SharedDtor() { + ABSL_DCHECK(GetArena() == nullptr); + _impl_.data_.Destroy(); + delete _impl_.identifier_; + _impl_.~Impl_(); +} + +const ::google::protobuf::MessageLite::ClassData* +control::GetClassData() const { + PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite::ClassData + _data_ = { + control::MergeImpl, + nullptr, // OnDemandRegisterArenaDtor + &::google::protobuf::Message::kDescriptorMethods, + PROTOBUF_FIELD_OFFSET(control, _impl_._cached_size_), + }; + return &_data_; +} +PROTOBUF_NOINLINE void control::Clear() { +// @@protoc_insertion_point(message_clear_start:messages.control.control) + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.data_.ClearToEmpty(); + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + ABSL_DCHECK(_impl_.identifier_ != nullptr); + _impl_.identifier_->Clear(); + } + _impl_.timestamp_ = ::uint64_t{0u}; + _impl_.type_ = 0u; + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +const char* control::_InternalParse( + const char* ptr, ::_pbi::ParseContext* ctx) { + ptr = ::_pbi::TcParser::ParseLoop(this, ptr, ctx, &_table_.header); + return ptr; +} + + +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<2, 4, 1, 37, 2> control::_table_ = { + { + PROTOBUF_FIELD_OFFSET(control, _impl_._has_bits_), + 0, // no _extensions_ + 4, 24, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967280, // skipmap + offsetof(decltype(_table_), field_entries), + 4, // num_field_entries + 1, // num_aux_entries + offsetof(decltype(_table_), aux_entries), + &_control_default_instance_._instance, + ::_pbi::TcParser::GenericFallback, // fallback + }, {{ + // optional uint64 timestamp = 4; + {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(control, _impl_.timestamp_), 1>(), + {32, 1, 0, PROTOBUF_FIELD_OFFSET(control, _impl_.timestamp_)}}, + // .messages.track.Identifier Identifier = 1; + {::_pbi::TcParser::FastMtS1, + {10, 0, 0, PROTOBUF_FIELD_OFFSET(control, _impl_.identifier_)}}, + // uint32 type = 2; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(control, _impl_.type_), 63>(), + {16, 63, 0, PROTOBUF_FIELD_OFFSET(control, _impl_.type_)}}, + // string data = 3; + {::_pbi::TcParser::FastUS1, + {26, 63, 0, PROTOBUF_FIELD_OFFSET(control, _impl_.data_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // .messages.track.Identifier Identifier = 1; + {PROTOBUF_FIELD_OFFSET(control, _impl_.identifier_), _Internal::kHasBitsOffset + 0, 0, + (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // uint32 type = 2; + {PROTOBUF_FIELD_OFFSET(control, _impl_.type_), -1, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // string data = 3; + {PROTOBUF_FIELD_OFFSET(control, _impl_.data_), -1, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // optional uint64 timestamp = 4; + {PROTOBUF_FIELD_OFFSET(control, _impl_.timestamp_), _Internal::kHasBitsOffset + 1, 0, + (0 | ::_fl::kFcOptional | ::_fl::kUInt64)}, + }}, {{ + {::_pbi::TcParser::GetTable<::messages::track::Identifier>()}, + }}, {{ + "\30\0\0\4\0\0\0\0" + "messages.control.control" + "data" + }}, +}; + +::uint8_t* control::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:messages.control.control) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // .messages.track.Identifier Identifier = 1; + if (cached_has_bits & 0x00000001u) { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 1, _Internal::identifier(this), + _Internal::identifier(this).GetCachedSize(), target, stream); + } + + // uint32 type = 2; + if (this->_internal_type() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 2, this->_internal_type(), target); + } + + // string data = 3; + if (!this->_internal_data().empty()) { + const std::string& _s = this->_internal_data(); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "messages.control.control.data"); + target = stream->WriteStringMaybeAliased(3, _s, target); + } + + // optional uint64 timestamp = 4; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt64ToArray( + 4, this->_internal_timestamp(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = + ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:messages.control.control) + return target; +} + +::size_t control::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:messages.control.control) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // string data = 3; + if (!this->_internal_data().empty()) { + total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( + this->_internal_data()); + } + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + // .messages.track.Identifier Identifier = 1; + if (cached_has_bits & 0x00000001u) { + total_size += + 1 + ::google::protobuf::internal::WireFormatLite::MessageSize(*_impl_.identifier_); + } + + // optional uint64 timestamp = 4; + if (cached_has_bits & 0x00000002u) { + total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne( + this->_internal_timestamp()); + } + + } + // uint32 type = 2; + if (this->_internal_type() != 0) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this->_internal_type()); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + + +void control::MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:messages.control.control) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (!from._internal_data().empty()) { + _this->_internal_set_data(from._internal_data()); + } + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_mutable_identifier()->::messages::track::Identifier::MergeFrom( + from._internal_identifier()); + } + if (cached_has_bits & 0x00000002u) { + _this->_impl_.timestamp_ = from._impl_.timestamp_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + if (from._internal_type() != 0) { + _this->_internal_set_type(from._internal_type()); + } + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void control::CopyFrom(const control& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:messages.control.control) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +PROTOBUF_NOINLINE bool control::IsInitialized() const { + return true; +} + +void control::InternalSwap(control* PROTOBUF_RESTRICT other) { + using std::swap; + auto* arena = GetArena(); + ABSL_DCHECK_EQ(arena, other->GetArena()); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.data_, &other->_impl_.data_, arena); + ::google::protobuf::internal::memswap< + PROTOBUF_FIELD_OFFSET(control, _impl_.type_) + + sizeof(control::_impl_.type_) + - PROTOBUF_FIELD_OFFSET(control, _impl_.identifier_)>( + reinterpret_cast(&_impl_.identifier_), + reinterpret_cast(&other->_impl_.identifier_)); +} + +::google::protobuf::Metadata control::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_Control_2eproto_getter, &descriptor_table_Control_2eproto_once, + file_level_metadata_Control_2eproto[0]); +} +// @@protoc_insertion_point(namespace_scope) +} // namespace control +} // namespace messages +namespace google { +namespace protobuf { +} // namespace protobuf +} // namespace google +// @@protoc_insertion_point(global_scope) +#include "google/protobuf/port_undef.inc" diff --git a/include/SimCore/Messages/Protos/Control.pb.h b/include/SimCore/Messages/Protos/Control.pb.h new file mode 100644 index 0000000..e0edf23 --- /dev/null +++ b/include/SimCore/Messages/Protos/Control.pb.h @@ -0,0 +1,524 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: Control.proto +// Protobuf C++ Version: 4.24.0-main + +#ifndef GOOGLE_PROTOBUF_INCLUDED_Control_2eproto_2epb_2eh +#define GOOGLE_PROTOBUF_INCLUDED_Control_2eproto_2epb_2eh + +#include +#include +#include +#include + +#include "google/protobuf/port_def.inc" +#if PROTOBUF_VERSION < 4025000 +#error "This file was generated by a newer version of protoc which is" +#error "incompatible with your Protocol Buffer headers. Please update" +#error "your headers." +#endif // PROTOBUF_VERSION + +#if 4025000 < PROTOBUF_MIN_PROTOC_VERSION +#error "This file was generated by an older version of protoc which is" +#error "incompatible with your Protocol Buffer headers. Please" +#error "regenerate this file with a newer version of protoc." +#endif // PROTOBUF_MIN_PROTOC_VERSION +#include "google/protobuf/port_undef.inc" +#include "google/protobuf/io/coded_stream.h" +#include "google/protobuf/arena.h" +#include "google/protobuf/arenastring.h" +#include "google/protobuf/generated_message_tctable_decl.h" +#include "google/protobuf/generated_message_util.h" +#include "google/protobuf/metadata_lite.h" +#include "google/protobuf/generated_message_reflection.h" +#include "google/protobuf/message.h" +#include "google/protobuf/repeated_field.h" // IWYU pragma: export +#include "google/protobuf/extension_set.h" // IWYU pragma: export +#include "google/protobuf/unknown_field_set.h" +#include "Identifier.pb.h" +// @@protoc_insertion_point(includes) + +// Must be included last. +#include "google/protobuf/port_def.inc" + +#define PROTOBUF_INTERNAL_EXPORT_Control_2eproto + +namespace google { +namespace protobuf { +namespace internal { +class AnyMetadata; +} // namespace internal +} // namespace protobuf +} // namespace google + +// Internal implementation detail -- do not use these members. +struct TableStruct_Control_2eproto { + static const ::uint32_t offsets[]; +}; +extern const ::google::protobuf::internal::DescriptorTable + descriptor_table_Control_2eproto; +namespace messages { +namespace control { +class control; +struct controlDefaultTypeInternal; +extern controlDefaultTypeInternal _control_default_instance_; +} // namespace control +} // namespace messages +namespace google { +namespace protobuf { +} // namespace protobuf +} // namespace google + +namespace messages { +namespace control { + +// =================================================================== + + +// ------------------------------------------------------------------- + +class control final : + public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:messages.control.control) */ { + public: + inline control() : control(nullptr) {} + ~control() override; + template + explicit PROTOBUF_CONSTEXPR control(::google::protobuf::internal::ConstantInitialized); + + inline control(const control& from) + : control(nullptr, from) {} + control(control&& from) noexcept + : control() { + *this = ::std::move(from); + } + + inline control& operator=(const control& from) { + CopyFrom(from); + return *this; + } + inline control& operator=(control&& from) noexcept { + if (this == &from) return *this; + if (GetArena() == from.GetArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const control& default_instance() { + return *internal_default_instance(); + } + static inline const control* internal_default_instance() { + return reinterpret_cast( + &_control_default_instance_); + } + static constexpr int kIndexInFileMessages = + 0; + + friend void swap(control& a, control& b) { + a.Swap(&b); + } + inline void Swap(control* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetArena() != nullptr && + GetArena() == other->GetArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetArena() == other->GetArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(control* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + control* New(::google::protobuf::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const control& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom( const control& from) { + control::MergeImpl(*this, from); + } + private: + static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg); + public: + ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + ::size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + void SharedDtor(); + void InternalSwap(control* other); + + private: + friend class ::google::protobuf::internal::AnyMetadata; + static ::absl::string_view FullMessageName() { + return "messages.control.control"; + } + protected: + explicit control(::google::protobuf::Arena* arena); + control(::google::protobuf::Arena* arena, const control& from); + const ::google::protobuf::MessageLite::ClassData* GetClassData() const final; + public: + + ::google::protobuf::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kDataFieldNumber = 3, + kIdentifierFieldNumber = 1, + kTimestampFieldNumber = 4, + kTypeFieldNumber = 2, + }; + // string data = 3; + void clear_data() ; + const std::string& data() const; + template + void set_data(Arg_&& arg, Args_... args); + std::string* mutable_data(); + PROTOBUF_NODISCARD std::string* release_data(); + void set_allocated_data(std::string* value); + + private: + const std::string& _internal_data() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_data( + const std::string& value); + std::string* _internal_mutable_data(); + + public: + // .messages.track.Identifier Identifier = 1; + bool has_identifier() const; + void clear_identifier() ; + const ::messages::track::Identifier& identifier() const; + PROTOBUF_NODISCARD ::messages::track::Identifier* release_identifier(); + ::messages::track::Identifier* mutable_identifier(); + void set_allocated_identifier(::messages::track::Identifier* value); + void unsafe_arena_set_allocated_identifier(::messages::track::Identifier* value); + ::messages::track::Identifier* unsafe_arena_release_identifier(); + + private: + const ::messages::track::Identifier& _internal_identifier() const; + ::messages::track::Identifier* _internal_mutable_identifier(); + + public: + // optional uint64 timestamp = 4; + bool has_timestamp() const; + void clear_timestamp() ; + ::uint64_t timestamp() const; + void set_timestamp(::uint64_t value); + + private: + ::uint64_t _internal_timestamp() const; + void _internal_set_timestamp(::uint64_t value); + + public: + // uint32 type = 2; + void clear_type() ; + ::uint32_t type() const; + void set_type(::uint32_t value); + + private: + ::uint32_t _internal_type() const; + void _internal_set_type(::uint32_t value); + + public: + // @@protoc_insertion_point(class_scope:messages.control.control) + private: + class _Internal; + + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 2, 4, 1, + 37, 2> + _table_; + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from); + ::google::protobuf::internal::HasBits<1> _has_bits_; + mutable ::google::protobuf::internal::CachedSize _cached_size_; + ::google::protobuf::internal::ArenaStringPtr data_; + ::messages::track::Identifier* identifier_; + ::uint64_t timestamp_; + ::uint32_t type_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_Control_2eproto; +}; + +// =================================================================== + + + + +// =================================================================== + + +#ifdef __GNUC__ +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wstrict-aliasing" +#endif // __GNUC__ +// ------------------------------------------------------------------- + +// control + +// .messages.track.Identifier Identifier = 1; +inline bool control::has_identifier() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || _impl_.identifier_ != nullptr); + return value; +} +inline const ::messages::track::Identifier& control::_internal_identifier() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + const ::messages::track::Identifier* p = _impl_.identifier_; + return p != nullptr ? *p : reinterpret_cast(::messages::track::_Identifier_default_instance_); +} +inline const ::messages::track::Identifier& control::identifier() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:messages.control.control.Identifier) + return _internal_identifier(); +} +inline void control::unsafe_arena_set_allocated_identifier(::messages::track::Identifier* value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + if (GetArena() == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.identifier_); + } + _impl_.identifier_ = reinterpret_cast<::messages::track::Identifier*>(value); + if (value != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:messages.control.control.Identifier) +} +inline ::messages::track::Identifier* control::release_identifier() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + + _impl_._has_bits_[0] &= ~0x00000001u; + ::messages::track::Identifier* released = _impl_.identifier_; + _impl_.identifier_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + if (GetArena() == nullptr) { + delete old; + } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArena() != nullptr) { + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return released; +} +inline ::messages::track::Identifier* control::unsafe_arena_release_identifier() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + // @@protoc_insertion_point(field_release:messages.control.control.Identifier) + + _impl_._has_bits_[0] &= ~0x00000001u; + ::messages::track::Identifier* temp = _impl_.identifier_; + _impl_.identifier_ = nullptr; + return temp; +} +inline ::messages::track::Identifier* control::_internal_mutable_identifier() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + _impl_._has_bits_[0] |= 0x00000001u; + if (_impl_.identifier_ == nullptr) { + auto* p = CreateMaybeMessage<::messages::track::Identifier>(GetArena()); + _impl_.identifier_ = reinterpret_cast<::messages::track::Identifier*>(p); + } + return _impl_.identifier_; +} +inline ::messages::track::Identifier* control::mutable_identifier() ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::messages::track::Identifier* _msg = _internal_mutable_identifier(); + // @@protoc_insertion_point(field_mutable:messages.control.control.Identifier) + return _msg; +} +inline void control::set_allocated_identifier(::messages::track::Identifier* value) { + ::google::protobuf::Arena* message_arena = GetArena(); + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + if (message_arena == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.identifier_); + } + + if (value != nullptr) { + ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena(); + if (message_arena != submessage_arena) { + value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + + _impl_.identifier_ = reinterpret_cast<::messages::track::Identifier*>(value); + // @@protoc_insertion_point(field_set_allocated:messages.control.control.Identifier) +} + +// uint32 type = 2; +inline void control::clear_type() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + _impl_.type_ = 0u; +} +inline ::uint32_t control::type() const { + // @@protoc_insertion_point(field_get:messages.control.control.type) + return _internal_type(); +} +inline void control::set_type(::uint32_t value) { + _internal_set_type(value); + // @@protoc_insertion_point(field_set:messages.control.control.type) +} +inline ::uint32_t control::_internal_type() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.type_; +} +inline void control::_internal_set_type(::uint32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.type_ = value; +} + +// string data = 3; +inline void control::clear_data() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + _impl_.data_.ClearToEmpty(); +} +inline const std::string& control::data() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:messages.control.control.data) + return _internal_data(); +} +template +inline PROTOBUF_ALWAYS_INLINE void control::set_data(Arg_&& arg, + Args_... args) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.data_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:messages.control.control.data) +} +inline std::string* control::mutable_data() ABSL_ATTRIBUTE_LIFETIME_BOUND { + std::string* _s = _internal_mutable_data(); + // @@protoc_insertion_point(field_mutable:messages.control.control.data) + return _s; +} +inline const std::string& control::_internal_data() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.data_.Get(); +} +inline void control::_internal_set_data(const std::string& value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.data_.Set(value, GetArena()); +} +inline std::string* control::_internal_mutable_data() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + return _impl_.data_.Mutable( GetArena()); +} +inline std::string* control::release_data() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + // @@protoc_insertion_point(field_release:messages.control.control.data) + return _impl_.data_.Release(); +} +inline void control::set_allocated_data(std::string* value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + _impl_.data_.SetAllocated(value, GetArena()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.data_.IsDefault()) { + _impl_.data_.Set("", GetArena()); + } + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:messages.control.control.data) +} + +// optional uint64 timestamp = 4; +inline bool control::has_timestamp() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline void control::clear_timestamp() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + _impl_.timestamp_ = ::uint64_t{0u}; + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline ::uint64_t control::timestamp() const { + // @@protoc_insertion_point(field_get:messages.control.control.timestamp) + return _internal_timestamp(); +} +inline void control::set_timestamp(::uint64_t value) { + _internal_set_timestamp(value); + // @@protoc_insertion_point(field_set:messages.control.control.timestamp) +} +inline ::uint64_t control::_internal_timestamp() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.timestamp_; +} +inline void control::_internal_set_timestamp(::uint64_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.timestamp_ = value; +} + +#ifdef __GNUC__ +#pragma GCC diagnostic pop +#endif // __GNUC__ + +// @@protoc_insertion_point(namespace_scope) +} // namespace control +} // namespace messages + + +// @@protoc_insertion_point(global_scope) + +#include "google/protobuf/port_undef.inc" + +#endif // GOOGLE_PROTOBUF_INCLUDED_Control_2eproto_2epb_2eh diff --git a/include/SimCore/Messages/Protos/GeocentricPosition.pb.cc b/include/SimCore/Messages/Protos/GeocentricPosition.pb.cc new file mode 100644 index 0000000..0bd3db5 --- /dev/null +++ b/include/SimCore/Messages/Protos/GeocentricPosition.pb.cc @@ -0,0 +1,399 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: GeocentricPosition.proto + +#include "GeocentricPosition.pb.h" + +#include +#include "google/protobuf/io/coded_stream.h" +#include "google/protobuf/extension_set.h" +#include "google/protobuf/wire_format_lite.h" +#include "google/protobuf/descriptor.h" +#include "google/protobuf/generated_message_reflection.h" +#include "google/protobuf/reflection_ops.h" +#include "google/protobuf/wire_format.h" +#include "google/protobuf/generated_message_tctable_impl.h" +// @@protoc_insertion_point(includes) + +// Must be included last. +#include "google/protobuf/port_def.inc" +PROTOBUF_PRAGMA_INIT_SEG +namespace _pb = ::google::protobuf; +namespace _pbi = ::google::protobuf::internal; +namespace _fl = ::google::protobuf::internal::field_layout; +namespace messages { +namespace track { + +inline constexpr EntityGeocentricPosition::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : x_{0}, + y_{0}, + z_{0}, + _cached_size_{0} {} + +template +PROTOBUF_CONSTEXPR EntityGeocentricPosition::EntityGeocentricPosition(::_pbi::ConstantInitialized) + : _impl_(::_pbi::ConstantInitialized()) {} +struct EntityGeocentricPositionDefaultTypeInternal { + PROTOBUF_CONSTEXPR EntityGeocentricPositionDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~EntityGeocentricPositionDefaultTypeInternal() {} + union { + EntityGeocentricPosition _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 EntityGeocentricPositionDefaultTypeInternal _EntityGeocentricPosition_default_instance_; +} // namespace track +} // namespace messages +static ::_pb::Metadata file_level_metadata_GeocentricPosition_2eproto[1]; +static constexpr const ::_pb::EnumDescriptor** + file_level_enum_descriptors_GeocentricPosition_2eproto = nullptr; +static constexpr const ::_pb::ServiceDescriptor** + file_level_service_descriptors_GeocentricPosition_2eproto = nullptr; +const ::uint32_t + TableStruct_GeocentricPosition_2eproto::offsets[] ABSL_ATTRIBUTE_SECTION_VARIABLE( + protodesc_cold) = { + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::messages::track::EntityGeocentricPosition, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + ~0u, // no _split_ + ~0u, // no sizeof(Split) + PROTOBUF_FIELD_OFFSET(::messages::track::EntityGeocentricPosition, _impl_.x_), + PROTOBUF_FIELD_OFFSET(::messages::track::EntityGeocentricPosition, _impl_.y_), + PROTOBUF_FIELD_OFFSET(::messages::track::EntityGeocentricPosition, _impl_.z_), +}; + +static const ::_pbi::MigrationSchema + schemas[] ABSL_ATTRIBUTE_SECTION_VARIABLE(protodesc_cold) = { + {0, -1, -1, sizeof(::messages::track::EntityGeocentricPosition)}, +}; + +static const ::_pb::Message* const file_default_instances[] = { + &::messages::track::_EntityGeocentricPosition_default_instance_._instance, +}; +const char descriptor_table_protodef_GeocentricPosition_2eproto[] ABSL_ATTRIBUTE_SECTION_VARIABLE( + protodesc_cold) = { + "\n\030GeocentricPosition.proto\022\016messages.tra" + "ck\";\n\030EntityGeocentricPosition\022\t\n\001X\030\001 \001(" + "\001\022\t\n\001Y\030\002 \001(\001\022\t\n\001Z\030\003 \001(\001b\006proto3" +}; +static ::absl::once_flag descriptor_table_GeocentricPosition_2eproto_once; +const ::_pbi::DescriptorTable descriptor_table_GeocentricPosition_2eproto = { + false, + false, + 111, + descriptor_table_protodef_GeocentricPosition_2eproto, + "GeocentricPosition.proto", + &descriptor_table_GeocentricPosition_2eproto_once, + nullptr, + 0, + 1, + schemas, + file_default_instances, + TableStruct_GeocentricPosition_2eproto::offsets, + file_level_metadata_GeocentricPosition_2eproto, + file_level_enum_descriptors_GeocentricPosition_2eproto, + file_level_service_descriptors_GeocentricPosition_2eproto, +}; + +// This function exists to be marked as weak. +// It can significantly speed up compilation by breaking up LLVM's SCC +// in the .pb.cc translation units. Large translation units see a +// reduction of more than 35% of walltime for optimized builds. Without +// the weak attribute all the messages in the file, including all the +// vtables and everything they use become part of the same SCC through +// a cycle like: +// GetMetadata -> descriptor table -> default instances -> +// vtables -> GetMetadata +// By adding a weak function here we break the connection from the +// individual vtables back into the descriptor table. +PROTOBUF_ATTRIBUTE_WEAK const ::_pbi::DescriptorTable* descriptor_table_GeocentricPosition_2eproto_getter() { + return &descriptor_table_GeocentricPosition_2eproto; +} +// Force running AddDescriptors() at dynamic initialization time. +PROTOBUF_ATTRIBUTE_INIT_PRIORITY2 +static ::_pbi::AddDescriptorsRunner dynamic_init_dummy_GeocentricPosition_2eproto(&descriptor_table_GeocentricPosition_2eproto); +namespace messages { +namespace track { +// =================================================================== + +class EntityGeocentricPosition::_Internal { + public: +}; + +EntityGeocentricPosition::EntityGeocentricPosition(::google::protobuf::Arena* arena) + : ::google::protobuf::Message(arena) { + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:messages.track.EntityGeocentricPosition) +} +EntityGeocentricPosition::EntityGeocentricPosition( + ::google::protobuf::Arena* arena, const EntityGeocentricPosition& from) + : EntityGeocentricPosition(arena) { + MergeFrom(from); +} +inline PROTOBUF_NDEBUG_INLINE EntityGeocentricPosition::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : _cached_size_{0} {} + +inline void EntityGeocentricPosition::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + ::memset(reinterpret_cast(&_impl_) + + offsetof(Impl_, x_), + 0, + offsetof(Impl_, z_) - + offsetof(Impl_, x_) + + sizeof(Impl_::z_)); +} +EntityGeocentricPosition::~EntityGeocentricPosition() { + // @@protoc_insertion_point(destructor:messages.track.EntityGeocentricPosition) + _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + SharedDtor(); +} +inline void EntityGeocentricPosition::SharedDtor() { + ABSL_DCHECK(GetArena() == nullptr); + _impl_.~Impl_(); +} + +const ::google::protobuf::MessageLite::ClassData* +EntityGeocentricPosition::GetClassData() const { + PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite::ClassData + _data_ = { + EntityGeocentricPosition::MergeImpl, + nullptr, // OnDemandRegisterArenaDtor + &::google::protobuf::Message::kDescriptorMethods, + PROTOBUF_FIELD_OFFSET(EntityGeocentricPosition, _impl_._cached_size_), + }; + return &_data_; +} +PROTOBUF_NOINLINE void EntityGeocentricPosition::Clear() { +// @@protoc_insertion_point(message_clear_start:messages.track.EntityGeocentricPosition) + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + ::memset(&_impl_.x_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.z_) - + reinterpret_cast(&_impl_.x_)) + sizeof(_impl_.z_)); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +const char* EntityGeocentricPosition::_InternalParse( + const char* ptr, ::_pbi::ParseContext* ctx) { + ptr = ::_pbi::TcParser::ParseLoop(this, ptr, ctx, &_table_.header); + return ptr; +} + + +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<2, 3, 0, 0, 2> EntityGeocentricPosition::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 3, 24, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967288, // skipmap + offsetof(decltype(_table_), field_entries), + 3, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + &_EntityGeocentricPosition_default_instance_._instance, + ::_pbi::TcParser::GenericFallback, // fallback + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + // double X = 1; + {::_pbi::TcParser::FastF64S1, + {9, 63, 0, PROTOBUF_FIELD_OFFSET(EntityGeocentricPosition, _impl_.x_)}}, + // double Y = 2; + {::_pbi::TcParser::FastF64S1, + {17, 63, 0, PROTOBUF_FIELD_OFFSET(EntityGeocentricPosition, _impl_.y_)}}, + // double Z = 3; + {::_pbi::TcParser::FastF64S1, + {25, 63, 0, PROTOBUF_FIELD_OFFSET(EntityGeocentricPosition, _impl_.z_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // double X = 1; + {PROTOBUF_FIELD_OFFSET(EntityGeocentricPosition, _impl_.x_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kDouble)}, + // double Y = 2; + {PROTOBUF_FIELD_OFFSET(EntityGeocentricPosition, _impl_.y_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kDouble)}, + // double Z = 3; + {PROTOBUF_FIELD_OFFSET(EntityGeocentricPosition, _impl_.z_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kDouble)}, + }}, + // no aux_entries + {{ + }}, +}; + +::uint8_t* EntityGeocentricPosition::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:messages.track.EntityGeocentricPosition) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // double X = 1; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_x = this->_internal_x(); + ::uint64_t raw_x; + memcpy(&raw_x, &tmp_x, sizeof(tmp_x)); + if (raw_x != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 1, this->_internal_x(), target); + } + + // double Y = 2; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_y = this->_internal_y(); + ::uint64_t raw_y; + memcpy(&raw_y, &tmp_y, sizeof(tmp_y)); + if (raw_y != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 2, this->_internal_y(), target); + } + + // double Z = 3; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_z = this->_internal_z(); + ::uint64_t raw_z; + memcpy(&raw_z, &tmp_z, sizeof(tmp_z)); + if (raw_z != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 3, this->_internal_z(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = + ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:messages.track.EntityGeocentricPosition) + return target; +} + +::size_t EntityGeocentricPosition::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:messages.track.EntityGeocentricPosition) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // double X = 1; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_x = this->_internal_x(); + ::uint64_t raw_x; + memcpy(&raw_x, &tmp_x, sizeof(tmp_x)); + if (raw_x != 0) { + total_size += 9; + } + + // double Y = 2; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_y = this->_internal_y(); + ::uint64_t raw_y; + memcpy(&raw_y, &tmp_y, sizeof(tmp_y)); + if (raw_y != 0) { + total_size += 9; + } + + // double Z = 3; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_z = this->_internal_z(); + ::uint64_t raw_z; + memcpy(&raw_z, &tmp_z, sizeof(tmp_z)); + if (raw_z != 0) { + total_size += 9; + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + + +void EntityGeocentricPosition::MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:messages.track.EntityGeocentricPosition) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_x = from._internal_x(); + ::uint64_t raw_x; + memcpy(&raw_x, &tmp_x, sizeof(tmp_x)); + if (raw_x != 0) { + _this->_internal_set_x(from._internal_x()); + } + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_y = from._internal_y(); + ::uint64_t raw_y; + memcpy(&raw_y, &tmp_y, sizeof(tmp_y)); + if (raw_y != 0) { + _this->_internal_set_y(from._internal_y()); + } + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_z = from._internal_z(); + ::uint64_t raw_z; + memcpy(&raw_z, &tmp_z, sizeof(tmp_z)); + if (raw_z != 0) { + _this->_internal_set_z(from._internal_z()); + } + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void EntityGeocentricPosition::CopyFrom(const EntityGeocentricPosition& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:messages.track.EntityGeocentricPosition) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +PROTOBUF_NOINLINE bool EntityGeocentricPosition::IsInitialized() const { + return true; +} + +void EntityGeocentricPosition::InternalSwap(EntityGeocentricPosition* PROTOBUF_RESTRICT other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::google::protobuf::internal::memswap< + PROTOBUF_FIELD_OFFSET(EntityGeocentricPosition, _impl_.z_) + + sizeof(EntityGeocentricPosition::_impl_.z_) + - PROTOBUF_FIELD_OFFSET(EntityGeocentricPosition, _impl_.x_)>( + reinterpret_cast(&_impl_.x_), + reinterpret_cast(&other->_impl_.x_)); +} + +::google::protobuf::Metadata EntityGeocentricPosition::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_GeocentricPosition_2eproto_getter, &descriptor_table_GeocentricPosition_2eproto_once, + file_level_metadata_GeocentricPosition_2eproto[0]); +} +// @@protoc_insertion_point(namespace_scope) +} // namespace track +} // namespace messages +namespace google { +namespace protobuf { +} // namespace protobuf +} // namespace google +// @@protoc_insertion_point(global_scope) +#include "google/protobuf/port_undef.inc" diff --git a/include/SimCore/Messages/Protos/GeocentricPosition.pb.h b/include/SimCore/Messages/Protos/GeocentricPosition.pb.h new file mode 100644 index 0000000..6227968 --- /dev/null +++ b/include/SimCore/Messages/Protos/GeocentricPosition.pb.h @@ -0,0 +1,372 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: GeocentricPosition.proto +// Protobuf C++ Version: 4.24.0-main + +#ifndef GOOGLE_PROTOBUF_INCLUDED_GeocentricPosition_2eproto_2epb_2eh +#define GOOGLE_PROTOBUF_INCLUDED_GeocentricPosition_2eproto_2epb_2eh + +#include +#include +#include +#include + +#include "google/protobuf/port_def.inc" +#if PROTOBUF_VERSION < 4025000 +#error "This file was generated by a newer version of protoc which is" +#error "incompatible with your Protocol Buffer headers. Please update" +#error "your headers." +#endif // PROTOBUF_VERSION + +#if 4025000 < PROTOBUF_MIN_PROTOC_VERSION +#error "This file was generated by an older version of protoc which is" +#error "incompatible with your Protocol Buffer headers. Please" +#error "regenerate this file with a newer version of protoc." +#endif // PROTOBUF_MIN_PROTOC_VERSION +#include "google/protobuf/port_undef.inc" +#include "google/protobuf/io/coded_stream.h" +#include "google/protobuf/arena.h" +#include "google/protobuf/arenastring.h" +#include "google/protobuf/generated_message_tctable_decl.h" +#include "google/protobuf/generated_message_util.h" +#include "google/protobuf/metadata_lite.h" +#include "google/protobuf/generated_message_reflection.h" +#include "google/protobuf/message.h" +#include "google/protobuf/repeated_field.h" // IWYU pragma: export +#include "google/protobuf/extension_set.h" // IWYU pragma: export +#include "google/protobuf/unknown_field_set.h" +// @@protoc_insertion_point(includes) + +// Must be included last. +#include "google/protobuf/port_def.inc" + +#define PROTOBUF_INTERNAL_EXPORT_GeocentricPosition_2eproto + +namespace google { +namespace protobuf { +namespace internal { +class AnyMetadata; +} // namespace internal +} // namespace protobuf +} // namespace google + +// Internal implementation detail -- do not use these members. +struct TableStruct_GeocentricPosition_2eproto { + static const ::uint32_t offsets[]; +}; +extern const ::google::protobuf::internal::DescriptorTable + descriptor_table_GeocentricPosition_2eproto; +namespace messages { +namespace track { +class EntityGeocentricPosition; +struct EntityGeocentricPositionDefaultTypeInternal; +extern EntityGeocentricPositionDefaultTypeInternal _EntityGeocentricPosition_default_instance_; +} // namespace track +} // namespace messages +namespace google { +namespace protobuf { +} // namespace protobuf +} // namespace google + +namespace messages { +namespace track { + +// =================================================================== + + +// ------------------------------------------------------------------- + +class EntityGeocentricPosition final : + public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:messages.track.EntityGeocentricPosition) */ { + public: + inline EntityGeocentricPosition() : EntityGeocentricPosition(nullptr) {} + ~EntityGeocentricPosition() override; + template + explicit PROTOBUF_CONSTEXPR EntityGeocentricPosition(::google::protobuf::internal::ConstantInitialized); + + inline EntityGeocentricPosition(const EntityGeocentricPosition& from) + : EntityGeocentricPosition(nullptr, from) {} + EntityGeocentricPosition(EntityGeocentricPosition&& from) noexcept + : EntityGeocentricPosition() { + *this = ::std::move(from); + } + + inline EntityGeocentricPosition& operator=(const EntityGeocentricPosition& from) { + CopyFrom(from); + return *this; + } + inline EntityGeocentricPosition& operator=(EntityGeocentricPosition&& from) noexcept { + if (this == &from) return *this; + if (GetArena() == from.GetArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const EntityGeocentricPosition& default_instance() { + return *internal_default_instance(); + } + static inline const EntityGeocentricPosition* internal_default_instance() { + return reinterpret_cast( + &_EntityGeocentricPosition_default_instance_); + } + static constexpr int kIndexInFileMessages = + 0; + + friend void swap(EntityGeocentricPosition& a, EntityGeocentricPosition& b) { + a.Swap(&b); + } + inline void Swap(EntityGeocentricPosition* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetArena() != nullptr && + GetArena() == other->GetArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetArena() == other->GetArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(EntityGeocentricPosition* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + EntityGeocentricPosition* New(::google::protobuf::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const EntityGeocentricPosition& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom( const EntityGeocentricPosition& from) { + EntityGeocentricPosition::MergeImpl(*this, from); + } + private: + static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg); + public: + ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + ::size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + void SharedDtor(); + void InternalSwap(EntityGeocentricPosition* other); + + private: + friend class ::google::protobuf::internal::AnyMetadata; + static ::absl::string_view FullMessageName() { + return "messages.track.EntityGeocentricPosition"; + } + protected: + explicit EntityGeocentricPosition(::google::protobuf::Arena* arena); + EntityGeocentricPosition(::google::protobuf::Arena* arena, const EntityGeocentricPosition& from); + const ::google::protobuf::MessageLite::ClassData* GetClassData() const final; + public: + + ::google::protobuf::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kXFieldNumber = 1, + kYFieldNumber = 2, + kZFieldNumber = 3, + }; + // double X = 1; + void clear_x() ; + double x() const; + void set_x(double value); + + private: + double _internal_x() const; + void _internal_set_x(double value); + + public: + // double Y = 2; + void clear_y() ; + double y() const; + void set_y(double value); + + private: + double _internal_y() const; + void _internal_set_y(double value); + + public: + // double Z = 3; + void clear_z() ; + double z() const; + void set_z(double value); + + private: + double _internal_z() const; + void _internal_set_z(double value); + + public: + // @@protoc_insertion_point(class_scope:messages.track.EntityGeocentricPosition) + private: + class _Internal; + + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 2, 3, 0, + 0, 2> + _table_; + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from); + double x_; + double y_; + double z_; + mutable ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_GeocentricPosition_2eproto; +}; + +// =================================================================== + + + + +// =================================================================== + + +#ifdef __GNUC__ +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wstrict-aliasing" +#endif // __GNUC__ +// ------------------------------------------------------------------- + +// EntityGeocentricPosition + +// double X = 1; +inline void EntityGeocentricPosition::clear_x() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + _impl_.x_ = 0; +} +inline double EntityGeocentricPosition::x() const { + // @@protoc_insertion_point(field_get:messages.track.EntityGeocentricPosition.X) + return _internal_x(); +} +inline void EntityGeocentricPosition::set_x(double value) { + _internal_set_x(value); + // @@protoc_insertion_point(field_set:messages.track.EntityGeocentricPosition.X) +} +inline double EntityGeocentricPosition::_internal_x() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.x_; +} +inline void EntityGeocentricPosition::_internal_set_x(double value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.x_ = value; +} + +// double Y = 2; +inline void EntityGeocentricPosition::clear_y() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + _impl_.y_ = 0; +} +inline double EntityGeocentricPosition::y() const { + // @@protoc_insertion_point(field_get:messages.track.EntityGeocentricPosition.Y) + return _internal_y(); +} +inline void EntityGeocentricPosition::set_y(double value) { + _internal_set_y(value); + // @@protoc_insertion_point(field_set:messages.track.EntityGeocentricPosition.Y) +} +inline double EntityGeocentricPosition::_internal_y() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.y_; +} +inline void EntityGeocentricPosition::_internal_set_y(double value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.y_ = value; +} + +// double Z = 3; +inline void EntityGeocentricPosition::clear_z() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + _impl_.z_ = 0; +} +inline double EntityGeocentricPosition::z() const { + // @@protoc_insertion_point(field_get:messages.track.EntityGeocentricPosition.Z) + return _internal_z(); +} +inline void EntityGeocentricPosition::set_z(double value) { + _internal_set_z(value); + // @@protoc_insertion_point(field_set:messages.track.EntityGeocentricPosition.Z) +} +inline double EntityGeocentricPosition::_internal_z() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.z_; +} +inline void EntityGeocentricPosition::_internal_set_z(double value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.z_ = value; +} + +#ifdef __GNUC__ +#pragma GCC diagnostic pop +#endif // __GNUC__ + +// @@protoc_insertion_point(namespace_scope) +} // namespace track +} // namespace messages + + +// @@protoc_insertion_point(global_scope) + +#include "google/protobuf/port_undef.inc" + +#endif // GOOGLE_PROTOBUF_INCLUDED_GeocentricPosition_2eproto_2epb_2eh diff --git a/include/SimCore/Messages/Protos/Identifier.pb.cc b/include/SimCore/Messages/Protos/Identifier.pb.cc new file mode 100644 index 0000000..3c4f111 --- /dev/null +++ b/include/SimCore/Messages/Protos/Identifier.pb.cc @@ -0,0 +1,345 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: Identifier.proto + +#include "Identifier.pb.h" + +#include +#include "google/protobuf/io/coded_stream.h" +#include "google/protobuf/extension_set.h" +#include "google/protobuf/wire_format_lite.h" +#include "google/protobuf/descriptor.h" +#include "google/protobuf/generated_message_reflection.h" +#include "google/protobuf/reflection_ops.h" +#include "google/protobuf/wire_format.h" +#include "google/protobuf/generated_message_tctable_impl.h" +// @@protoc_insertion_point(includes) + +// Must be included last. +#include "google/protobuf/port_def.inc" +PROTOBUF_PRAGMA_INIT_SEG +namespace _pb = ::google::protobuf; +namespace _pbi = ::google::protobuf::internal; +namespace _fl = ::google::protobuf::internal::field_layout; +namespace messages { +namespace track { + +inline constexpr Identifier::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : uuid_( + &::google::protobuf::internal::fixed_address_empty_string, + ::_pbi::ConstantInitialized()), + external_{false}, + _cached_size_{0} {} + +template +PROTOBUF_CONSTEXPR Identifier::Identifier(::_pbi::ConstantInitialized) + : _impl_(::_pbi::ConstantInitialized()) {} +struct IdentifierDefaultTypeInternal { + PROTOBUF_CONSTEXPR IdentifierDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~IdentifierDefaultTypeInternal() {} + union { + Identifier _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 IdentifierDefaultTypeInternal _Identifier_default_instance_; +} // namespace track +} // namespace messages +static ::_pb::Metadata file_level_metadata_Identifier_2eproto[1]; +static constexpr const ::_pb::EnumDescriptor** + file_level_enum_descriptors_Identifier_2eproto = nullptr; +static constexpr const ::_pb::ServiceDescriptor** + file_level_service_descriptors_Identifier_2eproto = nullptr; +const ::uint32_t + TableStruct_Identifier_2eproto::offsets[] ABSL_ATTRIBUTE_SECTION_VARIABLE( + protodesc_cold) = { + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::messages::track::Identifier, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + ~0u, // no _split_ + ~0u, // no sizeof(Split) + PROTOBUF_FIELD_OFFSET(::messages::track::Identifier, _impl_.external_), + PROTOBUF_FIELD_OFFSET(::messages::track::Identifier, _impl_.uuid_), +}; + +static const ::_pbi::MigrationSchema + schemas[] ABSL_ATTRIBUTE_SECTION_VARIABLE(protodesc_cold) = { + {0, -1, -1, sizeof(::messages::track::Identifier)}, +}; + +static const ::_pb::Message* const file_default_instances[] = { + &::messages::track::_Identifier_default_instance_._instance, +}; +const char descriptor_table_protodef_Identifier_2eproto[] ABSL_ATTRIBUTE_SECTION_VARIABLE( + protodesc_cold) = { + "\n\020Identifier.proto\022\016messages.track\",\n\nId" + "entifier\022\020\n\010external\030\001 \001(\010\022\014\n\004uuid\030\002 \001(\t" + "b\006proto3" +}; +static ::absl::once_flag descriptor_table_Identifier_2eproto_once; +const ::_pbi::DescriptorTable descriptor_table_Identifier_2eproto = { + false, + false, + 88, + descriptor_table_protodef_Identifier_2eproto, + "Identifier.proto", + &descriptor_table_Identifier_2eproto_once, + nullptr, + 0, + 1, + schemas, + file_default_instances, + TableStruct_Identifier_2eproto::offsets, + file_level_metadata_Identifier_2eproto, + file_level_enum_descriptors_Identifier_2eproto, + file_level_service_descriptors_Identifier_2eproto, +}; + +// This function exists to be marked as weak. +// It can significantly speed up compilation by breaking up LLVM's SCC +// in the .pb.cc translation units. Large translation units see a +// reduction of more than 35% of walltime for optimized builds. Without +// the weak attribute all the messages in the file, including all the +// vtables and everything they use become part of the same SCC through +// a cycle like: +// GetMetadata -> descriptor table -> default instances -> +// vtables -> GetMetadata +// By adding a weak function here we break the connection from the +// individual vtables back into the descriptor table. +PROTOBUF_ATTRIBUTE_WEAK const ::_pbi::DescriptorTable* descriptor_table_Identifier_2eproto_getter() { + return &descriptor_table_Identifier_2eproto; +} +// Force running AddDescriptors() at dynamic initialization time. +PROTOBUF_ATTRIBUTE_INIT_PRIORITY2 +static ::_pbi::AddDescriptorsRunner dynamic_init_dummy_Identifier_2eproto(&descriptor_table_Identifier_2eproto); +namespace messages { +namespace track { +// =================================================================== + +class Identifier::_Internal { + public: +}; + +Identifier::Identifier(::google::protobuf::Arena* arena) + : ::google::protobuf::Message(arena) { + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:messages.track.Identifier) +} +inline PROTOBUF_NDEBUG_INLINE Identifier::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, + const Impl_& from) + : uuid_(arena, from.uuid_), + _cached_size_{0} {} + +Identifier::Identifier( + ::google::protobuf::Arena* arena, + const Identifier& from) + : ::google::protobuf::Message(arena) { + Identifier* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_); + _impl_.external_ = from._impl_.external_; + + // @@protoc_insertion_point(copy_constructor:messages.track.Identifier) +} +inline PROTOBUF_NDEBUG_INLINE Identifier::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : uuid_(arena), + _cached_size_{0} {} + +inline void Identifier::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + _impl_.external_ = {}; +} +Identifier::~Identifier() { + // @@protoc_insertion_point(destructor:messages.track.Identifier) + _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + SharedDtor(); +} +inline void Identifier::SharedDtor() { + ABSL_DCHECK(GetArena() == nullptr); + _impl_.uuid_.Destroy(); + _impl_.~Impl_(); +} + +const ::google::protobuf::MessageLite::ClassData* +Identifier::GetClassData() const { + PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite::ClassData + _data_ = { + Identifier::MergeImpl, + nullptr, // OnDemandRegisterArenaDtor + &::google::protobuf::Message::kDescriptorMethods, + PROTOBUF_FIELD_OFFSET(Identifier, _impl_._cached_size_), + }; + return &_data_; +} +PROTOBUF_NOINLINE void Identifier::Clear() { +// @@protoc_insertion_point(message_clear_start:messages.track.Identifier) + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.uuid_.ClearToEmpty(); + _impl_.external_ = false; + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +const char* Identifier::_InternalParse( + const char* ptr, ::_pbi::ParseContext* ctx) { + ptr = ::_pbi::TcParser::ParseLoop(this, ptr, ctx, &_table_.header); + return ptr; +} + + +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<1, 2, 0, 38, 2> Identifier::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 2, 8, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967292, // skipmap + offsetof(decltype(_table_), field_entries), + 2, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + &_Identifier_default_instance_._instance, + ::_pbi::TcParser::GenericFallback, // fallback + }, {{ + // string uuid = 2; + {::_pbi::TcParser::FastUS1, + {18, 63, 0, PROTOBUF_FIELD_OFFSET(Identifier, _impl_.uuid_)}}, + // bool external = 1; + {::_pbi::TcParser::SingularVarintNoZag1(), + {8, 63, 0, PROTOBUF_FIELD_OFFSET(Identifier, _impl_.external_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // bool external = 1; + {PROTOBUF_FIELD_OFFSET(Identifier, _impl_.external_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kBool)}, + // string uuid = 2; + {PROTOBUF_FIELD_OFFSET(Identifier, _impl_.uuid_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, + }}, + // no aux_entries + {{ + "\31\0\4\0\0\0\0\0" + "messages.track.Identifier" + "uuid" + }}, +}; + +::uint8_t* Identifier::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:messages.track.Identifier) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // bool external = 1; + if (this->_internal_external() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray( + 1, this->_internal_external(), target); + } + + // string uuid = 2; + if (!this->_internal_uuid().empty()) { + const std::string& _s = this->_internal_uuid(); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "messages.track.Identifier.uuid"); + target = stream->WriteStringMaybeAliased(2, _s, target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = + ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:messages.track.Identifier) + return target; +} + +::size_t Identifier::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:messages.track.Identifier) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // string uuid = 2; + if (!this->_internal_uuid().empty()) { + total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( + this->_internal_uuid()); + } + + // bool external = 1; + if (this->_internal_external() != 0) { + total_size += 2; + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + + +void Identifier::MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:messages.track.Identifier) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (!from._internal_uuid().empty()) { + _this->_internal_set_uuid(from._internal_uuid()); + } + if (from._internal_external() != 0) { + _this->_internal_set_external(from._internal_external()); + } + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void Identifier::CopyFrom(const Identifier& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:messages.track.Identifier) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +PROTOBUF_NOINLINE bool Identifier::IsInitialized() const { + return true; +} + +void Identifier::InternalSwap(Identifier* PROTOBUF_RESTRICT other) { + using std::swap; + auto* arena = GetArena(); + ABSL_DCHECK_EQ(arena, other->GetArena()); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.uuid_, &other->_impl_.uuid_, arena); + swap(_impl_.external_, other->_impl_.external_); +} + +::google::protobuf::Metadata Identifier::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_Identifier_2eproto_getter, &descriptor_table_Identifier_2eproto_once, + file_level_metadata_Identifier_2eproto[0]); +} +// @@protoc_insertion_point(namespace_scope) +} // namespace track +} // namespace messages +namespace google { +namespace protobuf { +} // namespace protobuf +} // namespace google +// @@protoc_insertion_point(global_scope) +#include "google/protobuf/port_undef.inc" diff --git a/include/SimCore/Messages/Protos/Identifier.pb.h b/include/SimCore/Messages/Protos/Identifier.pb.h new file mode 100644 index 0000000..0702eb0 --- /dev/null +++ b/include/SimCore/Messages/Protos/Identifier.pb.h @@ -0,0 +1,373 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: Identifier.proto +// Protobuf C++ Version: 4.24.0-main + +#ifndef GOOGLE_PROTOBUF_INCLUDED_Identifier_2eproto_2epb_2eh +#define GOOGLE_PROTOBUF_INCLUDED_Identifier_2eproto_2epb_2eh + +#include +#include +#include +#include + +#include "google/protobuf/port_def.inc" +#if PROTOBUF_VERSION < 4025000 +#error "This file was generated by a newer version of protoc which is" +#error "incompatible with your Protocol Buffer headers. Please update" +#error "your headers." +#endif // PROTOBUF_VERSION + +#if 4025000 < PROTOBUF_MIN_PROTOC_VERSION +#error "This file was generated by an older version of protoc which is" +#error "incompatible with your Protocol Buffer headers. Please" +#error "regenerate this file with a newer version of protoc." +#endif // PROTOBUF_MIN_PROTOC_VERSION +#include "google/protobuf/port_undef.inc" +#include "google/protobuf/io/coded_stream.h" +#include "google/protobuf/arena.h" +#include "google/protobuf/arenastring.h" +#include "google/protobuf/generated_message_tctable_decl.h" +#include "google/protobuf/generated_message_util.h" +#include "google/protobuf/metadata_lite.h" +#include "google/protobuf/generated_message_reflection.h" +#include "google/protobuf/message.h" +#include "google/protobuf/repeated_field.h" // IWYU pragma: export +#include "google/protobuf/extension_set.h" // IWYU pragma: export +#include "google/protobuf/unknown_field_set.h" +// @@protoc_insertion_point(includes) + +// Must be included last. +#include "google/protobuf/port_def.inc" + +#define PROTOBUF_INTERNAL_EXPORT_Identifier_2eproto + +namespace google { +namespace protobuf { +namespace internal { +class AnyMetadata; +} // namespace internal +} // namespace protobuf +} // namespace google + +// Internal implementation detail -- do not use these members. +struct TableStruct_Identifier_2eproto { + static const ::uint32_t offsets[]; +}; +extern const ::google::protobuf::internal::DescriptorTable + descriptor_table_Identifier_2eproto; +namespace messages { +namespace track { +class Identifier; +struct IdentifierDefaultTypeInternal; +extern IdentifierDefaultTypeInternal _Identifier_default_instance_; +} // namespace track +} // namespace messages +namespace google { +namespace protobuf { +} // namespace protobuf +} // namespace google + +namespace messages { +namespace track { + +// =================================================================== + + +// ------------------------------------------------------------------- + +class Identifier final : + public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:messages.track.Identifier) */ { + public: + inline Identifier() : Identifier(nullptr) {} + ~Identifier() override; + template + explicit PROTOBUF_CONSTEXPR Identifier(::google::protobuf::internal::ConstantInitialized); + + inline Identifier(const Identifier& from) + : Identifier(nullptr, from) {} + Identifier(Identifier&& from) noexcept + : Identifier() { + *this = ::std::move(from); + } + + inline Identifier& operator=(const Identifier& from) { + CopyFrom(from); + return *this; + } + inline Identifier& operator=(Identifier&& from) noexcept { + if (this == &from) return *this; + if (GetArena() == from.GetArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const Identifier& default_instance() { + return *internal_default_instance(); + } + static inline const Identifier* internal_default_instance() { + return reinterpret_cast( + &_Identifier_default_instance_); + } + static constexpr int kIndexInFileMessages = + 0; + + friend void swap(Identifier& a, Identifier& b) { + a.Swap(&b); + } + inline void Swap(Identifier* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetArena() != nullptr && + GetArena() == other->GetArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetArena() == other->GetArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Identifier* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Identifier* New(::google::protobuf::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const Identifier& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom( const Identifier& from) { + Identifier::MergeImpl(*this, from); + } + private: + static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg); + public: + ABSL_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + ::size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + void SharedDtor(); + void InternalSwap(Identifier* other); + + private: + friend class ::google::protobuf::internal::AnyMetadata; + static ::absl::string_view FullMessageName() { + return "messages.track.Identifier"; + } + protected: + explicit Identifier(::google::protobuf::Arena* arena); + Identifier(::google::protobuf::Arena* arena, const Identifier& from); + const ::google::protobuf::MessageLite::ClassData* GetClassData() const final; + public: + + ::google::protobuf::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kUuidFieldNumber = 2, + kExternalFieldNumber = 1, + }; + // string uuid = 2; + void clear_uuid() ; + const std::string& uuid() const; + template + void set_uuid(Arg_&& arg, Args_... args); + std::string* mutable_uuid(); + PROTOBUF_NODISCARD std::string* release_uuid(); + void set_allocated_uuid(std::string* value); + + private: + const std::string& _internal_uuid() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_uuid( + const std::string& value); + std::string* _internal_mutable_uuid(); + + public: + // bool external = 1; + void clear_external() ; + bool external() const; + void set_external(bool value); + + private: + bool _internal_external() const; + void _internal_set_external(bool value); + + public: + // @@protoc_insertion_point(class_scope:messages.track.Identifier) + private: + class _Internal; + + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 1, 2, 0, + 38, 2> + _table_; + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from); + ::google::protobuf::internal::ArenaStringPtr uuid_; + bool external_; + mutable ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_Identifier_2eproto; +}; + +// =================================================================== + + + + +// =================================================================== + + +#ifdef __GNUC__ +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wstrict-aliasing" +#endif // __GNUC__ +// ------------------------------------------------------------------- + +// Identifier + +// bool external = 1; +inline void Identifier::clear_external() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + _impl_.external_ = false; +} +inline bool Identifier::external() const { + // @@protoc_insertion_point(field_get:messages.track.Identifier.external) + return _internal_external(); +} +inline void Identifier::set_external(bool value) { + _internal_set_external(value); + // @@protoc_insertion_point(field_set:messages.track.Identifier.external) +} +inline bool Identifier::_internal_external() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.external_; +} +inline void Identifier::_internal_set_external(bool value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.external_ = value; +} + +// string uuid = 2; +inline void Identifier::clear_uuid() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + _impl_.uuid_.ClearToEmpty(); +} +inline const std::string& Identifier::uuid() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:messages.track.Identifier.uuid) + return _internal_uuid(); +} +template +inline PROTOBUF_ALWAYS_INLINE void Identifier::set_uuid(Arg_&& arg, + Args_... args) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.uuid_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:messages.track.Identifier.uuid) +} +inline std::string* Identifier::mutable_uuid() ABSL_ATTRIBUTE_LIFETIME_BOUND { + std::string* _s = _internal_mutable_uuid(); + // @@protoc_insertion_point(field_mutable:messages.track.Identifier.uuid) + return _s; +} +inline const std::string& Identifier::_internal_uuid() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.uuid_.Get(); +} +inline void Identifier::_internal_set_uuid(const std::string& value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.uuid_.Set(value, GetArena()); +} +inline std::string* Identifier::_internal_mutable_uuid() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + return _impl_.uuid_.Mutable( GetArena()); +} +inline std::string* Identifier::release_uuid() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + // @@protoc_insertion_point(field_release:messages.track.Identifier.uuid) + return _impl_.uuid_.Release(); +} +inline void Identifier::set_allocated_uuid(std::string* value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + _impl_.uuid_.SetAllocated(value, GetArena()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.uuid_.IsDefault()) { + _impl_.uuid_.Set("", GetArena()); + } + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:messages.track.Identifier.uuid) +} + +#ifdef __GNUC__ +#pragma GCC diagnostic pop +#endif // __GNUC__ + +// @@protoc_insertion_point(namespace_scope) +} // namespace track +} // namespace messages + + +// @@protoc_insertion_point(global_scope) + +#include "google/protobuf/port_undef.inc" + +#endif // GOOGLE_PROTOBUF_INCLUDED_Identifier_2eproto_2epb_2eh