diff options
Diffstat (limited to 'bin/main/messages/VehicleMessageHeader.pb.cc')
| -rw-r--r-- | bin/main/messages/VehicleMessageHeader.pb.cc | 827 |
1 files changed, 827 insertions, 0 deletions
diff --git a/bin/main/messages/VehicleMessageHeader.pb.cc b/bin/main/messages/VehicleMessageHeader.pb.cc new file mode 100644 index 0000000..8569ef4 --- /dev/null +++ b/bin/main/messages/VehicleMessageHeader.pb.cc @@ -0,0 +1,827 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: messages/VehicleMessageHeader.proto + +#include "messages/VehicleMessageHeader.pb.h" + +#include <algorithm> +#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" +// @@protoc_insertion_point(includes) + +// Must be included last. +#include "google/protobuf/port_def.inc" +PROTOBUF_PRAGMA_INIT_SEG +namespace _pb = ::PROTOBUF_NAMESPACE_ID; +namespace _pbi = ::PROTOBUF_NAMESPACE_ID::internal; +namespace messages { +PROTOBUF_CONSTEXPR VehicleMessageHeading::VehicleMessageHeading( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_.vehicle_identity_)*/ { + &::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized {} + } + + , /*decltype(_impl_.vehicle_device_id_)*/ { + &::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized {} + } + + , /*decltype(_impl_.location_)*/nullptr + , /*decltype(_impl_.message_id_)*/ 0 + + , /*decltype(_impl_.correlation_id_)*/ 0 + + , /*decltype(_impl_.message_timestamp_)*/ ::int64_t{0} + + , /*decltype(_impl_.protocol_version_)*/ 0 + + , /*decltype(_impl_._cached_size_)*/{}} {} +struct VehicleMessageHeadingDefaultTypeInternal { + PROTOBUF_CONSTEXPR VehicleMessageHeadingDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~VehicleMessageHeadingDefaultTypeInternal() {} + union { + VehicleMessageHeading _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 VehicleMessageHeadingDefaultTypeInternal _VehicleMessageHeading_default_instance_; +PROTOBUF_CONSTEXPR lat_long::lat_long( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_.latitude_)*/ 0 + + , /*decltype(_impl_.longitude_)*/ 0 + + , /*decltype(_impl_._cached_size_)*/{}} {} +struct lat_longDefaultTypeInternal { + PROTOBUF_CONSTEXPR lat_longDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~lat_longDefaultTypeInternal() {} + union { + lat_long _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 lat_longDefaultTypeInternal _lat_long_default_instance_; +} // namespace messages +static ::_pb::Metadata file_level_metadata_messages_2fVehicleMessageHeader_2eproto[2]; +static constexpr const ::_pb::EnumDescriptor** + file_level_enum_descriptors_messages_2fVehicleMessageHeader_2eproto = nullptr; +static constexpr const ::_pb::ServiceDescriptor** + file_level_service_descriptors_messages_2fVehicleMessageHeader_2eproto = nullptr; +const ::uint32_t TableStruct_messages_2fVehicleMessageHeader_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE( + protodesc_cold) = { + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::messages::VehicleMessageHeading, _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::VehicleMessageHeading, _impl_.message_id_), + PROTOBUF_FIELD_OFFSET(::messages::VehicleMessageHeading, _impl_.correlation_id_), + PROTOBUF_FIELD_OFFSET(::messages::VehicleMessageHeading, _impl_.vehicle_identity_), + PROTOBUF_FIELD_OFFSET(::messages::VehicleMessageHeading, _impl_.vehicle_device_id_), + PROTOBUF_FIELD_OFFSET(::messages::VehicleMessageHeading, _impl_.message_timestamp_), + PROTOBUF_FIELD_OFFSET(::messages::VehicleMessageHeading, _impl_.protocol_version_), + PROTOBUF_FIELD_OFFSET(::messages::VehicleMessageHeading, _impl_.location_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::messages::lat_long, _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::lat_long, _impl_.latitude_), + PROTOBUF_FIELD_OFFSET(::messages::lat_long, _impl_.longitude_), +}; + +static const ::_pbi::MigrationSchema + schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { + { 0, -1, -1, sizeof(::messages::VehicleMessageHeading)}, + { 15, -1, -1, sizeof(::messages::lat_long)}, +}; + +static const ::_pb::Message* const file_default_instances[] = { + &::messages::_VehicleMessageHeading_default_instance_._instance, + &::messages::_lat_long_default_instance_._instance, +}; +const char descriptor_table_protodef_messages_2fVehicleMessageHeader_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { + "\n#messages/VehicleMessageHeader.proto\022\010m" + "essages\"\323\001\n\025VehicleMessageHeading\022\022\n\nmes" + "sage_id\030\001 \001(\005\022\026\n\016correlation_id\030\002 \001(\005\022\030\n" + "\020vehicle_identity\030\003 \001(\t\022\031\n\021vehicle_devic" + "e_id\030\007 \001(\t\022\031\n\021message_timestamp\030\004 \001(\003\022\030\n" + "\020protocol_version\030\005 \001(\001\022$\n\010location\030\006 \001(" + "\0132\022.messages.lat_long\"/\n\010lat_long\022\020\n\010lat" + "itude\030\001 \001(\001\022\021\n\tlongitude\030\002 \001(\001b\006proto3" +}; +static ::absl::once_flag descriptor_table_messages_2fVehicleMessageHeader_2eproto_once; +const ::_pbi::DescriptorTable descriptor_table_messages_2fVehicleMessageHeader_2eproto = { + false, + false, + 318, + descriptor_table_protodef_messages_2fVehicleMessageHeader_2eproto, + "messages/VehicleMessageHeader.proto", + &descriptor_table_messages_2fVehicleMessageHeader_2eproto_once, + nullptr, + 0, + 2, + schemas, + file_default_instances, + TableStruct_messages_2fVehicleMessageHeader_2eproto::offsets, + file_level_metadata_messages_2fVehicleMessageHeader_2eproto, + file_level_enum_descriptors_messages_2fVehicleMessageHeader_2eproto, + file_level_service_descriptors_messages_2fVehicleMessageHeader_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_messages_2fVehicleMessageHeader_2eproto_getter() { + return &descriptor_table_messages_2fVehicleMessageHeader_2eproto; +} +// Force running AddDescriptors() at dynamic initialization time. +PROTOBUF_ATTRIBUTE_INIT_PRIORITY2 +static ::_pbi::AddDescriptorsRunner dynamic_init_dummy_messages_2fVehicleMessageHeader_2eproto(&descriptor_table_messages_2fVehicleMessageHeader_2eproto); +namespace messages { +// =================================================================== + +class VehicleMessageHeading::_Internal { + public: + static const ::messages::lat_long& location(const VehicleMessageHeading* msg); +}; + +const ::messages::lat_long& +VehicleMessageHeading::_Internal::location(const VehicleMessageHeading* msg) { + return *msg->_impl_.location_; +} +VehicleMessageHeading::VehicleMessageHeading(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:messages.VehicleMessageHeading) +} +VehicleMessageHeading::VehicleMessageHeading(const VehicleMessageHeading& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + VehicleMessageHeading* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_.vehicle_identity_) {} + + , decltype(_impl_.vehicle_device_id_) {} + + , decltype(_impl_.location_){nullptr} + , decltype(_impl_.message_id_) {} + + , decltype(_impl_.correlation_id_) {} + + , decltype(_impl_.message_timestamp_) {} + + , decltype(_impl_.protocol_version_) {} + + , /*decltype(_impl_._cached_size_)*/{}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.vehicle_identity_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.vehicle_identity_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (!from._internal_vehicle_identity().empty()) { + _this->_impl_.vehicle_identity_.Set(from._internal_vehicle_identity(), _this->GetArenaForAllocation()); + } + _impl_.vehicle_device_id_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.vehicle_device_id_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (!from._internal_vehicle_device_id().empty()) { + _this->_impl_.vehicle_device_id_.Set(from._internal_vehicle_device_id(), _this->GetArenaForAllocation()); + } + if (from._internal_has_location()) { + _this->_impl_.location_ = new ::messages::lat_long(*from._impl_.location_); + } + ::memcpy(&_impl_.message_id_, &from._impl_.message_id_, + static_cast<::size_t>(reinterpret_cast<char*>(&_impl_.protocol_version_) - + reinterpret_cast<char*>(&_impl_.message_id_)) + sizeof(_impl_.protocol_version_)); + // @@protoc_insertion_point(copy_constructor:messages.VehicleMessageHeading) +} + +inline void VehicleMessageHeading::SharedCtor(::_pb::Arena* arena) { + (void)arena; + new (&_impl_) Impl_{ + decltype(_impl_.vehicle_identity_) {} + + , decltype(_impl_.vehicle_device_id_) {} + + , decltype(_impl_.location_){nullptr} + , decltype(_impl_.message_id_) { 0 } + + , decltype(_impl_.correlation_id_) { 0 } + + , decltype(_impl_.message_timestamp_) { ::int64_t{0} } + + , decltype(_impl_.protocol_version_) { 0 } + + , /*decltype(_impl_._cached_size_)*/{} + }; + _impl_.vehicle_identity_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.vehicle_identity_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.vehicle_device_id_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.vehicle_device_id_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +VehicleMessageHeading::~VehicleMessageHeading() { + // @@protoc_insertion_point(destructor:messages.VehicleMessageHeading) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void VehicleMessageHeading::SharedDtor() { + ABSL_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.vehicle_identity_.Destroy(); + _impl_.vehicle_device_id_.Destroy(); + if (this != internal_default_instance()) delete _impl_.location_; +} + +void VehicleMessageHeading::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void VehicleMessageHeading::Clear() { +// @@protoc_insertion_point(message_clear_start:messages.VehicleMessageHeading) + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.vehicle_identity_.ClearToEmpty(); + _impl_.vehicle_device_id_.ClearToEmpty(); + if (GetArenaForAllocation() == nullptr && _impl_.location_ != nullptr) { + delete _impl_.location_; + } + _impl_.location_ = nullptr; + ::memset(&_impl_.message_id_, 0, static_cast<::size_t>( + reinterpret_cast<char*>(&_impl_.protocol_version_) - + reinterpret_cast<char*>(&_impl_.message_id_)) + sizeof(_impl_.protocol_version_)); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* VehicleMessageHeading::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // int32 message_id = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) { + _impl_.message_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else { + goto handle_unusual; + } + continue; + // int32 correlation_id = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) { + _impl_.correlation_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else { + goto handle_unusual; + } + continue; + // string vehicle_identity = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) { + auto str = _internal_mutable_vehicle_identity(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + CHK_(::_pbi::VerifyUTF8(str, "messages.VehicleMessageHeading.vehicle_identity")); + } else { + goto handle_unusual; + } + continue; + // int64 message_timestamp = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) { + _impl_.message_timestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else { + goto handle_unusual; + } + continue; + // double protocol_version = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 41)) { + _impl_.protocol_version_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr); + ptr += sizeof(double); + } else { + goto handle_unusual; + } + continue; + // .messages.lat_long location = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 50)) { + ptr = ctx->ParseMessage(_internal_mutable_location(), ptr); + CHK_(ptr); + } else { + goto handle_unusual; + } + continue; + // string vehicle_device_id = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 58)) { + auto str = _internal_mutable_vehicle_device_id(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + CHK_(::_pbi::VerifyUTF8(str, "messages.VehicleMessageHeading.vehicle_device_id")); + } 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: + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +::uint8_t* VehicleMessageHeading::_InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:messages.VehicleMessageHeading) + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + // int32 message_id = 1; + if (this->_internal_message_id() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt32ToArray( + 1, this->_internal_message_id(), target); + } + + // int32 correlation_id = 2; + if (this->_internal_correlation_id() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt32ToArray( + 2, this->_internal_correlation_id(), target); + } + + // string vehicle_identity = 3; + if (!this->_internal_vehicle_identity().empty()) { + const std::string& _s = this->_internal_vehicle_identity(); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast<int>(_s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "messages.VehicleMessageHeading.vehicle_identity"); + target = stream->WriteStringMaybeAliased(3, _s, target); + } + + // int64 message_timestamp = 4; + if (this->_internal_message_timestamp() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt64ToArray( + 4, this->_internal_message_timestamp(), target); + } + + // double protocol_version = 5; + static_assert(sizeof(::uint64_t) == sizeof(double), "Code assumes ::uint64_t and double are the same size."); + double tmp_protocol_version = this->_internal_protocol_version(); + ::uint64_t raw_protocol_version; + memcpy(&raw_protocol_version, &tmp_protocol_version, sizeof(tmp_protocol_version)); + if (raw_protocol_version != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 5, this->_internal_protocol_version(), target); + } + + // .messages.lat_long location = 6; + if (this->_internal_has_location()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(6, _Internal::location(this), + _Internal::location(this).GetCachedSize(), target, stream); + } + + // string vehicle_device_id = 7; + if (!this->_internal_vehicle_device_id().empty()) { + const std::string& _s = this->_internal_vehicle_device_id(); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast<int>(_s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "messages.VehicleMessageHeading.vehicle_device_id"); + target = stream->WriteStringMaybeAliased(7, _s, 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.VehicleMessageHeading) + return target; +} + +::size_t VehicleMessageHeading::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:messages.VehicleMessageHeading) + ::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 vehicle_identity = 3; + if (!this->_internal_vehicle_identity().empty()) { + total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_vehicle_identity()); + } + + // string vehicle_device_id = 7; + if (!this->_internal_vehicle_device_id().empty()) { + total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_vehicle_device_id()); + } + + // .messages.lat_long location = 6; + if (this->_internal_has_location()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.location_); + } + + // int32 message_id = 1; + if (this->_internal_message_id() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this->_internal_message_id()); + } + + // int32 correlation_id = 2; + if (this->_internal_correlation_id() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this->_internal_correlation_id()); + } + + // int64 message_timestamp = 4; + if (this->_internal_message_timestamp() != 0) { + total_size += ::_pbi::WireFormatLite::Int64SizePlusOne( + this->_internal_message_timestamp()); + } + + // double protocol_version = 5; + static_assert(sizeof(::uint64_t) == sizeof(double), "Code assumes ::uint64_t and double are the same size."); + double tmp_protocol_version = this->_internal_protocol_version(); + ::uint64_t raw_protocol_version; + memcpy(&raw_protocol_version, &tmp_protocol_version, sizeof(tmp_protocol_version)); + if (raw_protocol_version != 0) { + total_size += 9; + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData VehicleMessageHeading::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + VehicleMessageHeading::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*VehicleMessageHeading::GetClassData() const { return &_class_data_; } + + +void VehicleMessageHeading::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast<VehicleMessageHeading*>(&to_msg); + auto& from = static_cast<const VehicleMessageHeading&>(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:messages.VehicleMessageHeading) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (!from._internal_vehicle_identity().empty()) { + _this->_internal_set_vehicle_identity(from._internal_vehicle_identity()); + } + if (!from._internal_vehicle_device_id().empty()) { + _this->_internal_set_vehicle_device_id(from._internal_vehicle_device_id()); + } + if (from._internal_has_location()) { + _this->_internal_mutable_location()->::messages::lat_long::MergeFrom( + from._internal_location()); + } + if (from._internal_message_id() != 0) { + _this->_internal_set_message_id(from._internal_message_id()); + } + if (from._internal_correlation_id() != 0) { + _this->_internal_set_correlation_id(from._internal_correlation_id()); + } + if (from._internal_message_timestamp() != 0) { + _this->_internal_set_message_timestamp(from._internal_message_timestamp()); + } + static_assert(sizeof(::uint64_t) == sizeof(double), "Code assumes ::uint64_t and double are the same size."); + double tmp_protocol_version = from._internal_protocol_version(); + ::uint64_t raw_protocol_version; + memcpy(&raw_protocol_version, &tmp_protocol_version, sizeof(tmp_protocol_version)); + if (raw_protocol_version != 0) { + _this->_internal_set_protocol_version(from._internal_protocol_version()); + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void VehicleMessageHeading::CopyFrom(const VehicleMessageHeading& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:messages.VehicleMessageHeading) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool VehicleMessageHeading::IsInitialized() const { + return true; +} + +void VehicleMessageHeading::InternalSwap(VehicleMessageHeading* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.vehicle_identity_, lhs_arena, + &other->_impl_.vehicle_identity_, rhs_arena); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.vehicle_device_id_, lhs_arena, + &other->_impl_.vehicle_device_id_, rhs_arena); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(VehicleMessageHeading, _impl_.protocol_version_) + + sizeof(VehicleMessageHeading::_impl_.protocol_version_) + - PROTOBUF_FIELD_OFFSET(VehicleMessageHeading, _impl_.location_)>( + reinterpret_cast<char*>(&_impl_.location_), + reinterpret_cast<char*>(&other->_impl_.location_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata VehicleMessageHeading::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_messages_2fVehicleMessageHeader_2eproto_getter, &descriptor_table_messages_2fVehicleMessageHeader_2eproto_once, + file_level_metadata_messages_2fVehicleMessageHeader_2eproto[0]); +} +// =================================================================== + +class lat_long::_Internal { + public: +}; + +lat_long::lat_long(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:messages.lat_long) +} +lat_long::lat_long(const lat_long& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), _impl_(from._impl_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>( + from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:messages.lat_long) +} + +inline void lat_long::SharedCtor(::_pb::Arena* arena) { + (void)arena; + new (&_impl_) Impl_{ + decltype(_impl_.latitude_) { 0 } + + , decltype(_impl_.longitude_) { 0 } + + , /*decltype(_impl_._cached_size_)*/{} + }; +} + +lat_long::~lat_long() { + // @@protoc_insertion_point(destructor:messages.lat_long) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void lat_long::SharedDtor() { + ABSL_DCHECK(GetArenaForAllocation() == nullptr); +} + +void lat_long::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void lat_long::Clear() { +// @@protoc_insertion_point(message_clear_start:messages.lat_long) + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + ::memset(&_impl_.latitude_, 0, static_cast<::size_t>( + reinterpret_cast<char*>(&_impl_.longitude_) - + reinterpret_cast<char*>(&_impl_.latitude_)) + sizeof(_impl_.longitude_)); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* lat_long::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // double latitude = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 9)) { + _impl_.latitude_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr); + ptr += sizeof(double); + } else { + goto handle_unusual; + } + continue; + // double longitude = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 17)) { + _impl_.longitude_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr); + ptr += sizeof(double); + } 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: + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +::uint8_t* lat_long::_InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:messages.lat_long) + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + // double latitude = 1; + static_assert(sizeof(::uint64_t) == sizeof(double), "Code assumes ::uint64_t and double are the same size."); + double tmp_latitude = this->_internal_latitude(); + ::uint64_t raw_latitude; + memcpy(&raw_latitude, &tmp_latitude, sizeof(tmp_latitude)); + if (raw_latitude != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 1, this->_internal_latitude(), target); + } + + // double longitude = 2; + static_assert(sizeof(::uint64_t) == sizeof(double), "Code assumes ::uint64_t and double are the same size."); + double tmp_longitude = this->_internal_longitude(); + ::uint64_t raw_longitude; + memcpy(&raw_longitude, &tmp_longitude, sizeof(tmp_longitude)); + if (raw_longitude != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 2, this->_internal_longitude(), 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.lat_long) + return target; +} + +::size_t lat_long::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:messages.lat_long) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // double latitude = 1; + static_assert(sizeof(::uint64_t) == sizeof(double), "Code assumes ::uint64_t and double are the same size."); + double tmp_latitude = this->_internal_latitude(); + ::uint64_t raw_latitude; + memcpy(&raw_latitude, &tmp_latitude, sizeof(tmp_latitude)); + if (raw_latitude != 0) { + total_size += 9; + } + + // double longitude = 2; + static_assert(sizeof(::uint64_t) == sizeof(double), "Code assumes ::uint64_t and double are the same size."); + double tmp_longitude = this->_internal_longitude(); + ::uint64_t raw_longitude; + memcpy(&raw_longitude, &tmp_longitude, sizeof(tmp_longitude)); + if (raw_longitude != 0) { + total_size += 9; + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData lat_long::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + lat_long::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*lat_long::GetClassData() const { return &_class_data_; } + + +void lat_long::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast<lat_long*>(&to_msg); + auto& from = static_cast<const lat_long&>(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:messages.lat_long) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + static_assert(sizeof(::uint64_t) == sizeof(double), "Code assumes ::uint64_t and double are the same size."); + double tmp_latitude = from._internal_latitude(); + ::uint64_t raw_latitude; + memcpy(&raw_latitude, &tmp_latitude, sizeof(tmp_latitude)); + if (raw_latitude != 0) { + _this->_internal_set_latitude(from._internal_latitude()); + } + static_assert(sizeof(::uint64_t) == sizeof(double), "Code assumes ::uint64_t and double are the same size."); + double tmp_longitude = from._internal_longitude(); + ::uint64_t raw_longitude; + memcpy(&raw_longitude, &tmp_longitude, sizeof(tmp_longitude)); + if (raw_longitude != 0) { + _this->_internal_set_longitude(from._internal_longitude()); + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void lat_long::CopyFrom(const lat_long& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:messages.lat_long) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool lat_long::IsInitialized() const { + return true; +} + +void lat_long::InternalSwap(lat_long* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(lat_long, _impl_.longitude_) + + sizeof(lat_long::_impl_.longitude_) + - PROTOBUF_FIELD_OFFSET(lat_long, _impl_.latitude_)>( + reinterpret_cast<char*>(&_impl_.latitude_), + reinterpret_cast<char*>(&other->_impl_.latitude_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata lat_long::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_messages_2fVehicleMessageHeader_2eproto_getter, &descriptor_table_messages_2fVehicleMessageHeader_2eproto_once, + file_level_metadata_messages_2fVehicleMessageHeader_2eproto[1]); +} +// @@protoc_insertion_point(namespace_scope) +} // namespace messages +PROTOBUF_NAMESPACE_OPEN +template<> PROTOBUF_NOINLINE ::messages::VehicleMessageHeading* +Arena::CreateMaybeMessage< ::messages::VehicleMessageHeading >(Arena* arena) { + return Arena::CreateMessageInternal< ::messages::VehicleMessageHeading >(arena); +} +template<> PROTOBUF_NOINLINE ::messages::lat_long* +Arena::CreateMaybeMessage< ::messages::lat_long >(Arena* arena) { + return Arena::CreateMessageInternal< ::messages::lat_long >(arena); +} +PROTOBUF_NAMESPACE_CLOSE +// @@protoc_insertion_point(global_scope) +#include "google/protobuf/port_undef.inc" |