From dae304baec37093110f49e79d39cd309701bf26f Mon Sep 17 00:00:00 2001 From: Henry Winkel Date: Wed, 27 Sep 2023 16:18:30 +0200 Subject: [PATCH] FIX: fixed gitignore file --- .gitignore | 2 - include/SimCore/Messages/Protos/Control.pb.cc | 432 ++++++++++++++++ include/SimCore/Messages/Protos/Control.pb.h | 467 ++++++++++++++++++ 3 files changed, 899 insertions(+), 2 deletions(-) create mode 100644 include/SimCore/Messages/Protos/Control.pb.cc create mode 100644 include/SimCore/Messages/Protos/Control.pb.h diff --git a/.gitignore b/.gitignore index 31f3ddb..4e7bf47 100644 --- a/.gitignore +++ b/.gitignore @@ -1,4 +1,2 @@ build/ .cache -*.pb.cc -*.pb.h \ No newline at end of file diff --git a/include/SimCore/Messages/Protos/Control.pb.cc b/include/SimCore/Messages/Protos/Control.pb.cc new file mode 100644 index 0000000..087eba0 --- /dev/null +++ b/include/SimCore/Messages/Protos/Control.pb.cc @@ -0,0 +1,432 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: Control.proto + +#include "Control.pb.h" + +#include + +#include +#include +#include +#include +#include +#include +#include +// @@protoc_insertion_point(includes) +#include + +PROTOBUF_PRAGMA_INIT_SEG + +namespace _pb = ::PROTOBUF_NAMESPACE_ID; +namespace _pbi = _pb::internal; + +namespace messages { +namespace control { +PROTOBUF_CONSTEXPR control::control( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.data_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.identifier_)*/nullptr + , /*decltype(_impl_.timestamp_)*/uint64_t{0u} + , /*decltype(_impl_.type_)*/0u} {} +struct controlDefaultTypeInternal { + PROTOBUF_CONSTEXPR controlDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~controlDefaultTypeInternal() {} + union { + control _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 controlDefaultTypeInternal _control_default_instance_; +} // namespace control +} // namespace messages +static ::_pb::Metadata file_level_metadata_Control_2eproto[1]; +static constexpr ::_pb::EnumDescriptor const** file_level_enum_descriptors_Control_2eproto = nullptr; +static constexpr ::_pb::ServiceDescriptor const** file_level_service_descriptors_Control_2eproto = nullptr; + +const uint32_t TableStruct_Control_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { + PROTOBUF_FIELD_OFFSET(::messages::control::control, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::messages::control::control, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::messages::control::control, _impl_.identifier_), + PROTOBUF_FIELD_OFFSET(::messages::control::control, _impl_.type_), + PROTOBUF_FIELD_OFFSET(::messages::control::control, _impl_.data_), + PROTOBUF_FIELD_OFFSET(::messages::control::control, _impl_.timestamp_), + ~0u, + ~0u, + ~0u, + 0, +}; +static const ::_pbi::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { + { 0, 10, -1, sizeof(::messages::control::control)}, +}; + +static const ::_pb::Message* const file_default_instances[] = { + &::messages::control::_control_default_instance_._instance, +}; + +const char descriptor_table_protodef_Control_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = + "\n\rControl.proto\022\020messages.control\032\020Ident" + "ifier.proto\"{\n\007control\022.\n\nIdentifier\030\001 \001" + "(\0132\032.messages.track.Identifier\022\014\n\004type\030\002" + " \001(\r\022\014\n\004data\030\003 \001(\t\022\026\n\ttimestamp\030\004 \001(\004H\000\210" + "\001\001B\014\n\n_timestampb\006proto3" + ; +static const ::_pbi::DescriptorTable* const descriptor_table_Control_2eproto_deps[1] = { + &::descriptor_table_Identifier_2eproto, +}; +static ::_pbi::once_flag descriptor_table_Control_2eproto_once; +const ::_pbi::DescriptorTable descriptor_table_Control_2eproto = { + false, false, 184, descriptor_table_protodef_Control_2eproto, + "Control.proto", + &descriptor_table_Control_2eproto_once, descriptor_table_Control_2eproto_deps, 1, 1, + schemas, file_default_instances, TableStruct_Control_2eproto::offsets, + file_level_metadata_Control_2eproto, file_level_enum_descriptors_Control_2eproto, + file_level_service_descriptors_Control_2eproto, +}; +PROTOBUF_ATTRIBUTE_WEAK const ::_pbi::DescriptorTable* descriptor_table_Control_2eproto_getter() { + return &descriptor_table_Control_2eproto; +} + +// Force running AddDescriptors() at dynamic initialization time. +PROTOBUF_ATTRIBUTE_INIT_PRIORITY2 static ::_pbi::AddDescriptorsRunner dynamic_init_dummy_Control_2eproto(&descriptor_table_Control_2eproto); +namespace messages { +namespace control { + +// =================================================================== + +class control::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static const ::messages::track::Identifier& identifier(const control* msg); + static void set_has_timestamp(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +const ::messages::track::Identifier& +control::_Internal::identifier(const control* msg) { + return *msg->_impl_.identifier_; +} +void control::clear_identifier() { + if (GetArenaForAllocation() == nullptr && _impl_.identifier_ != nullptr) { + delete _impl_.identifier_; + } + _impl_.identifier_ = nullptr; +} +control::control(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:messages.control.control) +} +control::control(const control& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + control* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.data_){} + , decltype(_impl_.identifier_){nullptr} + , decltype(_impl_.timestamp_){} + , decltype(_impl_.type_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.data_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.data_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (!from._internal_data().empty()) { + _this->_impl_.data_.Set(from._internal_data(), + _this->GetArenaForAllocation()); + } + if (from._internal_has_identifier()) { + _this->_impl_.identifier_ = new ::messages::track::Identifier(*from._impl_.identifier_); + } + ::memcpy(&_impl_.timestamp_, &from._impl_.timestamp_, + static_cast(reinterpret_cast(&_impl_.type_) - + reinterpret_cast(&_impl_.timestamp_)) + sizeof(_impl_.type_)); + // @@protoc_insertion_point(copy_constructor:messages.control.control) +} + +inline void control::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.data_){} + , decltype(_impl_.identifier_){nullptr} + , decltype(_impl_.timestamp_){uint64_t{0u}} + , decltype(_impl_.type_){0u} + }; + _impl_.data_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.data_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +control::~control() { + // @@protoc_insertion_point(destructor:messages.control.control) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void control::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.data_.Destroy(); + if (this != internal_default_instance()) delete _impl_.identifier_; +} + +void control::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void control::Clear() { +// @@protoc_insertion_point(message_clear_start:messages.control.control) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.data_.ClearToEmpty(); + if (GetArenaForAllocation() == nullptr && _impl_.identifier_ != nullptr) { + delete _impl_.identifier_; + } + _impl_.identifier_ = nullptr; + _impl_.timestamp_ = uint64_t{0u}; + _impl_.type_ = 0u; + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* control::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .messages.track.Identifier Identifier = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_identifier(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // uint32 type = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + _impl_.type_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // string data = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + auto str = _internal_mutable_data(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + CHK_(::_pbi::VerifyUTF8(str, "messages.control.control.data")); + } else + goto handle_unusual; + continue; + // optional uint64 timestamp = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { + _Internal::set_has_timestamp(&has_bits); + _impl_.timestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* control::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:messages.control.control) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + // .messages.track.Identifier Identifier = 1; + if (this->_internal_has_identifier()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, _Internal::identifier(this), + _Internal::identifier(this).GetCachedSize(), target, stream); + } + + // uint32 type = 2; + if (this->_internal_type() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray(2, this->_internal_type(), target); + } + + // string data = 3; + if (!this->_internal_data().empty()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->_internal_data().data(), static_cast(this->_internal_data().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "messages.control.control.data"); + target = stream->WriteStringMaybeAliased( + 3, this->_internal_data(), target); + } + + // optional uint64 timestamp = 4; + if (_internal_has_timestamp()) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt64ToArray(4, this->_internal_timestamp(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:messages.control.control) + return target; +} + +size_t control::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:messages.control.control) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // string data = 3; + if (!this->_internal_data().empty()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_data()); + } + + // .messages.track.Identifier Identifier = 1; + if (this->_internal_has_identifier()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.identifier_); + } + + // optional uint64 timestamp = 4; + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_timestamp()); + } + + // uint32 type = 2; + if (this->_internal_type() != 0) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_type()); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData control::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + control::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*control::GetClassData() const { return &_class_data_; } + + +void control::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:messages.control.control) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (!from._internal_data().empty()) { + _this->_internal_set_data(from._internal_data()); + } + if (from._internal_has_identifier()) { + _this->_internal_mutable_identifier()->::messages::track::Identifier::MergeFrom( + from._internal_identifier()); + } + if (from._internal_has_timestamp()) { + _this->_internal_set_timestamp(from._internal_timestamp()); + } + if (from._internal_type() != 0) { + _this->_internal_set_type(from._internal_type()); + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void control::CopyFrom(const control& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:messages.control.control) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool control::IsInitialized() const { + return true; +} + +void control::InternalSwap(control* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.data_, lhs_arena, + &other->_impl_.data_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(control, _impl_.type_) + + sizeof(control::_impl_.type_) + - PROTOBUF_FIELD_OFFSET(control, _impl_.identifier_)>( + reinterpret_cast(&_impl_.identifier_), + reinterpret_cast(&other->_impl_.identifier_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata control::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_Control_2eproto_getter, &descriptor_table_Control_2eproto_once, + file_level_metadata_Control_2eproto[0]); +} + +// @@protoc_insertion_point(namespace_scope) +} // namespace control +} // namespace messages +PROTOBUF_NAMESPACE_OPEN +template<> PROTOBUF_NOINLINE ::messages::control::control* +Arena::CreateMaybeMessage< ::messages::control::control >(Arena* arena) { + return Arena::CreateMessageInternal< ::messages::control::control >(arena); +} +PROTOBUF_NAMESPACE_CLOSE + +// @@protoc_insertion_point(global_scope) +#include diff --git a/include/SimCore/Messages/Protos/Control.pb.h b/include/SimCore/Messages/Protos/Control.pb.h new file mode 100644 index 0000000..1389676 --- /dev/null +++ b/include/SimCore/Messages/Protos/Control.pb.h @@ -0,0 +1,467 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: Control.proto + +#ifndef GOOGLE_PROTOBUF_INCLUDED_Control_2eproto +#define GOOGLE_PROTOBUF_INCLUDED_Control_2eproto + +#include +#include + +#include +#if PROTOBUF_VERSION < 3021000 +#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 +#if 3021012 < 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 + +#include +#include +#include +#include +#include +#include +#include +#include +#include // IWYU pragma: export +#include // IWYU pragma: export +#include +#include "Identifier.pb.h" +// @@protoc_insertion_point(includes) +#include +#define PROTOBUF_INTERNAL_EXPORT_Control_2eproto +PROTOBUF_NAMESPACE_OPEN +namespace internal { +class AnyMetadata; +} // namespace internal +PROTOBUF_NAMESPACE_CLOSE + +// Internal implementation detail -- do not use these members. +struct TableStruct_Control_2eproto { + static const uint32_t offsets[]; +}; +extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_Control_2eproto; +namespace messages { +namespace control { +class control; +struct controlDefaultTypeInternal; +extern controlDefaultTypeInternal _control_default_instance_; +} // namespace control +} // namespace messages +PROTOBUF_NAMESPACE_OPEN +template<> ::messages::control::control* Arena::CreateMaybeMessage<::messages::control::control>(Arena*); +PROTOBUF_NAMESPACE_CLOSE +namespace messages { +namespace control { + +// =================================================================== + +class control final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:messages.control.control) */ { + public: + inline control() : control(nullptr) {} + ~control() override; + explicit PROTOBUF_CONSTEXPR control(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + control(const control& from); + control(control&& from) noexcept + : control() { + *this = ::std::move(from); + } + + inline control& operator=(const control& from) { + CopyFrom(from); + return *this; + } + inline control& operator=(control&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const control& default_instance() { + return *internal_default_instance(); + } + static inline const control* internal_default_instance() { + return reinterpret_cast( + &_control_default_instance_); + } + static constexpr int kIndexInFileMessages = + 0; + + friend void swap(control& a, control& b) { + a.Swap(&b); + } + inline void Swap(control* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(control* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + control* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const control& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const control& from) { + control::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(control* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "messages.control.control"; + } + protected: + explicit control(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kDataFieldNumber = 3, + kIdentifierFieldNumber = 1, + kTimestampFieldNumber = 4, + kTypeFieldNumber = 2, + }; + // string data = 3; + void clear_data(); + const std::string& data() const; + template + void set_data(ArgT0&& arg0, ArgT... args); + std::string* mutable_data(); + PROTOBUF_NODISCARD std::string* release_data(); + void set_allocated_data(std::string* data); + private: + const std::string& _internal_data() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_data(const std::string& value); + std::string* _internal_mutable_data(); + public: + + // .messages.track.Identifier Identifier = 1; + bool has_identifier() const; + private: + bool _internal_has_identifier() const; + public: + 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* identifier); + private: + const ::messages::track::Identifier& _internal_identifier() const; + ::messages::track::Identifier* _internal_mutable_identifier(); + public: + void unsafe_arena_set_allocated_identifier( + ::messages::track::Identifier* identifier); + ::messages::track::Identifier* unsafe_arena_release_identifier(); + + // optional uint64 timestamp = 4; + bool has_timestamp() const; + private: + bool _internal_has_timestamp() const; + public: + void clear_timestamp(); + uint64_t timestamp() const; + void set_timestamp(uint64_t value); + private: + uint64_t _internal_timestamp() const; + void _internal_set_timestamp(uint64_t value); + public: + + // uint32 type = 2; + void clear_type(); + uint32_t type() const; + void set_type(uint32_t value); + private: + uint32_t _internal_type() const; + void _internal_set_type(uint32_t value); + public: + + // @@protoc_insertion_point(class_scope:messages.control.control) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr data_; + ::messages::track::Identifier* identifier_; + uint64_t timestamp_; + uint32_t type_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_Control_2eproto; +}; +// =================================================================== + + +// =================================================================== + +#ifdef __GNUC__ + #pragma GCC diagnostic push + #pragma GCC diagnostic ignored "-Wstrict-aliasing" +#endif // __GNUC__ +// control + +// .messages.track.Identifier Identifier = 1; +inline bool control::_internal_has_identifier() const { + return this != internal_default_instance() && _impl_.identifier_ != nullptr; +} +inline bool control::has_identifier() const { + return _internal_has_identifier(); +} +inline const ::messages::track::Identifier& control::_internal_identifier() const { + const ::messages::track::Identifier* p = _impl_.identifier_; + return p != nullptr ? *p : reinterpret_cast( + ::messages::track::_Identifier_default_instance_); +} +inline const ::messages::track::Identifier& control::identifier() const { + // @@protoc_insertion_point(field_get:messages.control.control.Identifier) + return _internal_identifier(); +} +inline void control::unsafe_arena_set_allocated_identifier( + ::messages::track::Identifier* identifier) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.identifier_); + } + _impl_.identifier_ = identifier; + if (identifier) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:messages.control.control.Identifier) +} +inline ::messages::track::Identifier* control::release_identifier() { + + ::messages::track::Identifier* temp = _impl_.identifier_; + _impl_.identifier_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::messages::track::Identifier* control::unsafe_arena_release_identifier() { + // @@protoc_insertion_point(field_release:messages.control.control.Identifier) + + ::messages::track::Identifier* temp = _impl_.identifier_; + _impl_.identifier_ = nullptr; + return temp; +} +inline ::messages::track::Identifier* control::_internal_mutable_identifier() { + + if (_impl_.identifier_ == nullptr) { + auto* p = CreateMaybeMessage<::messages::track::Identifier>(GetArenaForAllocation()); + _impl_.identifier_ = p; + } + return _impl_.identifier_; +} +inline ::messages::track::Identifier* control::mutable_identifier() { + ::messages::track::Identifier* _msg = _internal_mutable_identifier(); + // @@protoc_insertion_point(field_mutable:messages.control.control.Identifier) + return _msg; +} +inline void control::set_allocated_identifier(::messages::track::Identifier* identifier) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.identifier_); + } + if (identifier) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena( + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(identifier)); + if (message_arena != submessage_arena) { + identifier = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, identifier, submessage_arena); + } + + } else { + + } + _impl_.identifier_ = identifier; + // @@protoc_insertion_point(field_set_allocated:messages.control.control.Identifier) +} + +// uint32 type = 2; +inline void control::clear_type() { + _impl_.type_ = 0u; +} +inline uint32_t control::_internal_type() const { + return _impl_.type_; +} +inline uint32_t control::type() const { + // @@protoc_insertion_point(field_get:messages.control.control.type) + return _internal_type(); +} +inline void control::_internal_set_type(uint32_t value) { + + _impl_.type_ = value; +} +inline void control::set_type(uint32_t value) { + _internal_set_type(value); + // @@protoc_insertion_point(field_set:messages.control.control.type) +} + +// string data = 3; +inline void control::clear_data() { + _impl_.data_.ClearToEmpty(); +} +inline const std::string& control::data() const { + // @@protoc_insertion_point(field_get:messages.control.control.data) + return _internal_data(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void control::set_data(ArgT0&& arg0, ArgT... args) { + + _impl_.data_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:messages.control.control.data) +} +inline std::string* control::mutable_data() { + std::string* _s = _internal_mutable_data(); + // @@protoc_insertion_point(field_mutable:messages.control.control.data) + return _s; +} +inline const std::string& control::_internal_data() const { + return _impl_.data_.Get(); +} +inline void control::_internal_set_data(const std::string& value) { + + _impl_.data_.Set(value, GetArenaForAllocation()); +} +inline std::string* control::_internal_mutable_data() { + + return _impl_.data_.Mutable(GetArenaForAllocation()); +} +inline std::string* control::release_data() { + // @@protoc_insertion_point(field_release:messages.control.control.data) + return _impl_.data_.Release(); +} +inline void control::set_allocated_data(std::string* data) { + if (data != nullptr) { + + } else { + + } + _impl_.data_.SetAllocated(data, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.data_.IsDefault()) { + _impl_.data_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:messages.control.control.data) +} + +// optional uint64 timestamp = 4; +inline bool control::_internal_has_timestamp() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool control::has_timestamp() const { + return _internal_has_timestamp(); +} +inline void control::clear_timestamp() { + _impl_.timestamp_ = uint64_t{0u}; + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline uint64_t control::_internal_timestamp() const { + return _impl_.timestamp_; +} +inline uint64_t control::timestamp() const { + // @@protoc_insertion_point(field_get:messages.control.control.timestamp) + return _internal_timestamp(); +} +inline void control::_internal_set_timestamp(uint64_t value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.timestamp_ = value; +} +inline void control::set_timestamp(uint64_t value) { + _internal_set_timestamp(value); + // @@protoc_insertion_point(field_set:messages.control.control.timestamp) +} + +#ifdef __GNUC__ + #pragma GCC diagnostic pop +#endif // __GNUC__ + +// @@protoc_insertion_point(namespace_scope) + +} // namespace control +} // namespace messages + +// @@protoc_insertion_point(global_scope) + +#include +#endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_Control_2eproto