From 7bb7c4bb8ef62c910a4bf2a189f2ae3b4cf444cd Mon Sep 17 00:00:00 2001 From: Henry Winkel Date: Tue, 7 Nov 2023 15:45:58 +0100 Subject: [PATCH] ADD: added generated protofiles --- .../SimCore/Messages/Protos/SimTrack.pb.cc | 1279 +++++++++++++ include/SimCore/Messages/Protos/SimTrack.pb.h | 1578 +++++++++++++++++ 2 files changed, 2857 insertions(+) create mode 100644 include/SimCore/Messages/Protos/SimTrack.pb.cc create mode 100644 include/SimCore/Messages/Protos/SimTrack.pb.h diff --git a/include/SimCore/Messages/Protos/SimTrack.pb.cc b/include/SimCore/Messages/Protos/SimTrack.pb.cc new file mode 100644 index 0000000..11153fd --- /dev/null +++ b/include/SimCore/Messages/Protos/SimTrack.pb.cc @@ -0,0 +1,1279 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: SimTrack.proto + +#include "SimTrack.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 SimTrack { + +inline constexpr Emission::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : _cached_size_{0}, + name_( + &::google::protobuf::internal::fixed_address_empty_string, + ::_pbi::ConstantInitialized()), + identifier_{nullptr}, + frequency_{0}, + range_{0}, + bandwidth_{0u}, + pulsewidth_{0u}, + pulserepitition_{0u}, + radiatedpower_{0u}, + numberofbeams_{0u}, + searchinterval_{0u} {} + +template +PROTOBUF_CONSTEXPR Emission::Emission(::_pbi::ConstantInitialized) + : _impl_(::_pbi::ConstantInitialized()) {} +struct EmissionDefaultTypeInternal { + PROTOBUF_CONSTEXPR EmissionDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~EmissionDefaultTypeInternal() {} + union { + Emission _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 EmissionDefaultTypeInternal _Emission_default_instance_; + +inline constexpr SimTrack::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : _cached_size_{0}, + contactemissions_{}, + conatactname_( + &::google::protobuf::internal::fixed_address_empty_string, + ::_pbi::ConstantInitialized()), + entityidentifier_{nullptr}, + geocentricposition_{nullptr}, + contactspeed_{0}, + contactsourcetype_{0u}, + contactkind_{0u}, + contactcourse_{0}, + conactpitch_{0}, + contactrcs_{0}, + contactside_{0u} {} + +template +PROTOBUF_CONSTEXPR SimTrack::SimTrack(::_pbi::ConstantInitialized) + : _impl_(::_pbi::ConstantInitialized()) {} +struct SimTrackDefaultTypeInternal { + PROTOBUF_CONSTEXPR SimTrackDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~SimTrackDefaultTypeInternal() {} + union { + SimTrack _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SimTrackDefaultTypeInternal _SimTrack_default_instance_; +} // namespace SimTrack +} // namespace messages +static ::_pb::Metadata file_level_metadata_SimTrack_2eproto[2]; +static constexpr const ::_pb::EnumDescriptor** + file_level_enum_descriptors_SimTrack_2eproto = nullptr; +static constexpr const ::_pb::ServiceDescriptor** + file_level_service_descriptors_SimTrack_2eproto = nullptr; +const ::uint32_t + TableStruct_SimTrack_2eproto::offsets[] ABSL_ATTRIBUTE_SECTION_VARIABLE( + protodesc_cold) = { + PROTOBUF_FIELD_OFFSET(::messages::SimTrack::SimTrack, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::messages::SimTrack::SimTrack, _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::SimTrack::SimTrack, _impl_.entityidentifier_), + PROTOBUF_FIELD_OFFSET(::messages::SimTrack::SimTrack, _impl_.conatactname_), + PROTOBUF_FIELD_OFFSET(::messages::SimTrack::SimTrack, _impl_.contactsourcetype_), + PROTOBUF_FIELD_OFFSET(::messages::SimTrack::SimTrack, _impl_.geocentricposition_), + PROTOBUF_FIELD_OFFSET(::messages::SimTrack::SimTrack, _impl_.contactspeed_), + PROTOBUF_FIELD_OFFSET(::messages::SimTrack::SimTrack, _impl_.contactcourse_), + PROTOBUF_FIELD_OFFSET(::messages::SimTrack::SimTrack, _impl_.conactpitch_), + PROTOBUF_FIELD_OFFSET(::messages::SimTrack::SimTrack, _impl_.contactkind_), + PROTOBUF_FIELD_OFFSET(::messages::SimTrack::SimTrack, _impl_.contactside_), + PROTOBUF_FIELD_OFFSET(::messages::SimTrack::SimTrack, _impl_.contactrcs_), + PROTOBUF_FIELD_OFFSET(::messages::SimTrack::SimTrack, _impl_.contactemissions_), + 0, + ~0u, + 3, + 1, + 2, + 5, + 6, + 4, + 8, + 7, + ~0u, + PROTOBUF_FIELD_OFFSET(::messages::SimTrack::Emission, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::messages::SimTrack::Emission, _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::SimTrack::Emission, _impl_.identifier_), + PROTOBUF_FIELD_OFFSET(::messages::SimTrack::Emission, _impl_.name_), + PROTOBUF_FIELD_OFFSET(::messages::SimTrack::Emission, _impl_.frequency_), + PROTOBUF_FIELD_OFFSET(::messages::SimTrack::Emission, _impl_.range_), + PROTOBUF_FIELD_OFFSET(::messages::SimTrack::Emission, _impl_.bandwidth_), + PROTOBUF_FIELD_OFFSET(::messages::SimTrack::Emission, _impl_.pulsewidth_), + PROTOBUF_FIELD_OFFSET(::messages::SimTrack::Emission, _impl_.pulserepitition_), + PROTOBUF_FIELD_OFFSET(::messages::SimTrack::Emission, _impl_.radiatedpower_), + PROTOBUF_FIELD_OFFSET(::messages::SimTrack::Emission, _impl_.numberofbeams_), + PROTOBUF_FIELD_OFFSET(::messages::SimTrack::Emission, _impl_.searchinterval_), + 0, + ~0u, + ~0u, + ~0u, + 1, + 2, + 3, + 4, + 5, + 6, +}; + +static const ::_pbi::MigrationSchema + schemas[] ABSL_ATTRIBUTE_SECTION_VARIABLE(protodesc_cold) = { + {0, 19, -1, sizeof(::messages::SimTrack::SimTrack)}, + {30, 48, -1, sizeof(::messages::SimTrack::Emission)}, +}; + +static const ::_pb::Message* const file_default_instances[] = { + &::messages::SimTrack::_SimTrack_default_instance_._instance, + &::messages::SimTrack::_Emission_default_instance_._instance, +}; +const char descriptor_table_protodef_SimTrack_2eproto[] ABSL_ATTRIBUTE_SECTION_VARIABLE( + protodesc_cold) = { + "\n\016SimTrack.proto\022\021messages.SimTrack\032\037goo" + "gle/protobuf/timestamp.proto\032\036google/pro" + "tobuf/duration.proto\032\020Identifier.proto\032\030" + "GeocentricPosition.proto\"\245\004\n\010SimTrack\0224\n" + "\020EntityIdentifier\030\001 \001(\0132\032.messages.track" + ".Identifier\022\024\n\014ConatactName\030\002 \001(\t\022\036\n\021Con" + "tactSourceType\030\003 \001(\rH\000\210\001\001\022I\n\022GeocentricP" + "osition\030\004 \001(\0132(.messages.track.EntityGeo" + "centricPositionH\001\210\001\001\022\031\n\014ContactSpeed\030\005 \001" + "(\001H\002\210\001\001\022\032\n\rContactCourse\030\006 \001(\001H\003\210\001\001\022\030\n\013C" + "onactPitch\030\007 \001(\001H\004\210\001\001\022\030\n\013ContactKind\030\010 \001" + "(\rH\005\210\001\001\022\030\n\013ContactSide\030\t \001(\rH\006\210\001\001\022\027\n\nCon" + "tactRCS\030\n \001(\001H\007\210\001\001\0225\n\020ContactEmissions\030\013" + " \003(\0132\033.messages.SimTrack.EmissionB\024\n\022_Co" + "ntactSourceTypeB\025\n\023_GeocentricPositionB\017" + "\n\r_ContactSpeedB\020\n\016_ContactCourseB\016\n\014_Co" + "nactPitchB\016\n\014_ContactKindB\016\n\014_ContactSid" + "eB\r\n\013_ContactRCS\"\366\002\n\010Emission\022.\n\nIdentif" + "ier\030\001 \001(\0132\032.messages.track.Identifier\022\014\n" + "\004name\030\002 \001(\t\022\021\n\tfrequency\030\003 \001(\001\022\r\n\005Range\030" + "\004 \001(\001\022\026\n\tBandwidth\030\005 \001(\rH\000\210\001\001\022\027\n\npulseWi" + "dth\030\006 \001(\rH\001\210\001\001\022\034\n\017pulseRepitition\030\007 \001(\rH" + "\002\210\001\001\022\032\n\rradiatedPower\030\010 \001(\rH\003\210\001\001\022\032\n\rnumb" + "erOfBeams\030\t \001(\rH\004\210\001\001\022\033\n\016searchInterval\030\n" + " \001(\rH\005\210\001\001B\014\n\n_BandwidthB\r\n\013_pulseWidthB\022" + "\n\020_pulseRepititionB\020\n\016_radiatedPowerB\020\n\016" + "_numberOfBeamsB\021\n\017_searchIntervalb\006proto" + "3" +}; +static const ::_pbi::DescriptorTable* const descriptor_table_SimTrack_2eproto_deps[4] = + { + &::descriptor_table_GeocentricPosition_2eproto, + &::descriptor_table_Identifier_2eproto, + &::descriptor_table_google_2fprotobuf_2fduration_2eproto, + &::descriptor_table_google_2fprotobuf_2ftimestamp_2eproto, +}; +static ::absl::once_flag descriptor_table_SimTrack_2eproto_once; +const ::_pbi::DescriptorTable descriptor_table_SimTrack_2eproto = { + false, + false, + 1081, + descriptor_table_protodef_SimTrack_2eproto, + "SimTrack.proto", + &descriptor_table_SimTrack_2eproto_once, + descriptor_table_SimTrack_2eproto_deps, + 4, + 2, + schemas, + file_default_instances, + TableStruct_SimTrack_2eproto::offsets, + file_level_metadata_SimTrack_2eproto, + file_level_enum_descriptors_SimTrack_2eproto, + file_level_service_descriptors_SimTrack_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_SimTrack_2eproto_getter() { + return &descriptor_table_SimTrack_2eproto; +} +// Force running AddDescriptors() at dynamic initialization time. +PROTOBUF_ATTRIBUTE_INIT_PRIORITY2 +static ::_pbi::AddDescriptorsRunner dynamic_init_dummy_SimTrack_2eproto(&descriptor_table_SimTrack_2eproto); +namespace messages { +namespace SimTrack { +// =================================================================== + +class SimTrack::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(SimTrack, _impl_._has_bits_); + static const ::messages::track::Identifier& entityidentifier(const SimTrack* msg); + static void set_has_entityidentifier(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_contactsourcetype(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static const ::messages::track::EntityGeocentricPosition& geocentricposition(const SimTrack* msg); + static void set_has_geocentricposition(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_contactspeed(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_contactcourse(HasBits* has_bits) { + (*has_bits)[0] |= 32u; + } + static void set_has_conactpitch(HasBits* has_bits) { + (*has_bits)[0] |= 64u; + } + static void set_has_contactkind(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } + static void set_has_contactside(HasBits* has_bits) { + (*has_bits)[0] |= 256u; + } + static void set_has_contactrcs(HasBits* has_bits) { + (*has_bits)[0] |= 128u; + } +}; + +const ::messages::track::Identifier& SimTrack::_Internal::entityidentifier(const SimTrack* msg) { + return *msg->_impl_.entityidentifier_; +} +const ::messages::track::EntityGeocentricPosition& SimTrack::_Internal::geocentricposition(const SimTrack* msg) { + return *msg->_impl_.geocentricposition_; +} +void SimTrack::clear_entityidentifier() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + if (_impl_.entityidentifier_ != nullptr) _impl_.entityidentifier_->Clear(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +void SimTrack::clear_geocentricposition() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + if (_impl_.geocentricposition_ != nullptr) _impl_.geocentricposition_->Clear(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +SimTrack::SimTrack(::google::protobuf::Arena* arena) + : ::google::protobuf::Message(arena) { + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:messages.SimTrack.SimTrack) +} +inline PROTOBUF_NDEBUG_INLINE SimTrack::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, + const Impl_& from) + : _has_bits_{from._has_bits_}, + _cached_size_{0}, + contactemissions_{visibility, arena, from.contactemissions_}, + conatactname_(arena, from.conatactname_) {} + +SimTrack::SimTrack( + ::google::protobuf::Arena* arena, + const SimTrack& from) + : ::google::protobuf::Message(arena) { + SimTrack* 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_.entityidentifier_ = (cached_has_bits & 0x00000001u) + ? CreateMaybeMessage<::messages::track::Identifier>(arena, *from._impl_.entityidentifier_) + : nullptr; + _impl_.geocentricposition_ = (cached_has_bits & 0x00000002u) + ? CreateMaybeMessage<::messages::track::EntityGeocentricPosition>(arena, *from._impl_.geocentricposition_) + : nullptr; + ::memcpy(reinterpret_cast(&_impl_) + + offsetof(Impl_, contactspeed_), + reinterpret_cast(&from._impl_) + + offsetof(Impl_, contactspeed_), + offsetof(Impl_, contactside_) - + offsetof(Impl_, contactspeed_) + + sizeof(Impl_::contactside_)); + + // @@protoc_insertion_point(copy_constructor:messages.SimTrack.SimTrack) +} +inline PROTOBUF_NDEBUG_INLINE SimTrack::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : _cached_size_{0}, + contactemissions_{visibility, arena}, + conatactname_(arena) {} + +inline void SimTrack::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + ::memset(reinterpret_cast(&_impl_) + + offsetof(Impl_, entityidentifier_), + 0, + offsetof(Impl_, contactside_) - + offsetof(Impl_, entityidentifier_) + + sizeof(Impl_::contactside_)); +} +SimTrack::~SimTrack() { + // @@protoc_insertion_point(destructor:messages.SimTrack.SimTrack) + _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + SharedDtor(); +} +inline void SimTrack::SharedDtor() { + ABSL_DCHECK(GetArena() == nullptr); + _impl_.conatactname_.Destroy(); + delete _impl_.entityidentifier_; + delete _impl_.geocentricposition_; + _impl_.~Impl_(); +} + +const ::google::protobuf::MessageLite::ClassData* +SimTrack::GetClassData() const { + PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite::ClassData + _data_ = { + SimTrack::MergeImpl, + nullptr, // OnDemandRegisterArenaDtor + &::google::protobuf::Message::kDescriptorMethods, + PROTOBUF_FIELD_OFFSET(SimTrack, _impl_._cached_size_), + }; + return &_data_; +} +PROTOBUF_NOINLINE void SimTrack::Clear() { +// @@protoc_insertion_point(message_clear_start:messages.SimTrack.SimTrack) + 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_.contactemissions_.Clear(); + _impl_.conatactname_.ClearToEmpty(); + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + ABSL_DCHECK(_impl_.entityidentifier_ != nullptr); + _impl_.entityidentifier_->Clear(); + } + if (cached_has_bits & 0x00000002u) { + ABSL_DCHECK(_impl_.geocentricposition_ != nullptr); + _impl_.geocentricposition_->Clear(); + } + } + if (cached_has_bits & 0x000000fcu) { + ::memset(&_impl_.contactspeed_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.contactrcs_) - + reinterpret_cast(&_impl_.contactspeed_)) + sizeof(_impl_.contactrcs_)); + } + _impl_.contactside_ = 0u; + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +const char* SimTrack::_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<4, 11, 3, 55, 2> SimTrack::_table_ = { + { + PROTOBUF_FIELD_OFFSET(SimTrack, _impl_._has_bits_), + 0, // no _extensions_ + 11, 120, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294965248, // skipmap + offsetof(decltype(_table_), field_entries), + 11, // num_field_entries + 3, // num_aux_entries + offsetof(decltype(_table_), aux_entries), + &_SimTrack_default_instance_._instance, + ::_pbi::TcParser::GenericFallback, // fallback + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + // .messages.track.Identifier EntityIdentifier = 1; + {::_pbi::TcParser::FastMtS1, + {10, 0, 0, PROTOBUF_FIELD_OFFSET(SimTrack, _impl_.entityidentifier_)}}, + // string ConatactName = 2; + {::_pbi::TcParser::FastUS1, + {18, 63, 0, PROTOBUF_FIELD_OFFSET(SimTrack, _impl_.conatactname_)}}, + // optional uint32 ContactSourceType = 3; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(SimTrack, _impl_.contactsourcetype_), 3>(), + {24, 3, 0, PROTOBUF_FIELD_OFFSET(SimTrack, _impl_.contactsourcetype_)}}, + // optional .messages.track.EntityGeocentricPosition GeocentricPosition = 4; + {::_pbi::TcParser::FastMtS1, + {34, 1, 1, PROTOBUF_FIELD_OFFSET(SimTrack, _impl_.geocentricposition_)}}, + // optional double ContactSpeed = 5; + {::_pbi::TcParser::FastF64S1, + {41, 2, 0, PROTOBUF_FIELD_OFFSET(SimTrack, _impl_.contactspeed_)}}, + // optional double ContactCourse = 6; + {::_pbi::TcParser::FastF64S1, + {49, 5, 0, PROTOBUF_FIELD_OFFSET(SimTrack, _impl_.contactcourse_)}}, + // optional double ConactPitch = 7; + {::_pbi::TcParser::FastF64S1, + {57, 6, 0, PROTOBUF_FIELD_OFFSET(SimTrack, _impl_.conactpitch_)}}, + // optional uint32 ContactKind = 8; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(SimTrack, _impl_.contactkind_), 4>(), + {64, 4, 0, PROTOBUF_FIELD_OFFSET(SimTrack, _impl_.contactkind_)}}, + // optional uint32 ContactSide = 9; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(SimTrack, _impl_.contactside_), 8>(), + {72, 8, 0, PROTOBUF_FIELD_OFFSET(SimTrack, _impl_.contactside_)}}, + // optional double ContactRCS = 10; + {::_pbi::TcParser::FastF64S1, + {81, 7, 0, PROTOBUF_FIELD_OFFSET(SimTrack, _impl_.contactrcs_)}}, + // repeated .messages.SimTrack.Emission ContactEmissions = 11; + {::_pbi::TcParser::FastMtR1, + {90, 63, 2, PROTOBUF_FIELD_OFFSET(SimTrack, _impl_.contactemissions_)}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + }}, {{ + 65535, 65535 + }}, {{ + // .messages.track.Identifier EntityIdentifier = 1; + {PROTOBUF_FIELD_OFFSET(SimTrack, _impl_.entityidentifier_), _Internal::kHasBitsOffset + 0, 0, + (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // string ConatactName = 2; + {PROTOBUF_FIELD_OFFSET(SimTrack, _impl_.conatactname_), -1, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // optional uint32 ContactSourceType = 3; + {PROTOBUF_FIELD_OFFSET(SimTrack, _impl_.contactsourcetype_), _Internal::kHasBitsOffset + 3, 0, + (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + // optional .messages.track.EntityGeocentricPosition GeocentricPosition = 4; + {PROTOBUF_FIELD_OFFSET(SimTrack, _impl_.geocentricposition_), _Internal::kHasBitsOffset + 1, 1, + (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // optional double ContactSpeed = 5; + {PROTOBUF_FIELD_OFFSET(SimTrack, _impl_.contactspeed_), _Internal::kHasBitsOffset + 2, 0, + (0 | ::_fl::kFcOptional | ::_fl::kDouble)}, + // optional double ContactCourse = 6; + {PROTOBUF_FIELD_OFFSET(SimTrack, _impl_.contactcourse_), _Internal::kHasBitsOffset + 5, 0, + (0 | ::_fl::kFcOptional | ::_fl::kDouble)}, + // optional double ConactPitch = 7; + {PROTOBUF_FIELD_OFFSET(SimTrack, _impl_.conactpitch_), _Internal::kHasBitsOffset + 6, 0, + (0 | ::_fl::kFcOptional | ::_fl::kDouble)}, + // optional uint32 ContactKind = 8; + {PROTOBUF_FIELD_OFFSET(SimTrack, _impl_.contactkind_), _Internal::kHasBitsOffset + 4, 0, + (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + // optional uint32 ContactSide = 9; + {PROTOBUF_FIELD_OFFSET(SimTrack, _impl_.contactside_), _Internal::kHasBitsOffset + 8, 0, + (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + // optional double ContactRCS = 10; + {PROTOBUF_FIELD_OFFSET(SimTrack, _impl_.contactrcs_), _Internal::kHasBitsOffset + 7, 0, + (0 | ::_fl::kFcOptional | ::_fl::kDouble)}, + // repeated .messages.SimTrack.Emission ContactEmissions = 11; + {PROTOBUF_FIELD_OFFSET(SimTrack, _impl_.contactemissions_), -1, 2, + (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)}, + }}, {{ + {::_pbi::TcParser::GetTable<::messages::track::Identifier>()}, + {::_pbi::TcParser::GetTable<::messages::track::EntityGeocentricPosition>()}, + {::_pbi::TcParser::GetTable<::messages::SimTrack::Emission>()}, + }}, {{ + "\32\0\14\0\0\0\0\0\0\0\0\0\0\0\0\0" + "messages.SimTrack.SimTrack" + "ConatactName" + }}, +}; + +::uint8_t* SimTrack::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:messages.SimTrack.SimTrack) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // .messages.track.Identifier EntityIdentifier = 1; + if (cached_has_bits & 0x00000001u) { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 1, _Internal::entityidentifier(this), + _Internal::entityidentifier(this).GetCachedSize(), target, stream); + } + + // string ConatactName = 2; + if (!this->_internal_conatactname().empty()) { + const std::string& _s = this->_internal_conatactname(); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "messages.SimTrack.SimTrack.ConatactName"); + target = stream->WriteStringMaybeAliased(2, _s, target); + } + + // optional uint32 ContactSourceType = 3; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 3, this->_internal_contactsourcetype(), target); + } + + // optional .messages.track.EntityGeocentricPosition GeocentricPosition = 4; + if (cached_has_bits & 0x00000002u) { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 4, _Internal::geocentricposition(this), + _Internal::geocentricposition(this).GetCachedSize(), target, stream); + } + + // optional double ContactSpeed = 5; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 5, this->_internal_contactspeed(), target); + } + + // optional double ContactCourse = 6; + if (cached_has_bits & 0x00000020u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 6, this->_internal_contactcourse(), target); + } + + // optional double ConactPitch = 7; + if (cached_has_bits & 0x00000040u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 7, this->_internal_conactpitch(), target); + } + + // optional uint32 ContactKind = 8; + if (cached_has_bits & 0x00000010u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 8, this->_internal_contactkind(), target); + } + + // optional uint32 ContactSide = 9; + if (cached_has_bits & 0x00000100u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 9, this->_internal_contactside(), target); + } + + // optional double ContactRCS = 10; + if (cached_has_bits & 0x00000080u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 10, this->_internal_contactrcs(), target); + } + + // repeated .messages.SimTrack.Emission ContactEmissions = 11; + for (unsigned i = 0, + n = static_cast(this->_internal_contactemissions_size()); i < n; i++) { + const auto& repfield = this->_internal_contactemissions().Get(i); + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessage(11, repfield, repfield.GetCachedSize(), target, stream); + } + + 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.SimTrack.SimTrack) + return target; +} + +::size_t SimTrack::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:messages.SimTrack.SimTrack) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .messages.SimTrack.Emission ContactEmissions = 11; + total_size += 1UL * this->_internal_contactemissions_size(); + for (const auto& msg : this->_internal_contactemissions()) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSize(msg); + } + // string ConatactName = 2; + if (!this->_internal_conatactname().empty()) { + total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( + this->_internal_conatactname()); + } + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + // .messages.track.Identifier EntityIdentifier = 1; + if (cached_has_bits & 0x00000001u) { + total_size += + 1 + ::google::protobuf::internal::WireFormatLite::MessageSize(*_impl_.entityidentifier_); + } + + // optional .messages.track.EntityGeocentricPosition GeocentricPosition = 4; + if (cached_has_bits & 0x00000002u) { + total_size += + 1 + ::google::protobuf::internal::WireFormatLite::MessageSize(*_impl_.geocentricposition_); + } + + // optional double ContactSpeed = 5; + if (cached_has_bits & 0x00000004u) { + total_size += 9; + } + + // optional uint32 ContactSourceType = 3; + if (cached_has_bits & 0x00000008u) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this->_internal_contactsourcetype()); + } + + // optional uint32 ContactKind = 8; + if (cached_has_bits & 0x00000010u) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this->_internal_contactkind()); + } + + // optional double ContactCourse = 6; + if (cached_has_bits & 0x00000020u) { + total_size += 9; + } + + // optional double ConactPitch = 7; + if (cached_has_bits & 0x00000040u) { + total_size += 9; + } + + // optional double ContactRCS = 10; + if (cached_has_bits & 0x00000080u) { + total_size += 9; + } + + } + // optional uint32 ContactSide = 9; + if (cached_has_bits & 0x00000100u) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this->_internal_contactside()); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + + +void SimTrack::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.SimTrack.SimTrack) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + _this->_internal_mutable_contactemissions()->MergeFrom( + from._internal_contactemissions()); + if (!from._internal_conatactname().empty()) { + _this->_internal_set_conatactname(from._internal_conatactname()); + } + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_mutable_entityidentifier()->::messages::track::Identifier::MergeFrom( + from._internal_entityidentifier()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_mutable_geocentricposition()->::messages::track::EntityGeocentricPosition::MergeFrom( + from._internal_geocentricposition()); + } + if (cached_has_bits & 0x00000004u) { + _this->_impl_.contactspeed_ = from._impl_.contactspeed_; + } + if (cached_has_bits & 0x00000008u) { + _this->_impl_.contactsourcetype_ = from._impl_.contactsourcetype_; + } + if (cached_has_bits & 0x00000010u) { + _this->_impl_.contactkind_ = from._impl_.contactkind_; + } + if (cached_has_bits & 0x00000020u) { + _this->_impl_.contactcourse_ = from._impl_.contactcourse_; + } + if (cached_has_bits & 0x00000040u) { + _this->_impl_.conactpitch_ = from._impl_.conactpitch_; + } + if (cached_has_bits & 0x00000080u) { + _this->_impl_.contactrcs_ = from._impl_.contactrcs_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + if (cached_has_bits & 0x00000100u) { + _this->_internal_set_contactside(from._internal_contactside()); + } + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void SimTrack::CopyFrom(const SimTrack& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:messages.SimTrack.SimTrack) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +PROTOBUF_NOINLINE bool SimTrack::IsInitialized() const { + return true; +} + +void SimTrack::InternalSwap(SimTrack* 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]); + _impl_.contactemissions_.InternalSwap(&other->_impl_.contactemissions_); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.conatactname_, &other->_impl_.conatactname_, arena); + ::google::protobuf::internal::memswap< + PROTOBUF_FIELD_OFFSET(SimTrack, _impl_.contactside_) + + sizeof(SimTrack::_impl_.contactside_) + - PROTOBUF_FIELD_OFFSET(SimTrack, _impl_.entityidentifier_)>( + reinterpret_cast(&_impl_.entityidentifier_), + reinterpret_cast(&other->_impl_.entityidentifier_)); +} + +::google::protobuf::Metadata SimTrack::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_SimTrack_2eproto_getter, &descriptor_table_SimTrack_2eproto_once, + file_level_metadata_SimTrack_2eproto[0]); +} +// =================================================================== + +class Emission::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(Emission, _impl_._has_bits_); + static const ::messages::track::Identifier& identifier(const Emission* msg); + static void set_has_identifier(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_bandwidth(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_pulsewidth(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_pulserepitition(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static void set_has_radiatedpower(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } + static void set_has_numberofbeams(HasBits* has_bits) { + (*has_bits)[0] |= 32u; + } + static void set_has_searchinterval(HasBits* has_bits) { + (*has_bits)[0] |= 64u; + } +}; + +const ::messages::track::Identifier& Emission::_Internal::identifier(const Emission* msg) { + return *msg->_impl_.identifier_; +} +void Emission::clear_identifier() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + if (_impl_.identifier_ != nullptr) _impl_.identifier_->Clear(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +Emission::Emission(::google::protobuf::Arena* arena) + : ::google::protobuf::Message(arena) { + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:messages.SimTrack.Emission) +} +inline PROTOBUF_NDEBUG_INLINE Emission::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, + const Impl_& from) + : _has_bits_{from._has_bits_}, + _cached_size_{0}, + name_(arena, from.name_) {} + +Emission::Emission( + ::google::protobuf::Arena* arena, + const Emission& from) + : ::google::protobuf::Message(arena) { + Emission* 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_, frequency_), + reinterpret_cast(&from._impl_) + + offsetof(Impl_, frequency_), + offsetof(Impl_, searchinterval_) - + offsetof(Impl_, frequency_) + + sizeof(Impl_::searchinterval_)); + + // @@protoc_insertion_point(copy_constructor:messages.SimTrack.Emission) +} +inline PROTOBUF_NDEBUG_INLINE Emission::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : _cached_size_{0}, + name_(arena) {} + +inline void Emission::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + ::memset(reinterpret_cast(&_impl_) + + offsetof(Impl_, identifier_), + 0, + offsetof(Impl_, searchinterval_) - + offsetof(Impl_, identifier_) + + sizeof(Impl_::searchinterval_)); +} +Emission::~Emission() { + // @@protoc_insertion_point(destructor:messages.SimTrack.Emission) + _internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + SharedDtor(); +} +inline void Emission::SharedDtor() { + ABSL_DCHECK(GetArena() == nullptr); + _impl_.name_.Destroy(); + delete _impl_.identifier_; + _impl_.~Impl_(); +} + +const ::google::protobuf::MessageLite::ClassData* +Emission::GetClassData() const { + PROTOBUF_CONSTINIT static const ::google::protobuf::MessageLite::ClassData + _data_ = { + Emission::MergeImpl, + nullptr, // OnDemandRegisterArenaDtor + &::google::protobuf::Message::kDescriptorMethods, + PROTOBUF_FIELD_OFFSET(Emission, _impl_._cached_size_), + }; + return &_data_; +} +PROTOBUF_NOINLINE void Emission::Clear() { +// @@protoc_insertion_point(message_clear_start:messages.SimTrack.Emission) + 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_.name_.ClearToEmpty(); + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + ABSL_DCHECK(_impl_.identifier_ != nullptr); + _impl_.identifier_->Clear(); + } + ::memset(&_impl_.frequency_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.range_) - + reinterpret_cast(&_impl_.frequency_)) + sizeof(_impl_.range_)); + if (cached_has_bits & 0x0000007eu) { + ::memset(&_impl_.bandwidth_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.searchinterval_) - + reinterpret_cast(&_impl_.bandwidth_)) + sizeof(_impl_.searchinterval_)); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +const char* Emission::_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<4, 10, 1, 47, 2> Emission::_table_ = { + { + PROTOBUF_FIELD_OFFSET(Emission, _impl_._has_bits_), + 0, // no _extensions_ + 10, 120, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294966272, // skipmap + offsetof(decltype(_table_), field_entries), + 10, // num_field_entries + 1, // num_aux_entries + offsetof(decltype(_table_), aux_entries), + &_Emission_default_instance_._instance, + ::_pbi::TcParser::GenericFallback, // fallback + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + // .messages.track.Identifier Identifier = 1; + {::_pbi::TcParser::FastMtS1, + {10, 0, 0, PROTOBUF_FIELD_OFFSET(Emission, _impl_.identifier_)}}, + // string name = 2; + {::_pbi::TcParser::FastUS1, + {18, 63, 0, PROTOBUF_FIELD_OFFSET(Emission, _impl_.name_)}}, + // double frequency = 3; + {::_pbi::TcParser::FastF64S1, + {25, 63, 0, PROTOBUF_FIELD_OFFSET(Emission, _impl_.frequency_)}}, + // double Range = 4; + {::_pbi::TcParser::FastF64S1, + {33, 63, 0, PROTOBUF_FIELD_OFFSET(Emission, _impl_.range_)}}, + // optional uint32 Bandwidth = 5; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(Emission, _impl_.bandwidth_), 1>(), + {40, 1, 0, PROTOBUF_FIELD_OFFSET(Emission, _impl_.bandwidth_)}}, + // optional uint32 pulseWidth = 6; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(Emission, _impl_.pulsewidth_), 2>(), + {48, 2, 0, PROTOBUF_FIELD_OFFSET(Emission, _impl_.pulsewidth_)}}, + // optional uint32 pulseRepitition = 7; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(Emission, _impl_.pulserepitition_), 3>(), + {56, 3, 0, PROTOBUF_FIELD_OFFSET(Emission, _impl_.pulserepitition_)}}, + // optional uint32 radiatedPower = 8; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(Emission, _impl_.radiatedpower_), 4>(), + {64, 4, 0, PROTOBUF_FIELD_OFFSET(Emission, _impl_.radiatedpower_)}}, + // optional uint32 numberOfBeams = 9; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(Emission, _impl_.numberofbeams_), 5>(), + {72, 5, 0, PROTOBUF_FIELD_OFFSET(Emission, _impl_.numberofbeams_)}}, + // optional uint32 searchInterval = 10; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(Emission, _impl_.searchinterval_), 6>(), + {80, 6, 0, PROTOBUF_FIELD_OFFSET(Emission, _impl_.searchinterval_)}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + }}, {{ + 65535, 65535 + }}, {{ + // .messages.track.Identifier Identifier = 1; + {PROTOBUF_FIELD_OFFSET(Emission, _impl_.identifier_), _Internal::kHasBitsOffset + 0, 0, + (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // string name = 2; + {PROTOBUF_FIELD_OFFSET(Emission, _impl_.name_), -1, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // double frequency = 3; + {PROTOBUF_FIELD_OFFSET(Emission, _impl_.frequency_), -1, 0, + (0 | ::_fl::kFcSingular | ::_fl::kDouble)}, + // double Range = 4; + {PROTOBUF_FIELD_OFFSET(Emission, _impl_.range_), -1, 0, + (0 | ::_fl::kFcSingular | ::_fl::kDouble)}, + // optional uint32 Bandwidth = 5; + {PROTOBUF_FIELD_OFFSET(Emission, _impl_.bandwidth_), _Internal::kHasBitsOffset + 1, 0, + (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + // optional uint32 pulseWidth = 6; + {PROTOBUF_FIELD_OFFSET(Emission, _impl_.pulsewidth_), _Internal::kHasBitsOffset + 2, 0, + (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + // optional uint32 pulseRepitition = 7; + {PROTOBUF_FIELD_OFFSET(Emission, _impl_.pulserepitition_), _Internal::kHasBitsOffset + 3, 0, + (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + // optional uint32 radiatedPower = 8; + {PROTOBUF_FIELD_OFFSET(Emission, _impl_.radiatedpower_), _Internal::kHasBitsOffset + 4, 0, + (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + // optional uint32 numberOfBeams = 9; + {PROTOBUF_FIELD_OFFSET(Emission, _impl_.numberofbeams_), _Internal::kHasBitsOffset + 5, 0, + (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + // optional uint32 searchInterval = 10; + {PROTOBUF_FIELD_OFFSET(Emission, _impl_.searchinterval_), _Internal::kHasBitsOffset + 6, 0, + (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + }}, {{ + {::_pbi::TcParser::GetTable<::messages::track::Identifier>()}, + }}, {{ + "\32\0\4\0\0\0\0\0\0\0\0\0\0\0\0\0" + "messages.SimTrack.Emission" + "name" + }}, +}; + +::uint8_t* Emission::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:messages.SimTrack.Emission) + ::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); + } + + // string name = 2; + if (!this->_internal_name().empty()) { + const std::string& _s = this->_internal_name(); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "messages.SimTrack.Emission.name"); + target = stream->WriteStringMaybeAliased(2, _s, target); + } + + // double frequency = 3; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_frequency = this->_internal_frequency(); + ::uint64_t raw_frequency; + memcpy(&raw_frequency, &tmp_frequency, sizeof(tmp_frequency)); + if (raw_frequency != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 3, this->_internal_frequency(), target); + } + + // double Range = 4; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_range = this->_internal_range(); + ::uint64_t raw_range; + memcpy(&raw_range, &tmp_range, sizeof(tmp_range)); + if (raw_range != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 4, this->_internal_range(), target); + } + + // optional uint32 Bandwidth = 5; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 5, this->_internal_bandwidth(), target); + } + + // optional uint32 pulseWidth = 6; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 6, this->_internal_pulsewidth(), target); + } + + // optional uint32 pulseRepitition = 7; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 7, this->_internal_pulserepitition(), target); + } + + // optional uint32 radiatedPower = 8; + if (cached_has_bits & 0x00000010u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 8, this->_internal_radiatedpower(), target); + } + + // optional uint32 numberOfBeams = 9; + if (cached_has_bits & 0x00000020u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 9, this->_internal_numberofbeams(), target); + } + + // optional uint32 searchInterval = 10; + if (cached_has_bits & 0x00000040u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 10, this->_internal_searchinterval(), 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.SimTrack.Emission) + return target; +} + +::size_t Emission::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:messages.SimTrack.Emission) + ::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 name = 2; + if (!this->_internal_name().empty()) { + total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( + this->_internal_name()); + } + + // .messages.track.Identifier Identifier = 1; + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + total_size += + 1 + ::google::protobuf::internal::WireFormatLite::MessageSize(*_impl_.identifier_); + } + + // double frequency = 3; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_frequency = this->_internal_frequency(); + ::uint64_t raw_frequency; + memcpy(&raw_frequency, &tmp_frequency, sizeof(tmp_frequency)); + if (raw_frequency != 0) { + total_size += 9; + } + + // double Range = 4; + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_range = this->_internal_range(); + ::uint64_t raw_range; + memcpy(&raw_range, &tmp_range, sizeof(tmp_range)); + if (raw_range != 0) { + total_size += 9; + } + + if (cached_has_bits & 0x0000007eu) { + // optional uint32 Bandwidth = 5; + if (cached_has_bits & 0x00000002u) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this->_internal_bandwidth()); + } + + // optional uint32 pulseWidth = 6; + if (cached_has_bits & 0x00000004u) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this->_internal_pulsewidth()); + } + + // optional uint32 pulseRepitition = 7; + if (cached_has_bits & 0x00000008u) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this->_internal_pulserepitition()); + } + + // optional uint32 radiatedPower = 8; + if (cached_has_bits & 0x00000010u) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this->_internal_radiatedpower()); + } + + // optional uint32 numberOfBeams = 9; + if (cached_has_bits & 0x00000020u) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this->_internal_numberofbeams()); + } + + // optional uint32 searchInterval = 10; + if (cached_has_bits & 0x00000040u) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this->_internal_searchinterval()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + + +void Emission::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.SimTrack.Emission) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (!from._internal_name().empty()) { + _this->_internal_set_name(from._internal_name()); + } + if ((from._impl_._has_bits_[0] & 0x00000001u) != 0) { + _this->_internal_mutable_identifier()->::messages::track::Identifier::MergeFrom( + from._internal_identifier()); + } + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_frequency = from._internal_frequency(); + ::uint64_t raw_frequency; + memcpy(&raw_frequency, &tmp_frequency, sizeof(tmp_frequency)); + if (raw_frequency != 0) { + _this->_internal_set_frequency(from._internal_frequency()); + } + static_assert(sizeof(::uint64_t) == sizeof(double), + "Code assumes ::uint64_t and double are the same size."); + double tmp_range = from._internal_range(); + ::uint64_t raw_range; + memcpy(&raw_range, &tmp_range, sizeof(tmp_range)); + if (raw_range != 0) { + _this->_internal_set_range(from._internal_range()); + } + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x0000007eu) { + if (cached_has_bits & 0x00000002u) { + _this->_impl_.bandwidth_ = from._impl_.bandwidth_; + } + if (cached_has_bits & 0x00000004u) { + _this->_impl_.pulsewidth_ = from._impl_.pulsewidth_; + } + if (cached_has_bits & 0x00000008u) { + _this->_impl_.pulserepitition_ = from._impl_.pulserepitition_; + } + if (cached_has_bits & 0x00000010u) { + _this->_impl_.radiatedpower_ = from._impl_.radiatedpower_; + } + if (cached_has_bits & 0x00000020u) { + _this->_impl_.numberofbeams_ = from._impl_.numberofbeams_; + } + if (cached_has_bits & 0x00000040u) { + _this->_impl_.searchinterval_ = from._impl_.searchinterval_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_); +} + +void Emission::CopyFrom(const Emission& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:messages.SimTrack.Emission) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +PROTOBUF_NOINLINE bool Emission::IsInitialized() const { + return true; +} + +void Emission::InternalSwap(Emission* 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_.name_, &other->_impl_.name_, arena); + ::google::protobuf::internal::memswap< + PROTOBUF_FIELD_OFFSET(Emission, _impl_.searchinterval_) + + sizeof(Emission::_impl_.searchinterval_) + - PROTOBUF_FIELD_OFFSET(Emission, _impl_.identifier_)>( + reinterpret_cast(&_impl_.identifier_), + reinterpret_cast(&other->_impl_.identifier_)); +} + +::google::protobuf::Metadata Emission::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_SimTrack_2eproto_getter, &descriptor_table_SimTrack_2eproto_once, + file_level_metadata_SimTrack_2eproto[1]); +} +// @@protoc_insertion_point(namespace_scope) +} // namespace SimTrack +} // 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/SimTrack.pb.h b/include/SimCore/Messages/Protos/SimTrack.pb.h new file mode 100644 index 0000000..9ba94b1 --- /dev/null +++ b/include/SimCore/Messages/Protos/SimTrack.pb.h @@ -0,0 +1,1578 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: SimTrack.proto +// Protobuf C++ Version: 4.24.0-main + +#ifndef GOOGLE_PROTOBUF_INCLUDED_SimTrack_2eproto_2epb_2eh +#define GOOGLE_PROTOBUF_INCLUDED_SimTrack_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 "google/protobuf/timestamp.pb.h" +#include "google/protobuf/duration.pb.h" +#include "Identifier.pb.h" +#include "GeocentricPosition.pb.h" +// @@protoc_insertion_point(includes) + +// Must be included last. +#include "google/protobuf/port_def.inc" + +#define PROTOBUF_INTERNAL_EXPORT_SimTrack_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_SimTrack_2eproto { + static const ::uint32_t offsets[]; +}; +extern const ::google::protobuf::internal::DescriptorTable + descriptor_table_SimTrack_2eproto; +namespace messages { +namespace SimTrack { +class Emission; +struct EmissionDefaultTypeInternal; +extern EmissionDefaultTypeInternal _Emission_default_instance_; +class SimTrack; +struct SimTrackDefaultTypeInternal; +extern SimTrackDefaultTypeInternal _SimTrack_default_instance_; +} // namespace SimTrack +} // namespace messages +namespace google { +namespace protobuf { +} // namespace protobuf +} // namespace google + +namespace messages { +namespace SimTrack { + +// =================================================================== + + +// ------------------------------------------------------------------- + +class Emission final : + public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:messages.SimTrack.Emission) */ { + public: + inline Emission() : Emission(nullptr) {} + ~Emission() override; + template + explicit PROTOBUF_CONSTEXPR Emission(::google::protobuf::internal::ConstantInitialized); + + inline Emission(const Emission& from) + : Emission(nullptr, from) {} + Emission(Emission&& from) noexcept + : Emission() { + *this = ::std::move(from); + } + + inline Emission& operator=(const Emission& from) { + CopyFrom(from); + return *this; + } + inline Emission& operator=(Emission&& 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 Emission& default_instance() { + return *internal_default_instance(); + } + static inline const Emission* internal_default_instance() { + return reinterpret_cast( + &_Emission_default_instance_); + } + static constexpr int kIndexInFileMessages = + 1; + + friend void swap(Emission& a, Emission& b) { + a.Swap(&b); + } + inline void Swap(Emission* 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(Emission* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Emission* New(::google::protobuf::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const Emission& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom( const Emission& from) { + Emission::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(Emission* other); + + private: + friend class ::google::protobuf::internal::AnyMetadata; + static ::absl::string_view FullMessageName() { + return "messages.SimTrack.Emission"; + } + protected: + explicit Emission(::google::protobuf::Arena* arena); + Emission(::google::protobuf::Arena* arena, const Emission& from); + const ::google::protobuf::MessageLite::ClassData* GetClassData() const final; + public: + + ::google::protobuf::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kNameFieldNumber = 2, + kIdentifierFieldNumber = 1, + kFrequencyFieldNumber = 3, + kRangeFieldNumber = 4, + kBandwidthFieldNumber = 5, + kPulseWidthFieldNumber = 6, + kPulseRepititionFieldNumber = 7, + kRadiatedPowerFieldNumber = 8, + kNumberOfBeamsFieldNumber = 9, + kSearchIntervalFieldNumber = 10, + }; + // string name = 2; + void clear_name() ; + const std::string& name() const; + template + void set_name(Arg_&& arg, Args_... args); + std::string* mutable_name(); + PROTOBUF_NODISCARD std::string* release_name(); + void set_allocated_name(std::string* value); + + private: + const std::string& _internal_name() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_name( + const std::string& value); + std::string* _internal_mutable_name(); + + 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: + // double frequency = 3; + void clear_frequency() ; + double frequency() const; + void set_frequency(double value); + + private: + double _internal_frequency() const; + void _internal_set_frequency(double value); + + public: + // double Range = 4; + void clear_range() ; + double range() const; + void set_range(double value); + + private: + double _internal_range() const; + void _internal_set_range(double value); + + public: + // optional uint32 Bandwidth = 5; + bool has_bandwidth() const; + void clear_bandwidth() ; + ::uint32_t bandwidth() const; + void set_bandwidth(::uint32_t value); + + private: + ::uint32_t _internal_bandwidth() const; + void _internal_set_bandwidth(::uint32_t value); + + public: + // optional uint32 pulseWidth = 6; + bool has_pulsewidth() const; + void clear_pulsewidth() ; + ::uint32_t pulsewidth() const; + void set_pulsewidth(::uint32_t value); + + private: + ::uint32_t _internal_pulsewidth() const; + void _internal_set_pulsewidth(::uint32_t value); + + public: + // optional uint32 pulseRepitition = 7; + bool has_pulserepitition() const; + void clear_pulserepitition() ; + ::uint32_t pulserepitition() const; + void set_pulserepitition(::uint32_t value); + + private: + ::uint32_t _internal_pulserepitition() const; + void _internal_set_pulserepitition(::uint32_t value); + + public: + // optional uint32 radiatedPower = 8; + bool has_radiatedpower() const; + void clear_radiatedpower() ; + ::uint32_t radiatedpower() const; + void set_radiatedpower(::uint32_t value); + + private: + ::uint32_t _internal_radiatedpower() const; + void _internal_set_radiatedpower(::uint32_t value); + + public: + // optional uint32 numberOfBeams = 9; + bool has_numberofbeams() const; + void clear_numberofbeams() ; + ::uint32_t numberofbeams() const; + void set_numberofbeams(::uint32_t value); + + private: + ::uint32_t _internal_numberofbeams() const; + void _internal_set_numberofbeams(::uint32_t value); + + public: + // optional uint32 searchInterval = 10; + bool has_searchinterval() const; + void clear_searchinterval() ; + ::uint32_t searchinterval() const; + void set_searchinterval(::uint32_t value); + + private: + ::uint32_t _internal_searchinterval() const; + void _internal_set_searchinterval(::uint32_t value); + + public: + // @@protoc_insertion_point(class_scope:messages.SimTrack.Emission) + private: + class _Internal; + + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 4, 10, 1, + 47, 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 name_; + ::messages::track::Identifier* identifier_; + double frequency_; + double range_; + ::uint32_t bandwidth_; + ::uint32_t pulsewidth_; + ::uint32_t pulserepitition_; + ::uint32_t radiatedpower_; + ::uint32_t numberofbeams_; + ::uint32_t searchinterval_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_SimTrack_2eproto; +};// ------------------------------------------------------------------- + +class SimTrack final : + public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:messages.SimTrack.SimTrack) */ { + public: + inline SimTrack() : SimTrack(nullptr) {} + ~SimTrack() override; + template + explicit PROTOBUF_CONSTEXPR SimTrack(::google::protobuf::internal::ConstantInitialized); + + inline SimTrack(const SimTrack& from) + : SimTrack(nullptr, from) {} + SimTrack(SimTrack&& from) noexcept + : SimTrack() { + *this = ::std::move(from); + } + + inline SimTrack& operator=(const SimTrack& from) { + CopyFrom(from); + return *this; + } + inline SimTrack& operator=(SimTrack&& 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 SimTrack& default_instance() { + return *internal_default_instance(); + } + static inline const SimTrack* internal_default_instance() { + return reinterpret_cast( + &_SimTrack_default_instance_); + } + static constexpr int kIndexInFileMessages = + 0; + + friend void swap(SimTrack& a, SimTrack& b) { + a.Swap(&b); + } + inline void Swap(SimTrack* 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(SimTrack* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + SimTrack* New(::google::protobuf::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const SimTrack& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom( const SimTrack& from) { + SimTrack::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(SimTrack* other); + + private: + friend class ::google::protobuf::internal::AnyMetadata; + static ::absl::string_view FullMessageName() { + return "messages.SimTrack.SimTrack"; + } + protected: + explicit SimTrack(::google::protobuf::Arena* arena); + SimTrack(::google::protobuf::Arena* arena, const SimTrack& from); + const ::google::protobuf::MessageLite::ClassData* GetClassData() const final; + public: + + ::google::protobuf::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kContactEmissionsFieldNumber = 11, + kConatactNameFieldNumber = 2, + kEntityIdentifierFieldNumber = 1, + kGeocentricPositionFieldNumber = 4, + kContactSpeedFieldNumber = 5, + kContactSourceTypeFieldNumber = 3, + kContactKindFieldNumber = 8, + kContactCourseFieldNumber = 6, + kConactPitchFieldNumber = 7, + kContactRCSFieldNumber = 10, + kContactSideFieldNumber = 9, + }; + // repeated .messages.SimTrack.Emission ContactEmissions = 11; + int contactemissions_size() const; + private: + int _internal_contactemissions_size() const; + + public: + void clear_contactemissions() ; + ::messages::SimTrack::Emission* mutable_contactemissions(int index); + ::google::protobuf::RepeatedPtrField< ::messages::SimTrack::Emission >* + mutable_contactemissions(); + private: + const ::google::protobuf::RepeatedPtrField<::messages::SimTrack::Emission>& _internal_contactemissions() const; + ::google::protobuf::RepeatedPtrField<::messages::SimTrack::Emission>* _internal_mutable_contactemissions(); + public: + const ::messages::SimTrack::Emission& contactemissions(int index) const; + ::messages::SimTrack::Emission* add_contactemissions(); + const ::google::protobuf::RepeatedPtrField< ::messages::SimTrack::Emission >& + contactemissions() const; + // string ConatactName = 2; + void clear_conatactname() ; + const std::string& conatactname() const; + template + void set_conatactname(Arg_&& arg, Args_... args); + std::string* mutable_conatactname(); + PROTOBUF_NODISCARD std::string* release_conatactname(); + void set_allocated_conatactname(std::string* value); + + private: + const std::string& _internal_conatactname() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_conatactname( + const std::string& value); + std::string* _internal_mutable_conatactname(); + + public: + // .messages.track.Identifier EntityIdentifier = 1; + bool has_entityidentifier() const; + void clear_entityidentifier() ; + const ::messages::track::Identifier& entityidentifier() const; + PROTOBUF_NODISCARD ::messages::track::Identifier* release_entityidentifier(); + ::messages::track::Identifier* mutable_entityidentifier(); + void set_allocated_entityidentifier(::messages::track::Identifier* value); + void unsafe_arena_set_allocated_entityidentifier(::messages::track::Identifier* value); + ::messages::track::Identifier* unsafe_arena_release_entityidentifier(); + + private: + const ::messages::track::Identifier& _internal_entityidentifier() const; + ::messages::track::Identifier* _internal_mutable_entityidentifier(); + + public: + // optional .messages.track.EntityGeocentricPosition GeocentricPosition = 4; + bool has_geocentricposition() const; + void clear_geocentricposition() ; + const ::messages::track::EntityGeocentricPosition& geocentricposition() const; + PROTOBUF_NODISCARD ::messages::track::EntityGeocentricPosition* release_geocentricposition(); + ::messages::track::EntityGeocentricPosition* mutable_geocentricposition(); + void set_allocated_geocentricposition(::messages::track::EntityGeocentricPosition* value); + void unsafe_arena_set_allocated_geocentricposition(::messages::track::EntityGeocentricPosition* value); + ::messages::track::EntityGeocentricPosition* unsafe_arena_release_geocentricposition(); + + private: + const ::messages::track::EntityGeocentricPosition& _internal_geocentricposition() const; + ::messages::track::EntityGeocentricPosition* _internal_mutable_geocentricposition(); + + public: + // optional double ContactSpeed = 5; + bool has_contactspeed() const; + void clear_contactspeed() ; + double contactspeed() const; + void set_contactspeed(double value); + + private: + double _internal_contactspeed() const; + void _internal_set_contactspeed(double value); + + public: + // optional uint32 ContactSourceType = 3; + bool has_contactsourcetype() const; + void clear_contactsourcetype() ; + ::uint32_t contactsourcetype() const; + void set_contactsourcetype(::uint32_t value); + + private: + ::uint32_t _internal_contactsourcetype() const; + void _internal_set_contactsourcetype(::uint32_t value); + + public: + // optional uint32 ContactKind = 8; + bool has_contactkind() const; + void clear_contactkind() ; + ::uint32_t contactkind() const; + void set_contactkind(::uint32_t value); + + private: + ::uint32_t _internal_contactkind() const; + void _internal_set_contactkind(::uint32_t value); + + public: + // optional double ContactCourse = 6; + bool has_contactcourse() const; + void clear_contactcourse() ; + double contactcourse() const; + void set_contactcourse(double value); + + private: + double _internal_contactcourse() const; + void _internal_set_contactcourse(double value); + + public: + // optional double ConactPitch = 7; + bool has_conactpitch() const; + void clear_conactpitch() ; + double conactpitch() const; + void set_conactpitch(double value); + + private: + double _internal_conactpitch() const; + void _internal_set_conactpitch(double value); + + public: + // optional double ContactRCS = 10; + bool has_contactrcs() const; + void clear_contactrcs() ; + double contactrcs() const; + void set_contactrcs(double value); + + private: + double _internal_contactrcs() const; + void _internal_set_contactrcs(double value); + + public: + // optional uint32 ContactSide = 9; + bool has_contactside() const; + void clear_contactside() ; + ::uint32_t contactside() const; + void set_contactside(::uint32_t value); + + private: + ::uint32_t _internal_contactside() const; + void _internal_set_contactside(::uint32_t value); + + public: + // @@protoc_insertion_point(class_scope:messages.SimTrack.SimTrack) + private: + class _Internal; + + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 4, 11, 3, + 55, 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::RepeatedPtrField< ::messages::SimTrack::Emission > contactemissions_; + ::google::protobuf::internal::ArenaStringPtr conatactname_; + ::messages::track::Identifier* entityidentifier_; + ::messages::track::EntityGeocentricPosition* geocentricposition_; + double contactspeed_; + ::uint32_t contactsourcetype_; + ::uint32_t contactkind_; + double contactcourse_; + double conactpitch_; + double contactrcs_; + ::uint32_t contactside_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_SimTrack_2eproto; +}; + +// =================================================================== + + + + +// =================================================================== + + +#ifdef __GNUC__ +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wstrict-aliasing" +#endif // __GNUC__ +// ------------------------------------------------------------------- + +// SimTrack + +// .messages.track.Identifier EntityIdentifier = 1; +inline bool SimTrack::has_entityidentifier() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || _impl_.entityidentifier_ != nullptr); + return value; +} +inline const ::messages::track::Identifier& SimTrack::_internal_entityidentifier() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + const ::messages::track::Identifier* p = _impl_.entityidentifier_; + return p != nullptr ? *p : reinterpret_cast(::messages::track::_Identifier_default_instance_); +} +inline const ::messages::track::Identifier& SimTrack::entityidentifier() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:messages.SimTrack.SimTrack.EntityIdentifier) + return _internal_entityidentifier(); +} +inline void SimTrack::unsafe_arena_set_allocated_entityidentifier(::messages::track::Identifier* value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + if (GetArena() == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.entityidentifier_); + } + _impl_.entityidentifier_ = 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.SimTrack.SimTrack.EntityIdentifier) +} +inline ::messages::track::Identifier* SimTrack::release_entityidentifier() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + + _impl_._has_bits_[0] &= ~0x00000001u; + ::messages::track::Identifier* released = _impl_.entityidentifier_; + _impl_.entityidentifier_ = 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* SimTrack::unsafe_arena_release_entityidentifier() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + // @@protoc_insertion_point(field_release:messages.SimTrack.SimTrack.EntityIdentifier) + + _impl_._has_bits_[0] &= ~0x00000001u; + ::messages::track::Identifier* temp = _impl_.entityidentifier_; + _impl_.entityidentifier_ = nullptr; + return temp; +} +inline ::messages::track::Identifier* SimTrack::_internal_mutable_entityidentifier() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + _impl_._has_bits_[0] |= 0x00000001u; + if (_impl_.entityidentifier_ == nullptr) { + auto* p = CreateMaybeMessage<::messages::track::Identifier>(GetArena()); + _impl_.entityidentifier_ = reinterpret_cast<::messages::track::Identifier*>(p); + } + return _impl_.entityidentifier_; +} +inline ::messages::track::Identifier* SimTrack::mutable_entityidentifier() ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::messages::track::Identifier* _msg = _internal_mutable_entityidentifier(); + // @@protoc_insertion_point(field_mutable:messages.SimTrack.SimTrack.EntityIdentifier) + return _msg; +} +inline void SimTrack::set_allocated_entityidentifier(::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_.entityidentifier_); + } + + 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_.entityidentifier_ = reinterpret_cast<::messages::track::Identifier*>(value); + // @@protoc_insertion_point(field_set_allocated:messages.SimTrack.SimTrack.EntityIdentifier) +} + +// string ConatactName = 2; +inline void SimTrack::clear_conatactname() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + _impl_.conatactname_.ClearToEmpty(); +} +inline const std::string& SimTrack::conatactname() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:messages.SimTrack.SimTrack.ConatactName) + return _internal_conatactname(); +} +template +inline PROTOBUF_ALWAYS_INLINE void SimTrack::set_conatactname(Arg_&& arg, + Args_... args) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.conatactname_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:messages.SimTrack.SimTrack.ConatactName) +} +inline std::string* SimTrack::mutable_conatactname() ABSL_ATTRIBUTE_LIFETIME_BOUND { + std::string* _s = _internal_mutable_conatactname(); + // @@protoc_insertion_point(field_mutable:messages.SimTrack.SimTrack.ConatactName) + return _s; +} +inline const std::string& SimTrack::_internal_conatactname() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.conatactname_.Get(); +} +inline void SimTrack::_internal_set_conatactname(const std::string& value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.conatactname_.Set(value, GetArena()); +} +inline std::string* SimTrack::_internal_mutable_conatactname() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + return _impl_.conatactname_.Mutable( GetArena()); +} +inline std::string* SimTrack::release_conatactname() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + // @@protoc_insertion_point(field_release:messages.SimTrack.SimTrack.ConatactName) + return _impl_.conatactname_.Release(); +} +inline void SimTrack::set_allocated_conatactname(std::string* value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + _impl_.conatactname_.SetAllocated(value, GetArena()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.conatactname_.IsDefault()) { + _impl_.conatactname_.Set("", GetArena()); + } + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:messages.SimTrack.SimTrack.ConatactName) +} + +// optional uint32 ContactSourceType = 3; +inline bool SimTrack::has_contactsourcetype() const { + bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline void SimTrack::clear_contactsourcetype() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + _impl_.contactsourcetype_ = 0u; + _impl_._has_bits_[0] &= ~0x00000008u; +} +inline ::uint32_t SimTrack::contactsourcetype() const { + // @@protoc_insertion_point(field_get:messages.SimTrack.SimTrack.ContactSourceType) + return _internal_contactsourcetype(); +} +inline void SimTrack::set_contactsourcetype(::uint32_t value) { + _internal_set_contactsourcetype(value); + // @@protoc_insertion_point(field_set:messages.SimTrack.SimTrack.ContactSourceType) +} +inline ::uint32_t SimTrack::_internal_contactsourcetype() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.contactsourcetype_; +} +inline void SimTrack::_internal_set_contactsourcetype(::uint32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + _impl_._has_bits_[0] |= 0x00000008u; + _impl_.contactsourcetype_ = value; +} + +// optional .messages.track.EntityGeocentricPosition GeocentricPosition = 4; +inline bool SimTrack::has_geocentricposition() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + PROTOBUF_ASSUME(!value || _impl_.geocentricposition_ != nullptr); + return value; +} +inline const ::messages::track::EntityGeocentricPosition& SimTrack::_internal_geocentricposition() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + const ::messages::track::EntityGeocentricPosition* p = _impl_.geocentricposition_; + return p != nullptr ? *p : reinterpret_cast(::messages::track::_EntityGeocentricPosition_default_instance_); +} +inline const ::messages::track::EntityGeocentricPosition& SimTrack::geocentricposition() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:messages.SimTrack.SimTrack.GeocentricPosition) + return _internal_geocentricposition(); +} +inline void SimTrack::unsafe_arena_set_allocated_geocentricposition(::messages::track::EntityGeocentricPosition* value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + if (GetArena() == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.geocentricposition_); + } + _impl_.geocentricposition_ = reinterpret_cast<::messages::track::EntityGeocentricPosition*>(value); + if (value != nullptr) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:messages.SimTrack.SimTrack.GeocentricPosition) +} +inline ::messages::track::EntityGeocentricPosition* SimTrack::release_geocentricposition() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + + _impl_._has_bits_[0] &= ~0x00000002u; + ::messages::track::EntityGeocentricPosition* released = _impl_.geocentricposition_; + _impl_.geocentricposition_ = 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::EntityGeocentricPosition* SimTrack::unsafe_arena_release_geocentricposition() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + // @@protoc_insertion_point(field_release:messages.SimTrack.SimTrack.GeocentricPosition) + + _impl_._has_bits_[0] &= ~0x00000002u; + ::messages::track::EntityGeocentricPosition* temp = _impl_.geocentricposition_; + _impl_.geocentricposition_ = nullptr; + return temp; +} +inline ::messages::track::EntityGeocentricPosition* SimTrack::_internal_mutable_geocentricposition() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + _impl_._has_bits_[0] |= 0x00000002u; + if (_impl_.geocentricposition_ == nullptr) { + auto* p = CreateMaybeMessage<::messages::track::EntityGeocentricPosition>(GetArena()); + _impl_.geocentricposition_ = reinterpret_cast<::messages::track::EntityGeocentricPosition*>(p); + } + return _impl_.geocentricposition_; +} +inline ::messages::track::EntityGeocentricPosition* SimTrack::mutable_geocentricposition() ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::messages::track::EntityGeocentricPosition* _msg = _internal_mutable_geocentricposition(); + // @@protoc_insertion_point(field_mutable:messages.SimTrack.SimTrack.GeocentricPosition) + return _msg; +} +inline void SimTrack::set_allocated_geocentricposition(::messages::track::EntityGeocentricPosition* 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_.geocentricposition_); + } + + 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] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + + _impl_.geocentricposition_ = reinterpret_cast<::messages::track::EntityGeocentricPosition*>(value); + // @@protoc_insertion_point(field_set_allocated:messages.SimTrack.SimTrack.GeocentricPosition) +} + +// optional double ContactSpeed = 5; +inline bool SimTrack::has_contactspeed() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline void SimTrack::clear_contactspeed() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + _impl_.contactspeed_ = 0; + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline double SimTrack::contactspeed() const { + // @@protoc_insertion_point(field_get:messages.SimTrack.SimTrack.ContactSpeed) + return _internal_contactspeed(); +} +inline void SimTrack::set_contactspeed(double value) { + _internal_set_contactspeed(value); + // @@protoc_insertion_point(field_set:messages.SimTrack.SimTrack.ContactSpeed) +} +inline double SimTrack::_internal_contactspeed() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.contactspeed_; +} +inline void SimTrack::_internal_set_contactspeed(double value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.contactspeed_ = value; +} + +// optional double ContactCourse = 6; +inline bool SimTrack::has_contactcourse() const { + bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0; + return value; +} +inline void SimTrack::clear_contactcourse() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + _impl_.contactcourse_ = 0; + _impl_._has_bits_[0] &= ~0x00000020u; +} +inline double SimTrack::contactcourse() const { + // @@protoc_insertion_point(field_get:messages.SimTrack.SimTrack.ContactCourse) + return _internal_contactcourse(); +} +inline void SimTrack::set_contactcourse(double value) { + _internal_set_contactcourse(value); + // @@protoc_insertion_point(field_set:messages.SimTrack.SimTrack.ContactCourse) +} +inline double SimTrack::_internal_contactcourse() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.contactcourse_; +} +inline void SimTrack::_internal_set_contactcourse(double value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + _impl_._has_bits_[0] |= 0x00000020u; + _impl_.contactcourse_ = value; +} + +// optional double ConactPitch = 7; +inline bool SimTrack::has_conactpitch() const { + bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0; + return value; +} +inline void SimTrack::clear_conactpitch() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + _impl_.conactpitch_ = 0; + _impl_._has_bits_[0] &= ~0x00000040u; +} +inline double SimTrack::conactpitch() const { + // @@protoc_insertion_point(field_get:messages.SimTrack.SimTrack.ConactPitch) + return _internal_conactpitch(); +} +inline void SimTrack::set_conactpitch(double value) { + _internal_set_conactpitch(value); + // @@protoc_insertion_point(field_set:messages.SimTrack.SimTrack.ConactPitch) +} +inline double SimTrack::_internal_conactpitch() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.conactpitch_; +} +inline void SimTrack::_internal_set_conactpitch(double value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + _impl_._has_bits_[0] |= 0x00000040u; + _impl_.conactpitch_ = value; +} + +// optional uint32 ContactKind = 8; +inline bool SimTrack::has_contactkind() const { + bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; + return value; +} +inline void SimTrack::clear_contactkind() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + _impl_.contactkind_ = 0u; + _impl_._has_bits_[0] &= ~0x00000010u; +} +inline ::uint32_t SimTrack::contactkind() const { + // @@protoc_insertion_point(field_get:messages.SimTrack.SimTrack.ContactKind) + return _internal_contactkind(); +} +inline void SimTrack::set_contactkind(::uint32_t value) { + _internal_set_contactkind(value); + // @@protoc_insertion_point(field_set:messages.SimTrack.SimTrack.ContactKind) +} +inline ::uint32_t SimTrack::_internal_contactkind() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.contactkind_; +} +inline void SimTrack::_internal_set_contactkind(::uint32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + _impl_._has_bits_[0] |= 0x00000010u; + _impl_.contactkind_ = value; +} + +// optional uint32 ContactSide = 9; +inline bool SimTrack::has_contactside() const { + bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0; + return value; +} +inline void SimTrack::clear_contactside() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + _impl_.contactside_ = 0u; + _impl_._has_bits_[0] &= ~0x00000100u; +} +inline ::uint32_t SimTrack::contactside() const { + // @@protoc_insertion_point(field_get:messages.SimTrack.SimTrack.ContactSide) + return _internal_contactside(); +} +inline void SimTrack::set_contactside(::uint32_t value) { + _internal_set_contactside(value); + // @@protoc_insertion_point(field_set:messages.SimTrack.SimTrack.ContactSide) +} +inline ::uint32_t SimTrack::_internal_contactside() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.contactside_; +} +inline void SimTrack::_internal_set_contactside(::uint32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + _impl_._has_bits_[0] |= 0x00000100u; + _impl_.contactside_ = value; +} + +// optional double ContactRCS = 10; +inline bool SimTrack::has_contactrcs() const { + bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0; + return value; +} +inline void SimTrack::clear_contactrcs() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + _impl_.contactrcs_ = 0; + _impl_._has_bits_[0] &= ~0x00000080u; +} +inline double SimTrack::contactrcs() const { + // @@protoc_insertion_point(field_get:messages.SimTrack.SimTrack.ContactRCS) + return _internal_contactrcs(); +} +inline void SimTrack::set_contactrcs(double value) { + _internal_set_contactrcs(value); + // @@protoc_insertion_point(field_set:messages.SimTrack.SimTrack.ContactRCS) +} +inline double SimTrack::_internal_contactrcs() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.contactrcs_; +} +inline void SimTrack::_internal_set_contactrcs(double value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + _impl_._has_bits_[0] |= 0x00000080u; + _impl_.contactrcs_ = value; +} + +// repeated .messages.SimTrack.Emission ContactEmissions = 11; +inline int SimTrack::_internal_contactemissions_size() const { + return _internal_contactemissions().size(); +} +inline int SimTrack::contactemissions_size() const { + return _internal_contactemissions_size(); +} +inline void SimTrack::clear_contactemissions() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + _impl_.contactemissions_.Clear(); +} +inline ::messages::SimTrack::Emission* SimTrack::mutable_contactemissions(int index) + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_mutable:messages.SimTrack.SimTrack.ContactEmissions) + return _internal_mutable_contactemissions()->Mutable(index); +} +inline ::google::protobuf::RepeatedPtrField<::messages::SimTrack::Emission>* SimTrack::mutable_contactemissions() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_mutable_list:messages.SimTrack.SimTrack.ContactEmissions) + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + return _internal_mutable_contactemissions(); +} +inline const ::messages::SimTrack::Emission& SimTrack::contactemissions(int index) const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:messages.SimTrack.SimTrack.ContactEmissions) + return _internal_contactemissions().Get(index); +} +inline ::messages::SimTrack::Emission* SimTrack::add_contactemissions() ABSL_ATTRIBUTE_LIFETIME_BOUND { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ::messages::SimTrack::Emission* _add = _internal_mutable_contactemissions()->Add(); + // @@protoc_insertion_point(field_add:messages.SimTrack.SimTrack.ContactEmissions) + return _add; +} +inline const ::google::protobuf::RepeatedPtrField<::messages::SimTrack::Emission>& SimTrack::contactemissions() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_list:messages.SimTrack.SimTrack.ContactEmissions) + return _internal_contactemissions(); +} +inline const ::google::protobuf::RepeatedPtrField<::messages::SimTrack::Emission>& +SimTrack::_internal_contactemissions() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.contactemissions_; +} +inline ::google::protobuf::RepeatedPtrField<::messages::SimTrack::Emission>* +SimTrack::_internal_mutable_contactemissions() { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return &_impl_.contactemissions_; +} + +// ------------------------------------------------------------------- + +// Emission + +// .messages.track.Identifier Identifier = 1; +inline bool Emission::has_identifier() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || _impl_.identifier_ != nullptr); + return value; +} +inline const ::messages::track::Identifier& Emission::_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& Emission::identifier() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:messages.SimTrack.Emission.Identifier) + return _internal_identifier(); +} +inline void Emission::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.SimTrack.Emission.Identifier) +} +inline ::messages::track::Identifier* Emission::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* Emission::unsafe_arena_release_identifier() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + // @@protoc_insertion_point(field_release:messages.SimTrack.Emission.Identifier) + + _impl_._has_bits_[0] &= ~0x00000001u; + ::messages::track::Identifier* temp = _impl_.identifier_; + _impl_.identifier_ = nullptr; + return temp; +} +inline ::messages::track::Identifier* Emission::_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* Emission::mutable_identifier() ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::messages::track::Identifier* _msg = _internal_mutable_identifier(); + // @@protoc_insertion_point(field_mutable:messages.SimTrack.Emission.Identifier) + return _msg; +} +inline void Emission::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.SimTrack.Emission.Identifier) +} + +// string name = 2; +inline void Emission::clear_name() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + _impl_.name_.ClearToEmpty(); +} +inline const std::string& Emission::name() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:messages.SimTrack.Emission.name) + return _internal_name(); +} +template +inline PROTOBUF_ALWAYS_INLINE void Emission::set_name(Arg_&& arg, + Args_... args) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.name_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:messages.SimTrack.Emission.name) +} +inline std::string* Emission::mutable_name() ABSL_ATTRIBUTE_LIFETIME_BOUND { + std::string* _s = _internal_mutable_name(); + // @@protoc_insertion_point(field_mutable:messages.SimTrack.Emission.name) + return _s; +} +inline const std::string& Emission::_internal_name() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.name_.Get(); +} +inline void Emission::_internal_set_name(const std::string& value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.name_.Set(value, GetArena()); +} +inline std::string* Emission::_internal_mutable_name() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + return _impl_.name_.Mutable( GetArena()); +} +inline std::string* Emission::release_name() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + // @@protoc_insertion_point(field_release:messages.SimTrack.Emission.name) + return _impl_.name_.Release(); +} +inline void Emission::set_allocated_name(std::string* value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + _impl_.name_.SetAllocated(value, GetArena()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.name_.IsDefault()) { + _impl_.name_.Set("", GetArena()); + } + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:messages.SimTrack.Emission.name) +} + +// double frequency = 3; +inline void Emission::clear_frequency() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + _impl_.frequency_ = 0; +} +inline double Emission::frequency() const { + // @@protoc_insertion_point(field_get:messages.SimTrack.Emission.frequency) + return _internal_frequency(); +} +inline void Emission::set_frequency(double value) { + _internal_set_frequency(value); + // @@protoc_insertion_point(field_set:messages.SimTrack.Emission.frequency) +} +inline double Emission::_internal_frequency() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.frequency_; +} +inline void Emission::_internal_set_frequency(double value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.frequency_ = value; +} + +// double Range = 4; +inline void Emission::clear_range() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + _impl_.range_ = 0; +} +inline double Emission::range() const { + // @@protoc_insertion_point(field_get:messages.SimTrack.Emission.Range) + return _internal_range(); +} +inline void Emission::set_range(double value) { + _internal_set_range(value); + // @@protoc_insertion_point(field_set:messages.SimTrack.Emission.Range) +} +inline double Emission::_internal_range() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.range_; +} +inline void Emission::_internal_set_range(double value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + ; + _impl_.range_ = value; +} + +// optional uint32 Bandwidth = 5; +inline bool Emission::has_bandwidth() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline void Emission::clear_bandwidth() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + _impl_.bandwidth_ = 0u; + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline ::uint32_t Emission::bandwidth() const { + // @@protoc_insertion_point(field_get:messages.SimTrack.Emission.Bandwidth) + return _internal_bandwidth(); +} +inline void Emission::set_bandwidth(::uint32_t value) { + _internal_set_bandwidth(value); + // @@protoc_insertion_point(field_set:messages.SimTrack.Emission.Bandwidth) +} +inline ::uint32_t Emission::_internal_bandwidth() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.bandwidth_; +} +inline void Emission::_internal_set_bandwidth(::uint32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.bandwidth_ = value; +} + +// optional uint32 pulseWidth = 6; +inline bool Emission::has_pulsewidth() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline void Emission::clear_pulsewidth() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + _impl_.pulsewidth_ = 0u; + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline ::uint32_t Emission::pulsewidth() const { + // @@protoc_insertion_point(field_get:messages.SimTrack.Emission.pulseWidth) + return _internal_pulsewidth(); +} +inline void Emission::set_pulsewidth(::uint32_t value) { + _internal_set_pulsewidth(value); + // @@protoc_insertion_point(field_set:messages.SimTrack.Emission.pulseWidth) +} +inline ::uint32_t Emission::_internal_pulsewidth() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.pulsewidth_; +} +inline void Emission::_internal_set_pulsewidth(::uint32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.pulsewidth_ = value; +} + +// optional uint32 pulseRepitition = 7; +inline bool Emission::has_pulserepitition() const { + bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline void Emission::clear_pulserepitition() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + _impl_.pulserepitition_ = 0u; + _impl_._has_bits_[0] &= ~0x00000008u; +} +inline ::uint32_t Emission::pulserepitition() const { + // @@protoc_insertion_point(field_get:messages.SimTrack.Emission.pulseRepitition) + return _internal_pulserepitition(); +} +inline void Emission::set_pulserepitition(::uint32_t value) { + _internal_set_pulserepitition(value); + // @@protoc_insertion_point(field_set:messages.SimTrack.Emission.pulseRepitition) +} +inline ::uint32_t Emission::_internal_pulserepitition() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.pulserepitition_; +} +inline void Emission::_internal_set_pulserepitition(::uint32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + _impl_._has_bits_[0] |= 0x00000008u; + _impl_.pulserepitition_ = value; +} + +// optional uint32 radiatedPower = 8; +inline bool Emission::has_radiatedpower() const { + bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; + return value; +} +inline void Emission::clear_radiatedpower() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + _impl_.radiatedpower_ = 0u; + _impl_._has_bits_[0] &= ~0x00000010u; +} +inline ::uint32_t Emission::radiatedpower() const { + // @@protoc_insertion_point(field_get:messages.SimTrack.Emission.radiatedPower) + return _internal_radiatedpower(); +} +inline void Emission::set_radiatedpower(::uint32_t value) { + _internal_set_radiatedpower(value); + // @@protoc_insertion_point(field_set:messages.SimTrack.Emission.radiatedPower) +} +inline ::uint32_t Emission::_internal_radiatedpower() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.radiatedpower_; +} +inline void Emission::_internal_set_radiatedpower(::uint32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + _impl_._has_bits_[0] |= 0x00000010u; + _impl_.radiatedpower_ = value; +} + +// optional uint32 numberOfBeams = 9; +inline bool Emission::has_numberofbeams() const { + bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0; + return value; +} +inline void Emission::clear_numberofbeams() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + _impl_.numberofbeams_ = 0u; + _impl_._has_bits_[0] &= ~0x00000020u; +} +inline ::uint32_t Emission::numberofbeams() const { + // @@protoc_insertion_point(field_get:messages.SimTrack.Emission.numberOfBeams) + return _internal_numberofbeams(); +} +inline void Emission::set_numberofbeams(::uint32_t value) { + _internal_set_numberofbeams(value); + // @@protoc_insertion_point(field_set:messages.SimTrack.Emission.numberOfBeams) +} +inline ::uint32_t Emission::_internal_numberofbeams() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.numberofbeams_; +} +inline void Emission::_internal_set_numberofbeams(::uint32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + _impl_._has_bits_[0] |= 0x00000020u; + _impl_.numberofbeams_ = value; +} + +// optional uint32 searchInterval = 10; +inline bool Emission::has_searchinterval() const { + bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0; + return value; +} +inline void Emission::clear_searchinterval() { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + _impl_.searchinterval_ = 0u; + _impl_._has_bits_[0] &= ~0x00000040u; +} +inline ::uint32_t Emission::searchinterval() const { + // @@protoc_insertion_point(field_get:messages.SimTrack.Emission.searchInterval) + return _internal_searchinterval(); +} +inline void Emission::set_searchinterval(::uint32_t value) { + _internal_set_searchinterval(value); + // @@protoc_insertion_point(field_set:messages.SimTrack.Emission.searchInterval) +} +inline ::uint32_t Emission::_internal_searchinterval() const { + PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race); + return _impl_.searchinterval_; +} +inline void Emission::_internal_set_searchinterval(::uint32_t value) { + PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race); + _impl_._has_bits_[0] |= 0x00000040u; + _impl_.searchinterval_ = value; +} + +#ifdef __GNUC__ +#pragma GCC diagnostic pop +#endif // __GNUC__ + +// @@protoc_insertion_point(namespace_scope) +} // namespace SimTrack +} // namespace messages + + +// @@protoc_insertion_point(global_scope) + +#include "google/protobuf/port_undef.inc" + +#endif // GOOGLE_PROTOBUF_INCLUDED_SimTrack_2eproto_2epb_2eh