From 766283068a39df9bd7dabf10c8c36f5a75d4335a Mon Sep 17 00:00:00 2001 From: James Simon Date: Fri, 22 Sep 2023 09:45:27 -0400 Subject: added changes fixed doc gen2 Signed-off-by: James Simon Change-Id: I9214b5eae0402e0de542227bda2aee2981c52eb5 --- ...cleIntelligentDataCollector$PublishData$1.class | Bin 0 -> 2602 bytes ...elligentDataCollector$PublishData$Builder.class | Bin 0 -> 20245 bytes ...hicleIntelligentDataCollector$PublishData.class | Bin 0 -> 12653 bytes ...llector$PublishDataCollectionDescriptor$1.class | Bin 0 -> 2822 bytes ...r$PublishDataCollectionDescriptor$Builder.class | Bin 0 -> 9236 bytes ...Collector$PublishDataCollectionDescriptor.class | Bin 0 -> 10972 bytes ...$PublishDataCollectionDescriptorOrBuilder.class | Bin 0 -> 447 bytes ...lligentDataCollector$PublishDataOrBuilder.class | Bin 0 -> 1494 bytes ...ataCollector$PublishVehicleModelMapping$1.class | Bin 0 -> 2767 bytes ...lector$PublishVehicleModelMapping$Builder.class | Bin 0 -> 9136 bytes ...tDataCollector$PublishVehicleModelMapping.class | Bin 0 -> 10837 bytes ...ector$PublishVehicleModelMappingOrBuilder.class | Bin 0 -> 437 bytes ...cleIntelligentDataCollector$dataPayload$1.class | Bin 0 -> 2602 bytes ...elligentDataCollector$dataPayload$Builder.class | Bin 0 -> 13329 bytes ...hicleIntelligentDataCollector$dataPayload.class | Bin 0 -> 13825 bytes ...lligentDataCollector$dataPayloadOrBuilder.class | Bin 0 -> 639 bytes .../messages/VehicleIntelligentDataCollector.class | Bin 0 -> 5052 bytes .../messages/VehicleIntelligentDataCollector.pb.cc | 1290 +++++++++++ .../messages/VehicleIntelligentDataCollector.pb.h | 1299 +++++++++++ ...icleMessageHeader$VehicleMessageHeading$1.class | Bin 0 -> 2580 bytes ...ssageHeader$VehicleMessageHeading$Builder.class | Bin 0 -> 16565 bytes ...ehicleMessageHeader$VehicleMessageHeading.class | Bin 0 -> 14310 bytes ...sageHeader$VehicleMessageHeadingOrBuilder.class | Bin 0 -> 960 bytes .../messages/VehicleMessageHeader$lat_long$1.class | Bin 0 -> 2437 bytes .../VehicleMessageHeader$lat_long$Builder.class | Bin 0 -> 8783 bytes .../messages/VehicleMessageHeader$lat_long.class | Bin 0 -> 10364 bytes .../VehicleMessageHeader$lat_longOrBuilder.class | Bin 0 -> 348 bytes bin/main/messages/VehicleMessageHeader.class | Bin 0 -> 3402 bytes bin/main/messages/VehicleMessageHeader.pb.cc | 827 +++++++ bin/main/messages/VehicleMessageHeader.pb.h | 812 +++++++ ...nLocation$PublishCurrentVehicleLocation$1.class | Bin 0 -> 2716 bytes ...ion$PublishCurrentVehicleLocation$Builder.class | Bin 0 -> 15802 bytes ...ionLocation$PublishCurrentVehicleLocation.class | Bin 0 -> 12370 bytes ...on$PublishCurrentVehicleLocationOrBuilder.class | Bin 0 -> 1287 bytes ...ation$RequestCurrentVehicleLocationTest$1.class | Bin 0 -> 2760 bytes ...RequestCurrentVehicleLocationTest$Builder.class | Bin 0 -> 9985 bytes ...ocation$RequestCurrentVehicleLocationTest.class | Bin 0 -> 11445 bytes ...equestCurrentVehicleLocationTestOrBuilder.class | Bin 0 -> 482 bytes ...Location$ResponseCurrentVehicleLocation$1.class | Bin 0 -> 2727 bytes ...on$ResponseCurrentVehicleLocation$Builder.class | Bin 0 -> 17170 bytes ...onLocation$ResponseCurrentVehicleLocation.class | Bin 0 -> 13263 bytes ...n$ResponseCurrentVehicleLocationOrBuilder.class | Bin 0 -> 1502 bytes ...clePrecisionLocation$ResponseStatusEnum$1.class | Bin 0 -> 1159 bytes ...hiclePrecisionLocation$ResponseStatusEnum.class | Bin 0 -> 4446 bytes ...recisionLocation$VehicleCurrentLocation$1.class | Bin 0 -> 2639 bytes ...onLocation$VehicleCurrentLocation$Builder.class | Bin 0 -> 17011 bytes ...ePrecisionLocation$VehicleCurrentLocation.class | Bin 0 -> 14618 bytes ...tion$VehicleCurrentLocationGNSSReceiver$1.class | Bin 0 -> 2771 bytes ...ehicleCurrentLocationGNSSReceiver$Builder.class | Bin 0 -> 14727 bytes ...cation$VehicleCurrentLocationGNSSReceiver.class | Bin 0 -> 12827 bytes ...entLocationGNSSReceiverMountingPosition$1.class | Bin 0 -> 2947 bytes ...ationGNSSReceiverMountingPosition$Builder.class | Bin 0 -> 10040 bytes ...rrentLocationGNSSReceiverMountingPosition.class | Bin 0 -> 11587 bytes ...tionGNSSReceiverMountingPositionOrBuilder.class | Bin 0 -> 444 bytes ...hicleCurrentLocationGNSSReceiverOrBuilder.class | Bin 0 -> 1084 bytes ...nLocation$VehicleCurrentLocationOrBuilder.class | Bin 0 -> 1112 bytes bin/main/messages/VehiclePrecisionLocation.class | Bin 0 -> 7538 bytes bin/main/messages/VehiclePrecisionLocation.pb.cc | 2023 ++++++++++++++++ bin/main/messages/VehiclePrecisionLocation.pb.h | 2146 +++++++++++++++++ ...eRemoteHvac$CabinConditionStatusPublish$1.class | Bin 0 -> 2610 bytes ...eHvac$CabinConditionStatusPublish$Builder.class | Bin 0 -> 17486 bytes ...cleRemoteHvac$CabinConditionStatusPublish.class | Bin 0 -> 12564 bytes ...Hvac$CabinConditionStatusPublishOrBuilder.class | Bin 0 -> 1184 bytes .../VehicleRemoteHvac$CabinTemperature$1.class | Bin 0 -> 2489 bytes ...ehicleRemoteHvac$CabinTemperature$Builder.class | Bin 0 -> 14381 bytes .../VehicleRemoteHvac$CabinTemperature.class | Bin 0 -> 11451 bytes ...hicleRemoteHvac$CabinTemperatureOrBuilder.class | Bin 0 -> 937 bytes .../messages/VehicleRemoteHvac$HVACState$1.class | Bin 0 -> 2412 bytes .../VehicleRemoteHvac$HVACState$Builder.class | Bin 0 -> 12621 bytes .../VehicleRemoteHvac$HVACState$State$1.class | Bin 0 -> 1144 bytes .../VehicleRemoteHvac$HVACState$State.class | Bin 0 -> 4406 bytes .../messages/VehicleRemoteHvac$HVACState.class | Bin 0 -> 11198 bytes .../VehicleRemoteHvac$HVACStateOrBuilder.class | Bin 0 -> 835 bytes .../messages/VehicleRemoteHvac$HVACZone$1.class | Bin 0 -> 2401 bytes .../VehicleRemoteHvac$HVACZone$Builder.class | Bin 0 -> 12701 bytes .../VehicleRemoteHvac$HVACZone$Zone$1.class | Bin 0 -> 1131 bytes .../messages/VehicleRemoteHvac$HVACZone$Zone.class | Bin 0 -> 4407 bytes bin/main/messages/VehicleRemoteHvac$HVACZone.class | Bin 0 -> 11212 bytes .../VehicleRemoteHvac$HVACZoneOrBuilder.class | Bin 0 -> 860 bytes .../VehicleRemoteHvac$PreconditionRequest$1.class | Bin 0 -> 2522 bytes ...cleRemoteHvac$PreconditionRequest$Builder.class | Bin 0 -> 18999 bytes .../VehicleRemoteHvac$PreconditionRequest.class | Bin 0 -> 12064 bytes ...leRemoteHvac$PreconditionRequestOrBuilder.class | Bin 0 -> 1039 bytes .../VehicleRemoteHvac$PreconditionResponse$1.class | Bin 0 -> 2533 bytes ...leRemoteHvac$PreconditionResponse$Builder.class | Bin 0 -> 10792 bytes ...eRemoteHvac$PreconditionResponse$Status$1.class | Bin 0 -> 1227 bytes ...cleRemoteHvac$PreconditionResponse$Status.class | Bin 0 -> 4466 bytes .../VehicleRemoteHvac$PreconditionResponse.class | Bin 0 -> 11759 bytes ...eRemoteHvac$PreconditionResponseOrBuilder.class | Bin 0 -> 692 bytes .../messages/VehicleRemoteHvac$Temperature$1.class | Bin 0 -> 2434 bytes .../VehicleRemoteHvac$Temperature$Builder.class | Bin 0 -> 9848 bytes .../messages/VehicleRemoteHvac$Temperature.class | Bin 0 -> 11144 bytes .../VehicleRemoteHvac$TemperatureOrBuilder.class | Bin 0 -> 420 bytes bin/main/messages/VehicleRemoteHvac.class | Bin 0 -> 6970 bytes bin/main/messages/VehicleRemoteHvac.pb.cc | 2097 +++++++++++++++++ bin/main/messages/VehicleRemoteHvac.pb.h | 2444 ++++++++++++++++++++ 96 files changed, 12938 insertions(+) create mode 100644 bin/main/messages/VehicleIntelligentDataCollector$PublishData$1.class create mode 100644 bin/main/messages/VehicleIntelligentDataCollector$PublishData$Builder.class create mode 100644 bin/main/messages/VehicleIntelligentDataCollector$PublishData.class create mode 100644 bin/main/messages/VehicleIntelligentDataCollector$PublishDataCollectionDescriptor$1.class create mode 100644 bin/main/messages/VehicleIntelligentDataCollector$PublishDataCollectionDescriptor$Builder.class create mode 100644 bin/main/messages/VehicleIntelligentDataCollector$PublishDataCollectionDescriptor.class create mode 100644 bin/main/messages/VehicleIntelligentDataCollector$PublishDataCollectionDescriptorOrBuilder.class create mode 100644 bin/main/messages/VehicleIntelligentDataCollector$PublishDataOrBuilder.class create mode 100644 bin/main/messages/VehicleIntelligentDataCollector$PublishVehicleModelMapping$1.class create mode 100644 bin/main/messages/VehicleIntelligentDataCollector$PublishVehicleModelMapping$Builder.class create mode 100644 bin/main/messages/VehicleIntelligentDataCollector$PublishVehicleModelMapping.class create mode 100644 bin/main/messages/VehicleIntelligentDataCollector$PublishVehicleModelMappingOrBuilder.class create mode 100644 bin/main/messages/VehicleIntelligentDataCollector$dataPayload$1.class create mode 100644 bin/main/messages/VehicleIntelligentDataCollector$dataPayload$Builder.class create mode 100644 bin/main/messages/VehicleIntelligentDataCollector$dataPayload.class create mode 100644 bin/main/messages/VehicleIntelligentDataCollector$dataPayloadOrBuilder.class create mode 100644 bin/main/messages/VehicleIntelligentDataCollector.class create mode 100644 bin/main/messages/VehicleIntelligentDataCollector.pb.cc create mode 100644 bin/main/messages/VehicleIntelligentDataCollector.pb.h create mode 100644 bin/main/messages/VehicleMessageHeader$VehicleMessageHeading$1.class create mode 100644 bin/main/messages/VehicleMessageHeader$VehicleMessageHeading$Builder.class create mode 100644 bin/main/messages/VehicleMessageHeader$VehicleMessageHeading.class create mode 100644 bin/main/messages/VehicleMessageHeader$VehicleMessageHeadingOrBuilder.class create mode 100644 bin/main/messages/VehicleMessageHeader$lat_long$1.class create mode 100644 bin/main/messages/VehicleMessageHeader$lat_long$Builder.class create mode 100644 bin/main/messages/VehicleMessageHeader$lat_long.class create mode 100644 bin/main/messages/VehicleMessageHeader$lat_longOrBuilder.class create mode 100644 bin/main/messages/VehicleMessageHeader.class create mode 100644 bin/main/messages/VehicleMessageHeader.pb.cc create mode 100644 bin/main/messages/VehicleMessageHeader.pb.h create mode 100644 bin/main/messages/VehiclePrecisionLocation$PublishCurrentVehicleLocation$1.class create mode 100644 bin/main/messages/VehiclePrecisionLocation$PublishCurrentVehicleLocation$Builder.class create mode 100644 bin/main/messages/VehiclePrecisionLocation$PublishCurrentVehicleLocation.class create mode 100644 bin/main/messages/VehiclePrecisionLocation$PublishCurrentVehicleLocationOrBuilder.class create mode 100644 bin/main/messages/VehiclePrecisionLocation$RequestCurrentVehicleLocationTest$1.class create mode 100644 bin/main/messages/VehiclePrecisionLocation$RequestCurrentVehicleLocationTest$Builder.class create mode 100644 bin/main/messages/VehiclePrecisionLocation$RequestCurrentVehicleLocationTest.class create mode 100644 bin/main/messages/VehiclePrecisionLocation$RequestCurrentVehicleLocationTestOrBuilder.class create mode 100644 bin/main/messages/VehiclePrecisionLocation$ResponseCurrentVehicleLocation$1.class create mode 100644 bin/main/messages/VehiclePrecisionLocation$ResponseCurrentVehicleLocation$Builder.class create mode 100644 bin/main/messages/VehiclePrecisionLocation$ResponseCurrentVehicleLocation.class create mode 100644 bin/main/messages/VehiclePrecisionLocation$ResponseCurrentVehicleLocationOrBuilder.class create mode 100644 bin/main/messages/VehiclePrecisionLocation$ResponseStatusEnum$1.class create mode 100644 bin/main/messages/VehiclePrecisionLocation$ResponseStatusEnum.class create mode 100644 bin/main/messages/VehiclePrecisionLocation$VehicleCurrentLocation$1.class create mode 100644 bin/main/messages/VehiclePrecisionLocation$VehicleCurrentLocation$Builder.class create mode 100644 bin/main/messages/VehiclePrecisionLocation$VehicleCurrentLocation.class create mode 100644 bin/main/messages/VehiclePrecisionLocation$VehicleCurrentLocationGNSSReceiver$1.class create mode 100644 bin/main/messages/VehiclePrecisionLocation$VehicleCurrentLocationGNSSReceiver$Builder.class create mode 100644 bin/main/messages/VehiclePrecisionLocation$VehicleCurrentLocationGNSSReceiver.class create mode 100644 bin/main/messages/VehiclePrecisionLocation$VehicleCurrentLocationGNSSReceiverMountingPosition$1.class create mode 100644 bin/main/messages/VehiclePrecisionLocation$VehicleCurrentLocationGNSSReceiverMountingPosition$Builder.class create mode 100644 bin/main/messages/VehiclePrecisionLocation$VehicleCurrentLocationGNSSReceiverMountingPosition.class create mode 100644 bin/main/messages/VehiclePrecisionLocation$VehicleCurrentLocationGNSSReceiverMountingPositionOrBuilder.class create mode 100644 bin/main/messages/VehiclePrecisionLocation$VehicleCurrentLocationGNSSReceiverOrBuilder.class create mode 100644 bin/main/messages/VehiclePrecisionLocation$VehicleCurrentLocationOrBuilder.class create mode 100644 bin/main/messages/VehiclePrecisionLocation.class create mode 100644 bin/main/messages/VehiclePrecisionLocation.pb.cc create mode 100644 bin/main/messages/VehiclePrecisionLocation.pb.h create mode 100644 bin/main/messages/VehicleRemoteHvac$CabinConditionStatusPublish$1.class create mode 100644 bin/main/messages/VehicleRemoteHvac$CabinConditionStatusPublish$Builder.class create mode 100644 bin/main/messages/VehicleRemoteHvac$CabinConditionStatusPublish.class create mode 100644 bin/main/messages/VehicleRemoteHvac$CabinConditionStatusPublishOrBuilder.class create mode 100644 bin/main/messages/VehicleRemoteHvac$CabinTemperature$1.class create mode 100644 bin/main/messages/VehicleRemoteHvac$CabinTemperature$Builder.class create mode 100644 bin/main/messages/VehicleRemoteHvac$CabinTemperature.class create mode 100644 bin/main/messages/VehicleRemoteHvac$CabinTemperatureOrBuilder.class create mode 100644 bin/main/messages/VehicleRemoteHvac$HVACState$1.class create mode 100644 bin/main/messages/VehicleRemoteHvac$HVACState$Builder.class create mode 100644 bin/main/messages/VehicleRemoteHvac$HVACState$State$1.class create mode 100644 bin/main/messages/VehicleRemoteHvac$HVACState$State.class create mode 100644 bin/main/messages/VehicleRemoteHvac$HVACState.class create mode 100644 bin/main/messages/VehicleRemoteHvac$HVACStateOrBuilder.class create mode 100644 bin/main/messages/VehicleRemoteHvac$HVACZone$1.class create mode 100644 bin/main/messages/VehicleRemoteHvac$HVACZone$Builder.class create mode 100644 bin/main/messages/VehicleRemoteHvac$HVACZone$Zone$1.class create mode 100644 bin/main/messages/VehicleRemoteHvac$HVACZone$Zone.class create mode 100644 bin/main/messages/VehicleRemoteHvac$HVACZone.class create mode 100644 bin/main/messages/VehicleRemoteHvac$HVACZoneOrBuilder.class create mode 100644 bin/main/messages/VehicleRemoteHvac$PreconditionRequest$1.class create mode 100644 bin/main/messages/VehicleRemoteHvac$PreconditionRequest$Builder.class create mode 100644 bin/main/messages/VehicleRemoteHvac$PreconditionRequest.class create mode 100644 bin/main/messages/VehicleRemoteHvac$PreconditionRequestOrBuilder.class create mode 100644 bin/main/messages/VehicleRemoteHvac$PreconditionResponse$1.class create mode 100644 bin/main/messages/VehicleRemoteHvac$PreconditionResponse$Builder.class create mode 100644 bin/main/messages/VehicleRemoteHvac$PreconditionResponse$Status$1.class create mode 100644 bin/main/messages/VehicleRemoteHvac$PreconditionResponse$Status.class create mode 100644 bin/main/messages/VehicleRemoteHvac$PreconditionResponse.class create mode 100644 bin/main/messages/VehicleRemoteHvac$PreconditionResponseOrBuilder.class create mode 100644 bin/main/messages/VehicleRemoteHvac$Temperature$1.class create mode 100644 bin/main/messages/VehicleRemoteHvac$Temperature$Builder.class create mode 100644 bin/main/messages/VehicleRemoteHvac$Temperature.class create mode 100644 bin/main/messages/VehicleRemoteHvac$TemperatureOrBuilder.class create mode 100644 bin/main/messages/VehicleRemoteHvac.class create mode 100644 bin/main/messages/VehicleRemoteHvac.pb.cc create mode 100644 bin/main/messages/VehicleRemoteHvac.pb.h (limited to 'bin/main/messages') diff --git a/bin/main/messages/VehicleIntelligentDataCollector$PublishData$1.class b/bin/main/messages/VehicleIntelligentDataCollector$PublishData$1.class new file mode 100644 index 0000000..79525ad Binary files /dev/null and b/bin/main/messages/VehicleIntelligentDataCollector$PublishData$1.class differ diff --git a/bin/main/messages/VehicleIntelligentDataCollector$PublishData$Builder.class b/bin/main/messages/VehicleIntelligentDataCollector$PublishData$Builder.class new file mode 100644 index 0000000..e8725db Binary files /dev/null and b/bin/main/messages/VehicleIntelligentDataCollector$PublishData$Builder.class differ diff --git a/bin/main/messages/VehicleIntelligentDataCollector$PublishData.class b/bin/main/messages/VehicleIntelligentDataCollector$PublishData.class new file mode 100644 index 0000000..94868e4 Binary files /dev/null and b/bin/main/messages/VehicleIntelligentDataCollector$PublishData.class differ diff --git a/bin/main/messages/VehicleIntelligentDataCollector$PublishDataCollectionDescriptor$1.class b/bin/main/messages/VehicleIntelligentDataCollector$PublishDataCollectionDescriptor$1.class new file mode 100644 index 0000000..f409d59 Binary files /dev/null and b/bin/main/messages/VehicleIntelligentDataCollector$PublishDataCollectionDescriptor$1.class differ diff --git a/bin/main/messages/VehicleIntelligentDataCollector$PublishDataCollectionDescriptor$Builder.class b/bin/main/messages/VehicleIntelligentDataCollector$PublishDataCollectionDescriptor$Builder.class new file mode 100644 index 0000000..5ffd85e Binary files /dev/null and b/bin/main/messages/VehicleIntelligentDataCollector$PublishDataCollectionDescriptor$Builder.class differ diff --git a/bin/main/messages/VehicleIntelligentDataCollector$PublishDataCollectionDescriptor.class b/bin/main/messages/VehicleIntelligentDataCollector$PublishDataCollectionDescriptor.class new file mode 100644 index 0000000..91ad749 Binary files /dev/null and b/bin/main/messages/VehicleIntelligentDataCollector$PublishDataCollectionDescriptor.class differ diff --git a/bin/main/messages/VehicleIntelligentDataCollector$PublishDataCollectionDescriptorOrBuilder.class b/bin/main/messages/VehicleIntelligentDataCollector$PublishDataCollectionDescriptorOrBuilder.class new file mode 100644 index 0000000..0c74df4 Binary files /dev/null and b/bin/main/messages/VehicleIntelligentDataCollector$PublishDataCollectionDescriptorOrBuilder.class differ diff --git a/bin/main/messages/VehicleIntelligentDataCollector$PublishDataOrBuilder.class b/bin/main/messages/VehicleIntelligentDataCollector$PublishDataOrBuilder.class new file mode 100644 index 0000000..bf1ae04 Binary files /dev/null and b/bin/main/messages/VehicleIntelligentDataCollector$PublishDataOrBuilder.class differ diff --git a/bin/main/messages/VehicleIntelligentDataCollector$PublishVehicleModelMapping$1.class b/bin/main/messages/VehicleIntelligentDataCollector$PublishVehicleModelMapping$1.class new file mode 100644 index 0000000..4746081 Binary files /dev/null and b/bin/main/messages/VehicleIntelligentDataCollector$PublishVehicleModelMapping$1.class differ diff --git a/bin/main/messages/VehicleIntelligentDataCollector$PublishVehicleModelMapping$Builder.class b/bin/main/messages/VehicleIntelligentDataCollector$PublishVehicleModelMapping$Builder.class new file mode 100644 index 0000000..282506a Binary files /dev/null and b/bin/main/messages/VehicleIntelligentDataCollector$PublishVehicleModelMapping$Builder.class differ diff --git a/bin/main/messages/VehicleIntelligentDataCollector$PublishVehicleModelMapping.class b/bin/main/messages/VehicleIntelligentDataCollector$PublishVehicleModelMapping.class new file mode 100644 index 0000000..73903a2 Binary files /dev/null and b/bin/main/messages/VehicleIntelligentDataCollector$PublishVehicleModelMapping.class differ diff --git a/bin/main/messages/VehicleIntelligentDataCollector$PublishVehicleModelMappingOrBuilder.class b/bin/main/messages/VehicleIntelligentDataCollector$PublishVehicleModelMappingOrBuilder.class new file mode 100644 index 0000000..668c506 Binary files /dev/null and b/bin/main/messages/VehicleIntelligentDataCollector$PublishVehicleModelMappingOrBuilder.class differ diff --git a/bin/main/messages/VehicleIntelligentDataCollector$dataPayload$1.class b/bin/main/messages/VehicleIntelligentDataCollector$dataPayload$1.class new file mode 100644 index 0000000..6d451f8 Binary files /dev/null and b/bin/main/messages/VehicleIntelligentDataCollector$dataPayload$1.class differ diff --git a/bin/main/messages/VehicleIntelligentDataCollector$dataPayload$Builder.class b/bin/main/messages/VehicleIntelligentDataCollector$dataPayload$Builder.class new file mode 100644 index 0000000..cdd0342 Binary files /dev/null and b/bin/main/messages/VehicleIntelligentDataCollector$dataPayload$Builder.class differ diff --git a/bin/main/messages/VehicleIntelligentDataCollector$dataPayload.class b/bin/main/messages/VehicleIntelligentDataCollector$dataPayload.class new file mode 100644 index 0000000..51dbbd0 Binary files /dev/null and b/bin/main/messages/VehicleIntelligentDataCollector$dataPayload.class differ diff --git a/bin/main/messages/VehicleIntelligentDataCollector$dataPayloadOrBuilder.class b/bin/main/messages/VehicleIntelligentDataCollector$dataPayloadOrBuilder.class new file mode 100644 index 0000000..089dca4 Binary files /dev/null and b/bin/main/messages/VehicleIntelligentDataCollector$dataPayloadOrBuilder.class differ diff --git a/bin/main/messages/VehicleIntelligentDataCollector.class b/bin/main/messages/VehicleIntelligentDataCollector.class new file mode 100644 index 0000000..4da278b Binary files /dev/null and b/bin/main/messages/VehicleIntelligentDataCollector.class differ diff --git a/bin/main/messages/VehicleIntelligentDataCollector.pb.cc b/bin/main/messages/VehicleIntelligentDataCollector.pb.cc new file mode 100644 index 0000000..2027a14 --- /dev/null +++ b/bin/main/messages/VehicleIntelligentDataCollector.pb.cc @@ -0,0 +1,1290 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: messages/VehicleIntelligentDataCollector.proto + +#include "messages/VehicleIntelligentDataCollector.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" +// @@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 PublishData::PublishData( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_.datapayload_)*/{} + , /*decltype(_impl_.vehiclemessageheading_)*/nullptr + , /*decltype(_impl_._cached_size_)*/{}} {} +struct PublishDataDefaultTypeInternal { + PROTOBUF_CONSTEXPR PublishDataDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~PublishDataDefaultTypeInternal() {} + union { + PublishData _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PublishDataDefaultTypeInternal _PublishData_default_instance_; +PROTOBUF_CONSTEXPR dataPayload::dataPayload( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_.key_)*/ { + &::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized {} + } + + , /*decltype(_impl_.stringvalue_)*/ { + &::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized {} + } + + , /*decltype(_impl_.bytesvalue_)*/ { + &::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized {} + } + + , /*decltype(_impl_.doublevalue_)*/ 0 + + , /*decltype(_impl_.intlongvalue_)*/ ::int64_t{0} + + , /*decltype(_impl_.intshortvalue_)*/ 0 + + , /*decltype(_impl_.boolvalue_)*/ false + + , /*decltype(_impl_._cached_size_)*/{}} {} +struct dataPayloadDefaultTypeInternal { + PROTOBUF_CONSTEXPR dataPayloadDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~dataPayloadDefaultTypeInternal() {} + union { + dataPayload _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 dataPayloadDefaultTypeInternal _dataPayload_default_instance_; +PROTOBUF_CONSTEXPR PublishDataCollectionDescriptor::PublishDataCollectionDescriptor( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_.datacollectionscheme_)*/ { + &::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized {} + } + + , /*decltype(_impl_._cached_size_)*/{}} {} +struct PublishDataCollectionDescriptorDefaultTypeInternal { + PROTOBUF_CONSTEXPR PublishDataCollectionDescriptorDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~PublishDataCollectionDescriptorDefaultTypeInternal() {} + union { + PublishDataCollectionDescriptor _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PublishDataCollectionDescriptorDefaultTypeInternal _PublishDataCollectionDescriptor_default_instance_; +PROTOBUF_CONSTEXPR PublishVehicleModelMapping::PublishVehicleModelMapping( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_.datacollectionscheme_)*/ { + &::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized {} + } + + , /*decltype(_impl_._cached_size_)*/{}} {} +struct PublishVehicleModelMappingDefaultTypeInternal { + PROTOBUF_CONSTEXPR PublishVehicleModelMappingDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~PublishVehicleModelMappingDefaultTypeInternal() {} + union { + PublishVehicleModelMapping _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PublishVehicleModelMappingDefaultTypeInternal _PublishVehicleModelMapping_default_instance_; +} // namespace messages +static ::_pb::Metadata file_level_metadata_messages_2fVehicleIntelligentDataCollector_2eproto[4]; +static constexpr const ::_pb::EnumDescriptor** + file_level_enum_descriptors_messages_2fVehicleIntelligentDataCollector_2eproto = nullptr; +static constexpr const ::_pb::ServiceDescriptor** + file_level_service_descriptors_messages_2fVehicleIntelligentDataCollector_2eproto = nullptr; +const ::uint32_t TableStruct_messages_2fVehicleIntelligentDataCollector_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE( + protodesc_cold) = { + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::messages::PublishData, _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::PublishData, _impl_.vehiclemessageheading_), + PROTOBUF_FIELD_OFFSET(::messages::PublishData, _impl_.datapayload_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::messages::dataPayload, _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::dataPayload, _impl_.key_), + PROTOBUF_FIELD_OFFSET(::messages::dataPayload, _impl_.stringvalue_), + PROTOBUF_FIELD_OFFSET(::messages::dataPayload, _impl_.doublevalue_), + PROTOBUF_FIELD_OFFSET(::messages::dataPayload, _impl_.intshortvalue_), + PROTOBUF_FIELD_OFFSET(::messages::dataPayload, _impl_.intlongvalue_), + PROTOBUF_FIELD_OFFSET(::messages::dataPayload, _impl_.boolvalue_), + PROTOBUF_FIELD_OFFSET(::messages::dataPayload, _impl_.bytesvalue_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::messages::PublishDataCollectionDescriptor, _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::PublishDataCollectionDescriptor, _impl_.datacollectionscheme_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::messages::PublishVehicleModelMapping, _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::PublishVehicleModelMapping, _impl_.datacollectionscheme_), +}; + +static const ::_pbi::MigrationSchema + schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { + { 0, -1, -1, sizeof(::messages::PublishData)}, + { 10, -1, -1, sizeof(::messages::dataPayload)}, + { 25, -1, -1, sizeof(::messages::PublishDataCollectionDescriptor)}, + { 34, -1, -1, sizeof(::messages::PublishVehicleModelMapping)}, +}; + +static const ::_pb::Message* const file_default_instances[] = { + &::messages::_PublishData_default_instance_._instance, + &::messages::_dataPayload_default_instance_._instance, + &::messages::_PublishDataCollectionDescriptor_default_instance_._instance, + &::messages::_PublishVehicleModelMapping_default_instance_._instance, +}; +const char descriptor_table_protodef_messages_2fVehicleIntelligentDataCollector_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { + "\n.messages/VehicleIntelligentDataCollect" + "or.proto\022\010messages\032#messages/VehicleMess" + "ageHeader.proto\"y\n\013PublishData\022>\n\025vehicl" + "eMessageHeading\030\001 \001(\0132\037.messages.Vehicle" + "MessageHeading\022*\n\013DataPayload\030\002 \003(\0132\025.me" + "ssages.dataPayload\"\230\001\n\013dataPayload\022\013\n\003ke" + "y\030\001 \001(\t\022\023\n\013stringValue\030\002 \001(\t\022\023\n\013doubleVa" + "lue\030\003 \001(\001\022\025\n\rintShortValue\030\004 \001(\005\022\024\n\014intL" + "ongValue\030\005 \001(\003\022\021\n\tboolValue\030\006 \001(\010\022\022\n\nbyt" + "esValue\030\007 \001(\014\"\?\n\037PublishDataCollectionDe" + "scriptor\022\034\n\024dataCollectionScheme\030\001 \001(\014\":" + "\n\032PublishVehicleModelMapping\022\034\n\024dataColl" + "ectionScheme\030\001 \001(\014b\006proto3" +}; +static const ::_pbi::DescriptorTable* const descriptor_table_messages_2fVehicleIntelligentDataCollector_2eproto_deps[1] = + { + &::descriptor_table_messages_2fVehicleMessageHeader_2eproto, +}; +static ::absl::once_flag descriptor_table_messages_2fVehicleIntelligentDataCollector_2eproto_once; +const ::_pbi::DescriptorTable descriptor_table_messages_2fVehicleIntelligentDataCollector_2eproto = { + false, + false, + 506, + descriptor_table_protodef_messages_2fVehicleIntelligentDataCollector_2eproto, + "messages/VehicleIntelligentDataCollector.proto", + &descriptor_table_messages_2fVehicleIntelligentDataCollector_2eproto_once, + descriptor_table_messages_2fVehicleIntelligentDataCollector_2eproto_deps, + 1, + 4, + schemas, + file_default_instances, + TableStruct_messages_2fVehicleIntelligentDataCollector_2eproto::offsets, + file_level_metadata_messages_2fVehicleIntelligentDataCollector_2eproto, + file_level_enum_descriptors_messages_2fVehicleIntelligentDataCollector_2eproto, + file_level_service_descriptors_messages_2fVehicleIntelligentDataCollector_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_2fVehicleIntelligentDataCollector_2eproto_getter() { + return &descriptor_table_messages_2fVehicleIntelligentDataCollector_2eproto; +} +// Force running AddDescriptors() at dynamic initialization time. +PROTOBUF_ATTRIBUTE_INIT_PRIORITY2 +static ::_pbi::AddDescriptorsRunner dynamic_init_dummy_messages_2fVehicleIntelligentDataCollector_2eproto(&descriptor_table_messages_2fVehicleIntelligentDataCollector_2eproto); +namespace messages { +// =================================================================== + +class PublishData::_Internal { + public: + static const ::messages::VehicleMessageHeading& vehiclemessageheading(const PublishData* msg); +}; + +const ::messages::VehicleMessageHeading& +PublishData::_Internal::vehiclemessageheading(const PublishData* msg) { + return *msg->_impl_.vehiclemessageheading_; +} +void PublishData::clear_vehiclemessageheading() { + if (GetArenaForAllocation() == nullptr && _impl_.vehiclemessageheading_ != nullptr) { + delete _impl_.vehiclemessageheading_; + } + _impl_.vehiclemessageheading_ = nullptr; +} +PublishData::PublishData(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:messages.PublishData) +} +PublishData::PublishData(const PublishData& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + PublishData* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_.datapayload_){from._impl_.datapayload_} + , decltype(_impl_.vehiclemessageheading_){nullptr} + , /*decltype(_impl_._cached_size_)*/{}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_vehiclemessageheading()) { + _this->_impl_.vehiclemessageheading_ = new ::messages::VehicleMessageHeading(*from._impl_.vehiclemessageheading_); + } + // @@protoc_insertion_point(copy_constructor:messages.PublishData) +} + +inline void PublishData::SharedCtor(::_pb::Arena* arena) { + (void)arena; + new (&_impl_) Impl_{ + decltype(_impl_.datapayload_){arena} + , decltype(_impl_.vehiclemessageheading_){nullptr} + , /*decltype(_impl_._cached_size_)*/{} + }; +} + +PublishData::~PublishData() { + // @@protoc_insertion_point(destructor:messages.PublishData) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void PublishData::SharedDtor() { + ABSL_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.datapayload_.~RepeatedPtrField(); + if (this != internal_default_instance()) delete _impl_.vehiclemessageheading_; +} + +void PublishData::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void PublishData::Clear() { +// @@protoc_insertion_point(message_clear_start:messages.PublishData) + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.datapayload_.Clear(); + if (GetArenaForAllocation() == nullptr && _impl_.vehiclemessageheading_ != nullptr) { + delete _impl_.vehiclemessageheading_; + } + _impl_.vehiclemessageheading_ = nullptr; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* PublishData::_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) { + // .messages.VehicleMessageHeading vehicleMessageHeading = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_vehiclemessageheading(), ptr); + CHK_(ptr); + } else { + goto handle_unusual; + } + continue; + // repeated .messages.dataPayload DataPayload = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_datapayload(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(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: + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +::uint8_t* PublishData::_InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:messages.PublishData) + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + // .messages.VehicleMessageHeading vehicleMessageHeading = 1; + if (this->_internal_has_vehiclemessageheading()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, _Internal::vehiclemessageheading(this), + _Internal::vehiclemessageheading(this).GetCachedSize(), target, stream); + } + + // repeated .messages.dataPayload DataPayload = 2; + for (unsigned i = 0, + n = static_cast(this->_internal_datapayload_size()); i < n; i++) { + const auto& repfield = this->_internal_datapayload(i); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(2, repfield, repfield.GetCachedSize(), target, stream); + } + + 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.PublishData) + return target; +} + +::size_t PublishData::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:messages.PublishData) + ::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.dataPayload DataPayload = 2; + total_size += 1UL * this->_internal_datapayload_size(); + for (const auto& msg : this->_impl_.datapayload_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // .messages.VehicleMessageHeading vehicleMessageHeading = 1; + if (this->_internal_has_vehiclemessageheading()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.vehiclemessageheading_); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData PublishData::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + PublishData::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*PublishData::GetClassData() const { return &_class_data_; } + + +void PublishData::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.PublishData) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + _this->_impl_.datapayload_.MergeFrom(from._impl_.datapayload_); + if (from._internal_has_vehiclemessageheading()) { + _this->_internal_mutable_vehiclemessageheading()->::messages::VehicleMessageHeading::MergeFrom( + from._internal_vehiclemessageheading()); + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void PublishData::CopyFrom(const PublishData& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:messages.PublishData) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool PublishData::IsInitialized() const { + return true; +} + +void PublishData::InternalSwap(PublishData* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + _impl_.datapayload_.InternalSwap(&other->_impl_.datapayload_); + swap(_impl_.vehiclemessageheading_, other->_impl_.vehiclemessageheading_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata PublishData::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_messages_2fVehicleIntelligentDataCollector_2eproto_getter, &descriptor_table_messages_2fVehicleIntelligentDataCollector_2eproto_once, + file_level_metadata_messages_2fVehicleIntelligentDataCollector_2eproto[0]); +} +// =================================================================== + +class dataPayload::_Internal { + public: +}; + +dataPayload::dataPayload(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:messages.dataPayload) +} +dataPayload::dataPayload(const dataPayload& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + dataPayload* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_.key_) {} + + , decltype(_impl_.stringvalue_) {} + + , decltype(_impl_.bytesvalue_) {} + + , decltype(_impl_.doublevalue_) {} + + , decltype(_impl_.intlongvalue_) {} + + , decltype(_impl_.intshortvalue_) {} + + , decltype(_impl_.boolvalue_) {} + + , /*decltype(_impl_._cached_size_)*/{}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.key_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.key_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (!from._internal_key().empty()) { + _this->_impl_.key_.Set(from._internal_key(), _this->GetArenaForAllocation()); + } + _impl_.stringvalue_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.stringvalue_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (!from._internal_stringvalue().empty()) { + _this->_impl_.stringvalue_.Set(from._internal_stringvalue(), _this->GetArenaForAllocation()); + } + _impl_.bytesvalue_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.bytesvalue_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (!from._internal_bytesvalue().empty()) { + _this->_impl_.bytesvalue_.Set(from._internal_bytesvalue(), _this->GetArenaForAllocation()); + } + ::memcpy(&_impl_.doublevalue_, &from._impl_.doublevalue_, + static_cast<::size_t>(reinterpret_cast(&_impl_.boolvalue_) - + reinterpret_cast(&_impl_.doublevalue_)) + sizeof(_impl_.boolvalue_)); + // @@protoc_insertion_point(copy_constructor:messages.dataPayload) +} + +inline void dataPayload::SharedCtor(::_pb::Arena* arena) { + (void)arena; + new (&_impl_) Impl_{ + decltype(_impl_.key_) {} + + , decltype(_impl_.stringvalue_) {} + + , decltype(_impl_.bytesvalue_) {} + + , decltype(_impl_.doublevalue_) { 0 } + + , decltype(_impl_.intlongvalue_) { ::int64_t{0} } + + , decltype(_impl_.intshortvalue_) { 0 } + + , decltype(_impl_.boolvalue_) { false } + + , /*decltype(_impl_._cached_size_)*/{} + }; + _impl_.key_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.key_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.stringvalue_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.stringvalue_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.bytesvalue_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.bytesvalue_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +dataPayload::~dataPayload() { + // @@protoc_insertion_point(destructor:messages.dataPayload) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void dataPayload::SharedDtor() { + ABSL_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.key_.Destroy(); + _impl_.stringvalue_.Destroy(); + _impl_.bytesvalue_.Destroy(); +} + +void dataPayload::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void dataPayload::Clear() { +// @@protoc_insertion_point(message_clear_start:messages.dataPayload) + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.key_.ClearToEmpty(); + _impl_.stringvalue_.ClearToEmpty(); + _impl_.bytesvalue_.ClearToEmpty(); + ::memset(&_impl_.doublevalue_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.boolvalue_) - + reinterpret_cast(&_impl_.doublevalue_)) + sizeof(_impl_.boolvalue_)); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* dataPayload::_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) { + // string key = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) { + auto str = _internal_mutable_key(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + CHK_(::_pbi::VerifyUTF8(str, "messages.dataPayload.key")); + } else { + goto handle_unusual; + } + continue; + // string stringValue = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) { + auto str = _internal_mutable_stringvalue(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + CHK_(::_pbi::VerifyUTF8(str, "messages.dataPayload.stringValue")); + } else { + goto handle_unusual; + } + continue; + // double doubleValue = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 25)) { + _impl_.doublevalue_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(double); + } else { + goto handle_unusual; + } + continue; + // int32 intShortValue = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) { + _impl_.intshortvalue_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else { + goto handle_unusual; + } + continue; + // int64 intLongValue = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 40)) { + _impl_.intlongvalue_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else { + goto handle_unusual; + } + continue; + // bool boolValue = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 48)) { + _impl_.boolvalue_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else { + goto handle_unusual; + } + continue; + // bytes bytesValue = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 58)) { + auto str = _internal_mutable_bytesvalue(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + 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: + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +::uint8_t* dataPayload::_InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:messages.dataPayload) + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + // string key = 1; + if (!this->_internal_key().empty()) { + const std::string& _s = this->_internal_key(); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "messages.dataPayload.key"); + target = stream->WriteStringMaybeAliased(1, _s, target); + } + + // string stringValue = 2; + if (!this->_internal_stringvalue().empty()) { + const std::string& _s = this->_internal_stringvalue(); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "messages.dataPayload.stringValue"); + target = stream->WriteStringMaybeAliased(2, _s, target); + } + + // double doubleValue = 3; + static_assert(sizeof(::uint64_t) == sizeof(double), "Code assumes ::uint64_t and double are the same size."); + double tmp_doublevalue = this->_internal_doublevalue(); + ::uint64_t raw_doublevalue; + memcpy(&raw_doublevalue, &tmp_doublevalue, sizeof(tmp_doublevalue)); + if (raw_doublevalue != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 3, this->_internal_doublevalue(), target); + } + + // int32 intShortValue = 4; + if (this->_internal_intshortvalue() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt32ToArray( + 4, this->_internal_intshortvalue(), target); + } + + // int64 intLongValue = 5; + if (this->_internal_intlongvalue() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt64ToArray( + 5, this->_internal_intlongvalue(), target); + } + + // bool boolValue = 6; + if (this->_internal_boolvalue() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray( + 6, this->_internal_boolvalue(), target); + } + + // bytes bytesValue = 7; + if (!this->_internal_bytesvalue().empty()) { + const std::string& _s = this->_internal_bytesvalue(); + target = stream->WriteBytesMaybeAliased(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.dataPayload) + return target; +} + +::size_t dataPayload::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:messages.dataPayload) + ::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 key = 1; + if (!this->_internal_key().empty()) { + total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_key()); + } + + // string stringValue = 2; + if (!this->_internal_stringvalue().empty()) { + total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_stringvalue()); + } + + // bytes bytesValue = 7; + if (!this->_internal_bytesvalue().empty()) { + total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_bytesvalue()); + } + + // double doubleValue = 3; + static_assert(sizeof(::uint64_t) == sizeof(double), "Code assumes ::uint64_t and double are the same size."); + double tmp_doublevalue = this->_internal_doublevalue(); + ::uint64_t raw_doublevalue; + memcpy(&raw_doublevalue, &tmp_doublevalue, sizeof(tmp_doublevalue)); + if (raw_doublevalue != 0) { + total_size += 9; + } + + // int64 intLongValue = 5; + if (this->_internal_intlongvalue() != 0) { + total_size += ::_pbi::WireFormatLite::Int64SizePlusOne( + this->_internal_intlongvalue()); + } + + // int32 intShortValue = 4; + if (this->_internal_intshortvalue() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this->_internal_intshortvalue()); + } + + // bool boolValue = 6; + if (this->_internal_boolvalue() != 0) { + total_size += 2; + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData dataPayload::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + dataPayload::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*dataPayload::GetClassData() const { return &_class_data_; } + + +void dataPayload::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.dataPayload) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (!from._internal_key().empty()) { + _this->_internal_set_key(from._internal_key()); + } + if (!from._internal_stringvalue().empty()) { + _this->_internal_set_stringvalue(from._internal_stringvalue()); + } + if (!from._internal_bytesvalue().empty()) { + _this->_internal_set_bytesvalue(from._internal_bytesvalue()); + } + static_assert(sizeof(::uint64_t) == sizeof(double), "Code assumes ::uint64_t and double are the same size."); + double tmp_doublevalue = from._internal_doublevalue(); + ::uint64_t raw_doublevalue; + memcpy(&raw_doublevalue, &tmp_doublevalue, sizeof(tmp_doublevalue)); + if (raw_doublevalue != 0) { + _this->_internal_set_doublevalue(from._internal_doublevalue()); + } + if (from._internal_intlongvalue() != 0) { + _this->_internal_set_intlongvalue(from._internal_intlongvalue()); + } + if (from._internal_intshortvalue() != 0) { + _this->_internal_set_intshortvalue(from._internal_intshortvalue()); + } + if (from._internal_boolvalue() != 0) { + _this->_internal_set_boolvalue(from._internal_boolvalue()); + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void dataPayload::CopyFrom(const dataPayload& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:messages.dataPayload) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool dataPayload::IsInitialized() const { + return true; +} + +void dataPayload::InternalSwap(dataPayload* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.key_, lhs_arena, + &other->_impl_.key_, rhs_arena); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.stringvalue_, lhs_arena, + &other->_impl_.stringvalue_, rhs_arena); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.bytesvalue_, lhs_arena, + &other->_impl_.bytesvalue_, rhs_arena); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(dataPayload, _impl_.boolvalue_) + + sizeof(dataPayload::_impl_.boolvalue_) + - PROTOBUF_FIELD_OFFSET(dataPayload, _impl_.doublevalue_)>( + reinterpret_cast(&_impl_.doublevalue_), + reinterpret_cast(&other->_impl_.doublevalue_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata dataPayload::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_messages_2fVehicleIntelligentDataCollector_2eproto_getter, &descriptor_table_messages_2fVehicleIntelligentDataCollector_2eproto_once, + file_level_metadata_messages_2fVehicleIntelligentDataCollector_2eproto[1]); +} +// =================================================================== + +class PublishDataCollectionDescriptor::_Internal { + public: +}; + +PublishDataCollectionDescriptor::PublishDataCollectionDescriptor(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:messages.PublishDataCollectionDescriptor) +} +PublishDataCollectionDescriptor::PublishDataCollectionDescriptor(const PublishDataCollectionDescriptor& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + PublishDataCollectionDescriptor* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_.datacollectionscheme_) {} + + , /*decltype(_impl_._cached_size_)*/{}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.datacollectionscheme_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.datacollectionscheme_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (!from._internal_datacollectionscheme().empty()) { + _this->_impl_.datacollectionscheme_.Set(from._internal_datacollectionscheme(), _this->GetArenaForAllocation()); + } + // @@protoc_insertion_point(copy_constructor:messages.PublishDataCollectionDescriptor) +} + +inline void PublishDataCollectionDescriptor::SharedCtor(::_pb::Arena* arena) { + (void)arena; + new (&_impl_) Impl_{ + decltype(_impl_.datacollectionscheme_) {} + + , /*decltype(_impl_._cached_size_)*/{} + }; + _impl_.datacollectionscheme_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.datacollectionscheme_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +PublishDataCollectionDescriptor::~PublishDataCollectionDescriptor() { + // @@protoc_insertion_point(destructor:messages.PublishDataCollectionDescriptor) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void PublishDataCollectionDescriptor::SharedDtor() { + ABSL_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.datacollectionscheme_.Destroy(); +} + +void PublishDataCollectionDescriptor::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void PublishDataCollectionDescriptor::Clear() { +// @@protoc_insertion_point(message_clear_start:messages.PublishDataCollectionDescriptor) + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.datacollectionscheme_.ClearToEmpty(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* PublishDataCollectionDescriptor::_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) { + // bytes dataCollectionScheme = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) { + auto str = _internal_mutable_datacollectionscheme(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + 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: + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +::uint8_t* PublishDataCollectionDescriptor::_InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:messages.PublishDataCollectionDescriptor) + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + // bytes dataCollectionScheme = 1; + if (!this->_internal_datacollectionscheme().empty()) { + const std::string& _s = this->_internal_datacollectionscheme(); + target = stream->WriteBytesMaybeAliased(1, _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.PublishDataCollectionDescriptor) + return target; +} + +::size_t PublishDataCollectionDescriptor::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:messages.PublishDataCollectionDescriptor) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // bytes dataCollectionScheme = 1; + if (!this->_internal_datacollectionscheme().empty()) { + total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_datacollectionscheme()); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData PublishDataCollectionDescriptor::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + PublishDataCollectionDescriptor::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*PublishDataCollectionDescriptor::GetClassData() const { return &_class_data_; } + + +void PublishDataCollectionDescriptor::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.PublishDataCollectionDescriptor) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (!from._internal_datacollectionscheme().empty()) { + _this->_internal_set_datacollectionscheme(from._internal_datacollectionscheme()); + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void PublishDataCollectionDescriptor::CopyFrom(const PublishDataCollectionDescriptor& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:messages.PublishDataCollectionDescriptor) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool PublishDataCollectionDescriptor::IsInitialized() const { + return true; +} + +void PublishDataCollectionDescriptor::InternalSwap(PublishDataCollectionDescriptor* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.datacollectionscheme_, lhs_arena, + &other->_impl_.datacollectionscheme_, rhs_arena); +} + +::PROTOBUF_NAMESPACE_ID::Metadata PublishDataCollectionDescriptor::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_messages_2fVehicleIntelligentDataCollector_2eproto_getter, &descriptor_table_messages_2fVehicleIntelligentDataCollector_2eproto_once, + file_level_metadata_messages_2fVehicleIntelligentDataCollector_2eproto[2]); +} +// =================================================================== + +class PublishVehicleModelMapping::_Internal { + public: +}; + +PublishVehicleModelMapping::PublishVehicleModelMapping(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:messages.PublishVehicleModelMapping) +} +PublishVehicleModelMapping::PublishVehicleModelMapping(const PublishVehicleModelMapping& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + PublishVehicleModelMapping* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_.datacollectionscheme_) {} + + , /*decltype(_impl_._cached_size_)*/{}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.datacollectionscheme_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.datacollectionscheme_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (!from._internal_datacollectionscheme().empty()) { + _this->_impl_.datacollectionscheme_.Set(from._internal_datacollectionscheme(), _this->GetArenaForAllocation()); + } + // @@protoc_insertion_point(copy_constructor:messages.PublishVehicleModelMapping) +} + +inline void PublishVehicleModelMapping::SharedCtor(::_pb::Arena* arena) { + (void)arena; + new (&_impl_) Impl_{ + decltype(_impl_.datacollectionscheme_) {} + + , /*decltype(_impl_._cached_size_)*/{} + }; + _impl_.datacollectionscheme_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.datacollectionscheme_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +PublishVehicleModelMapping::~PublishVehicleModelMapping() { + // @@protoc_insertion_point(destructor:messages.PublishVehicleModelMapping) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void PublishVehicleModelMapping::SharedDtor() { + ABSL_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.datacollectionscheme_.Destroy(); +} + +void PublishVehicleModelMapping::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void PublishVehicleModelMapping::Clear() { +// @@protoc_insertion_point(message_clear_start:messages.PublishVehicleModelMapping) + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.datacollectionscheme_.ClearToEmpty(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* PublishVehicleModelMapping::_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) { + // bytes dataCollectionScheme = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) { + auto str = _internal_mutable_datacollectionscheme(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + 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: + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +::uint8_t* PublishVehicleModelMapping::_InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:messages.PublishVehicleModelMapping) + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + // bytes dataCollectionScheme = 1; + if (!this->_internal_datacollectionscheme().empty()) { + const std::string& _s = this->_internal_datacollectionscheme(); + target = stream->WriteBytesMaybeAliased(1, _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.PublishVehicleModelMapping) + return target; +} + +::size_t PublishVehicleModelMapping::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:messages.PublishVehicleModelMapping) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // bytes dataCollectionScheme = 1; + if (!this->_internal_datacollectionscheme().empty()) { + total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_datacollectionscheme()); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData PublishVehicleModelMapping::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + PublishVehicleModelMapping::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*PublishVehicleModelMapping::GetClassData() const { return &_class_data_; } + + +void PublishVehicleModelMapping::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.PublishVehicleModelMapping) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (!from._internal_datacollectionscheme().empty()) { + _this->_internal_set_datacollectionscheme(from._internal_datacollectionscheme()); + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void PublishVehicleModelMapping::CopyFrom(const PublishVehicleModelMapping& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:messages.PublishVehicleModelMapping) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool PublishVehicleModelMapping::IsInitialized() const { + return true; +} + +void PublishVehicleModelMapping::InternalSwap(PublishVehicleModelMapping* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.datacollectionscheme_, lhs_arena, + &other->_impl_.datacollectionscheme_, rhs_arena); +} + +::PROTOBUF_NAMESPACE_ID::Metadata PublishVehicleModelMapping::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_messages_2fVehicleIntelligentDataCollector_2eproto_getter, &descriptor_table_messages_2fVehicleIntelligentDataCollector_2eproto_once, + file_level_metadata_messages_2fVehicleIntelligentDataCollector_2eproto[3]); +} +// @@protoc_insertion_point(namespace_scope) +} // namespace messages +PROTOBUF_NAMESPACE_OPEN +template<> PROTOBUF_NOINLINE ::messages::PublishData* +Arena::CreateMaybeMessage< ::messages::PublishData >(Arena* arena) { + return Arena::CreateMessageInternal< ::messages::PublishData >(arena); +} +template<> PROTOBUF_NOINLINE ::messages::dataPayload* +Arena::CreateMaybeMessage< ::messages::dataPayload >(Arena* arena) { + return Arena::CreateMessageInternal< ::messages::dataPayload >(arena); +} +template<> PROTOBUF_NOINLINE ::messages::PublishDataCollectionDescriptor* +Arena::CreateMaybeMessage< ::messages::PublishDataCollectionDescriptor >(Arena* arena) { + return Arena::CreateMessageInternal< ::messages::PublishDataCollectionDescriptor >(arena); +} +template<> PROTOBUF_NOINLINE ::messages::PublishVehicleModelMapping* +Arena::CreateMaybeMessage< ::messages::PublishVehicleModelMapping >(Arena* arena) { + return Arena::CreateMessageInternal< ::messages::PublishVehicleModelMapping >(arena); +} +PROTOBUF_NAMESPACE_CLOSE +// @@protoc_insertion_point(global_scope) +#include "google/protobuf/port_undef.inc" diff --git a/bin/main/messages/VehicleIntelligentDataCollector.pb.h b/bin/main/messages/VehicleIntelligentDataCollector.pb.h new file mode 100644 index 0000000..f3844d9 --- /dev/null +++ b/bin/main/messages/VehicleIntelligentDataCollector.pb.h @@ -0,0 +1,1299 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: messages/VehicleIntelligentDataCollector.proto + +#ifndef GOOGLE_PROTOBUF_INCLUDED_messages_2fVehicleIntelligentDataCollector_2eproto_2epb_2eh +#define GOOGLE_PROTOBUF_INCLUDED_messages_2fVehicleIntelligentDataCollector_2eproto_2epb_2eh + +#include +#include +#include + +#include "google/protobuf/port_def.inc" +#if PROTOBUF_VERSION < 4022000 +#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 4022000 < 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_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 "messages/VehicleMessageHeader.pb.h" +// @@protoc_insertion_point(includes) + +// Must be included last. +#include "google/protobuf/port_def.inc" + +#define PROTOBUF_INTERNAL_EXPORT_messages_2fVehicleIntelligentDataCollector_2eproto + +PROTOBUF_NAMESPACE_OPEN +namespace internal { +class AnyMetadata; +} // namespace internal +PROTOBUF_NAMESPACE_CLOSE + +// Internal implementation detail -- do not use these members. +struct TableStruct_messages_2fVehicleIntelligentDataCollector_2eproto { + static const ::uint32_t offsets[]; +}; +extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable + descriptor_table_messages_2fVehicleIntelligentDataCollector_2eproto; +namespace messages { +class PublishData; +struct PublishDataDefaultTypeInternal; +extern PublishDataDefaultTypeInternal _PublishData_default_instance_; +class PublishDataCollectionDescriptor; +struct PublishDataCollectionDescriptorDefaultTypeInternal; +extern PublishDataCollectionDescriptorDefaultTypeInternal _PublishDataCollectionDescriptor_default_instance_; +class PublishVehicleModelMapping; +struct PublishVehicleModelMappingDefaultTypeInternal; +extern PublishVehicleModelMappingDefaultTypeInternal _PublishVehicleModelMapping_default_instance_; +class dataPayload; +struct dataPayloadDefaultTypeInternal; +extern dataPayloadDefaultTypeInternal _dataPayload_default_instance_; +} // namespace messages +PROTOBUF_NAMESPACE_OPEN +template <> +::messages::PublishData* Arena::CreateMaybeMessage<::messages::PublishData>(Arena*); +template <> +::messages::PublishDataCollectionDescriptor* Arena::CreateMaybeMessage<::messages::PublishDataCollectionDescriptor>(Arena*); +template <> +::messages::PublishVehicleModelMapping* Arena::CreateMaybeMessage<::messages::PublishVehicleModelMapping>(Arena*); +template <> +::messages::dataPayload* Arena::CreateMaybeMessage<::messages::dataPayload>(Arena*); +PROTOBUF_NAMESPACE_CLOSE + +namespace messages { + +// =================================================================== + + +// ------------------------------------------------------------------- + +class PublishData final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:messages.PublishData) */ { + public: + inline PublishData() : PublishData(nullptr) {} + ~PublishData() override; + explicit PROTOBUF_CONSTEXPR PublishData(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + PublishData(const PublishData& from); + PublishData(PublishData&& from) noexcept + : PublishData() { + *this = ::std::move(from); + } + + inline PublishData& operator=(const PublishData& from) { + CopyFrom(from); + return *this; + } + inline PublishData& operator=(PublishData&& 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 PublishData& default_instance() { + return *internal_default_instance(); + } + static inline const PublishData* internal_default_instance() { + return reinterpret_cast( + &_PublishData_default_instance_); + } + static constexpr int kIndexInFileMessages = + 0; + + friend void swap(PublishData& a, PublishData& b) { + a.Swap(&b); + } + inline void Swap(PublishData* 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(PublishData* other) { + if (other == this) return; + ABSL_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + PublishData* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const PublishData& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const PublishData& from) { + PublishData::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); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(PublishData* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::absl::string_view FullMessageName() { + return "messages.PublishData"; + } + protected: + explicit PublishData(::PROTOBUF_NAMESPACE_ID::Arena* arena); + 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 { + kDataPayloadFieldNumber = 2, + kVehicleMessageHeadingFieldNumber = 1, + }; + // repeated .messages.dataPayload DataPayload = 2; + int datapayload_size() const; + private: + int _internal_datapayload_size() const; + + public: + void clear_datapayload() ; + ::messages::dataPayload* mutable_datapayload(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::messages::dataPayload >* + mutable_datapayload(); + private: + const ::messages::dataPayload& _internal_datapayload(int index) const; + ::messages::dataPayload* _internal_add_datapayload(); + public: + const ::messages::dataPayload& datapayload(int index) const; + ::messages::dataPayload* add_datapayload(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::messages::dataPayload >& + datapayload() const; + // .messages.VehicleMessageHeading vehicleMessageHeading = 1; + bool has_vehiclemessageheading() const; + private: + bool _internal_has_vehiclemessageheading() const; + + public: + void clear_vehiclemessageheading() ; + const ::messages::VehicleMessageHeading& vehiclemessageheading() const; + PROTOBUF_NODISCARD ::messages::VehicleMessageHeading* release_vehiclemessageheading(); + ::messages::VehicleMessageHeading* mutable_vehiclemessageheading(); + void set_allocated_vehiclemessageheading(::messages::VehicleMessageHeading* vehiclemessageheading); + private: + const ::messages::VehicleMessageHeading& _internal_vehiclemessageheading() const; + ::messages::VehicleMessageHeading* _internal_mutable_vehiclemessageheading(); + public: + void unsafe_arena_set_allocated_vehiclemessageheading( + ::messages::VehicleMessageHeading* vehiclemessageheading); + ::messages::VehicleMessageHeading* unsafe_arena_release_vehiclemessageheading(); + // @@protoc_insertion_point(class_scope:messages.PublishData) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::messages::dataPayload > datapayload_; + ::messages::VehicleMessageHeading* vehiclemessageheading_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_messages_2fVehicleIntelligentDataCollector_2eproto; +};// ------------------------------------------------------------------- + +class dataPayload final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:messages.dataPayload) */ { + public: + inline dataPayload() : dataPayload(nullptr) {} + ~dataPayload() override; + explicit PROTOBUF_CONSTEXPR dataPayload(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + dataPayload(const dataPayload& from); + dataPayload(dataPayload&& from) noexcept + : dataPayload() { + *this = ::std::move(from); + } + + inline dataPayload& operator=(const dataPayload& from) { + CopyFrom(from); + return *this; + } + inline dataPayload& operator=(dataPayload&& 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 dataPayload& default_instance() { + return *internal_default_instance(); + } + static inline const dataPayload* internal_default_instance() { + return reinterpret_cast( + &_dataPayload_default_instance_); + } + static constexpr int kIndexInFileMessages = + 1; + + friend void swap(dataPayload& a, dataPayload& b) { + a.Swap(&b); + } + inline void Swap(dataPayload* 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(dataPayload* other) { + if (other == this) return; + ABSL_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + dataPayload* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const dataPayload& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const dataPayload& from) { + dataPayload::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); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(dataPayload* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::absl::string_view FullMessageName() { + return "messages.dataPayload"; + } + protected: + explicit dataPayload(::PROTOBUF_NAMESPACE_ID::Arena* arena); + 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 { + kKeyFieldNumber = 1, + kStringValueFieldNumber = 2, + kBytesValueFieldNumber = 7, + kDoubleValueFieldNumber = 3, + kIntLongValueFieldNumber = 5, + kIntShortValueFieldNumber = 4, + kBoolValueFieldNumber = 6, + }; + // string key = 1; + void clear_key() ; + const std::string& key() const; + + + + + template + void set_key(Arg_&& arg, Args_... args); + std::string* mutable_key(); + PROTOBUF_NODISCARD std::string* release_key(); + void set_allocated_key(std::string* ptr); + + private: + const std::string& _internal_key() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_key( + const std::string& value); + std::string* _internal_mutable_key(); + + public: + // string stringValue = 2; + void clear_stringvalue() ; + const std::string& stringvalue() const; + + + + + template + void set_stringvalue(Arg_&& arg, Args_... args); + std::string* mutable_stringvalue(); + PROTOBUF_NODISCARD std::string* release_stringvalue(); + void set_allocated_stringvalue(std::string* ptr); + + private: + const std::string& _internal_stringvalue() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_stringvalue( + const std::string& value); + std::string* _internal_mutable_stringvalue(); + + public: + // bytes bytesValue = 7; + void clear_bytesvalue() ; + const std::string& bytesvalue() const; + + + + + template + void set_bytesvalue(Arg_&& arg, Args_... args); + std::string* mutable_bytesvalue(); + PROTOBUF_NODISCARD std::string* release_bytesvalue(); + void set_allocated_bytesvalue(std::string* ptr); + + private: + const std::string& _internal_bytesvalue() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_bytesvalue( + const std::string& value); + std::string* _internal_mutable_bytesvalue(); + + public: + // double doubleValue = 3; + void clear_doublevalue() ; + double doublevalue() const; + void set_doublevalue(double value); + + private: + double _internal_doublevalue() const; + void _internal_set_doublevalue(double value); + + public: + // int64 intLongValue = 5; + void clear_intlongvalue() ; + ::int64_t intlongvalue() const; + void set_intlongvalue(::int64_t value); + + private: + ::int64_t _internal_intlongvalue() const; + void _internal_set_intlongvalue(::int64_t value); + + public: + // int32 intShortValue = 4; + void clear_intshortvalue() ; + ::int32_t intshortvalue() const; + void set_intshortvalue(::int32_t value); + + private: + ::int32_t _internal_intshortvalue() const; + void _internal_set_intshortvalue(::int32_t value); + + public: + // bool boolValue = 6; + void clear_boolvalue() ; + bool boolvalue() const; + void set_boolvalue(bool value); + + private: + bool _internal_boolvalue() const; + void _internal_set_boolvalue(bool value); + + public: + // @@protoc_insertion_point(class_scope:messages.dataPayload) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr key_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr stringvalue_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr bytesvalue_; + double doublevalue_; + ::int64_t intlongvalue_; + ::int32_t intshortvalue_; + bool boolvalue_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_messages_2fVehicleIntelligentDataCollector_2eproto; +};// ------------------------------------------------------------------- + +class PublishDataCollectionDescriptor final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:messages.PublishDataCollectionDescriptor) */ { + public: + inline PublishDataCollectionDescriptor() : PublishDataCollectionDescriptor(nullptr) {} + ~PublishDataCollectionDescriptor() override; + explicit PROTOBUF_CONSTEXPR PublishDataCollectionDescriptor(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + PublishDataCollectionDescriptor(const PublishDataCollectionDescriptor& from); + PublishDataCollectionDescriptor(PublishDataCollectionDescriptor&& from) noexcept + : PublishDataCollectionDescriptor() { + *this = ::std::move(from); + } + + inline PublishDataCollectionDescriptor& operator=(const PublishDataCollectionDescriptor& from) { + CopyFrom(from); + return *this; + } + inline PublishDataCollectionDescriptor& operator=(PublishDataCollectionDescriptor&& 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 PublishDataCollectionDescriptor& default_instance() { + return *internal_default_instance(); + } + static inline const PublishDataCollectionDescriptor* internal_default_instance() { + return reinterpret_cast( + &_PublishDataCollectionDescriptor_default_instance_); + } + static constexpr int kIndexInFileMessages = + 2; + + friend void swap(PublishDataCollectionDescriptor& a, PublishDataCollectionDescriptor& b) { + a.Swap(&b); + } + inline void Swap(PublishDataCollectionDescriptor* 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(PublishDataCollectionDescriptor* other) { + if (other == this) return; + ABSL_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + PublishDataCollectionDescriptor* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const PublishDataCollectionDescriptor& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const PublishDataCollectionDescriptor& from) { + PublishDataCollectionDescriptor::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); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(PublishDataCollectionDescriptor* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::absl::string_view FullMessageName() { + return "messages.PublishDataCollectionDescriptor"; + } + protected: + explicit PublishDataCollectionDescriptor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + 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 { + kDataCollectionSchemeFieldNumber = 1, + }; + // bytes dataCollectionScheme = 1; + void clear_datacollectionscheme() ; + const std::string& datacollectionscheme() const; + + + + + template + void set_datacollectionscheme(Arg_&& arg, Args_... args); + std::string* mutable_datacollectionscheme(); + PROTOBUF_NODISCARD std::string* release_datacollectionscheme(); + void set_allocated_datacollectionscheme(std::string* ptr); + + private: + const std::string& _internal_datacollectionscheme() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_datacollectionscheme( + const std::string& value); + std::string* _internal_mutable_datacollectionscheme(); + + public: + // @@protoc_insertion_point(class_scope:messages.PublishDataCollectionDescriptor) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr datacollectionscheme_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_messages_2fVehicleIntelligentDataCollector_2eproto; +};// ------------------------------------------------------------------- + +class PublishVehicleModelMapping final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:messages.PublishVehicleModelMapping) */ { + public: + inline PublishVehicleModelMapping() : PublishVehicleModelMapping(nullptr) {} + ~PublishVehicleModelMapping() override; + explicit PROTOBUF_CONSTEXPR PublishVehicleModelMapping(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + PublishVehicleModelMapping(const PublishVehicleModelMapping& from); + PublishVehicleModelMapping(PublishVehicleModelMapping&& from) noexcept + : PublishVehicleModelMapping() { + *this = ::std::move(from); + } + + inline PublishVehicleModelMapping& operator=(const PublishVehicleModelMapping& from) { + CopyFrom(from); + return *this; + } + inline PublishVehicleModelMapping& operator=(PublishVehicleModelMapping&& 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 PublishVehicleModelMapping& default_instance() { + return *internal_default_instance(); + } + static inline const PublishVehicleModelMapping* internal_default_instance() { + return reinterpret_cast( + &_PublishVehicleModelMapping_default_instance_); + } + static constexpr int kIndexInFileMessages = + 3; + + friend void swap(PublishVehicleModelMapping& a, PublishVehicleModelMapping& b) { + a.Swap(&b); + } + inline void Swap(PublishVehicleModelMapping* 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(PublishVehicleModelMapping* other) { + if (other == this) return; + ABSL_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + PublishVehicleModelMapping* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const PublishVehicleModelMapping& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const PublishVehicleModelMapping& from) { + PublishVehicleModelMapping::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); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(PublishVehicleModelMapping* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::absl::string_view FullMessageName() { + return "messages.PublishVehicleModelMapping"; + } + protected: + explicit PublishVehicleModelMapping(::PROTOBUF_NAMESPACE_ID::Arena* arena); + 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 { + kDataCollectionSchemeFieldNumber = 1, + }; + // bytes dataCollectionScheme = 1; + void clear_datacollectionscheme() ; + const std::string& datacollectionscheme() const; + + + + + template + void set_datacollectionscheme(Arg_&& arg, Args_... args); + std::string* mutable_datacollectionscheme(); + PROTOBUF_NODISCARD std::string* release_datacollectionscheme(); + void set_allocated_datacollectionscheme(std::string* ptr); + + private: + const std::string& _internal_datacollectionscheme() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_datacollectionscheme( + const std::string& value); + std::string* _internal_mutable_datacollectionscheme(); + + public: + // @@protoc_insertion_point(class_scope:messages.PublishVehicleModelMapping) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr datacollectionscheme_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_messages_2fVehicleIntelligentDataCollector_2eproto; +}; + +// =================================================================== + + + + +// =================================================================== + + +#ifdef __GNUC__ +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wstrict-aliasing" +#endif // __GNUC__ +// ------------------------------------------------------------------- + +// PublishData + +// .messages.VehicleMessageHeading vehicleMessageHeading = 1; +inline bool PublishData::_internal_has_vehiclemessageheading() const { + return this != internal_default_instance() && _impl_.vehiclemessageheading_ != nullptr; +} +inline bool PublishData::has_vehiclemessageheading() const { + return _internal_has_vehiclemessageheading(); +} +inline const ::messages::VehicleMessageHeading& PublishData::_internal_vehiclemessageheading() const { + const ::messages::VehicleMessageHeading* p = _impl_.vehiclemessageheading_; + return p != nullptr ? *p : reinterpret_cast( + ::messages::_VehicleMessageHeading_default_instance_); +} +inline const ::messages::VehicleMessageHeading& PublishData::vehiclemessageheading() const { + // @@protoc_insertion_point(field_get:messages.PublishData.vehicleMessageHeading) + return _internal_vehiclemessageheading(); +} +inline void PublishData::unsafe_arena_set_allocated_vehiclemessageheading( + ::messages::VehicleMessageHeading* vehiclemessageheading) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.vehiclemessageheading_); + } + _impl_.vehiclemessageheading_ = vehiclemessageheading; + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:messages.PublishData.vehicleMessageHeading) +} +inline ::messages::VehicleMessageHeading* PublishData::release_vehiclemessageheading() { + + ::messages::VehicleMessageHeading* temp = _impl_.vehiclemessageheading_; + _impl_.vehiclemessageheading_ = 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::VehicleMessageHeading* PublishData::unsafe_arena_release_vehiclemessageheading() { + // @@protoc_insertion_point(field_release:messages.PublishData.vehicleMessageHeading) + + ::messages::VehicleMessageHeading* temp = _impl_.vehiclemessageheading_; + _impl_.vehiclemessageheading_ = nullptr; + return temp; +} +inline ::messages::VehicleMessageHeading* PublishData::_internal_mutable_vehiclemessageheading() { + + if (_impl_.vehiclemessageheading_ == nullptr) { + auto* p = CreateMaybeMessage<::messages::VehicleMessageHeading>(GetArenaForAllocation()); + _impl_.vehiclemessageheading_ = p; + } + return _impl_.vehiclemessageheading_; +} +inline ::messages::VehicleMessageHeading* PublishData::mutable_vehiclemessageheading() { + ::messages::VehicleMessageHeading* _msg = _internal_mutable_vehiclemessageheading(); + // @@protoc_insertion_point(field_mutable:messages.PublishData.vehicleMessageHeading) + return _msg; +} +inline void PublishData::set_allocated_vehiclemessageheading(::messages::VehicleMessageHeading* vehiclemessageheading) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.vehiclemessageheading_); + } + if (vehiclemessageheading) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena( + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(vehiclemessageheading)); + if (message_arena != submessage_arena) { + vehiclemessageheading = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, vehiclemessageheading, submessage_arena); + } + + } else { + + } + _impl_.vehiclemessageheading_ = vehiclemessageheading; + // @@protoc_insertion_point(field_set_allocated:messages.PublishData.vehicleMessageHeading) +} + +// repeated .messages.dataPayload DataPayload = 2; +inline int PublishData::_internal_datapayload_size() const { + return _impl_.datapayload_.size(); +} +inline int PublishData::datapayload_size() const { + return _internal_datapayload_size(); +} +inline void PublishData::clear_datapayload() { + _impl_.datapayload_.Clear(); +} +inline ::messages::dataPayload* PublishData::mutable_datapayload(int index) { + // @@protoc_insertion_point(field_mutable:messages.PublishData.DataPayload) + return _impl_.datapayload_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::messages::dataPayload >* +PublishData::mutable_datapayload() { + // @@protoc_insertion_point(field_mutable_list:messages.PublishData.DataPayload) + return &_impl_.datapayload_; +} +inline const ::messages::dataPayload& PublishData::_internal_datapayload(int index) const { + return _impl_.datapayload_.Get(index); +} +inline const ::messages::dataPayload& PublishData::datapayload(int index) const { + // @@protoc_insertion_point(field_get:messages.PublishData.DataPayload) + return _internal_datapayload(index); +} +inline ::messages::dataPayload* PublishData::_internal_add_datapayload() { + return _impl_.datapayload_.Add(); +} +inline ::messages::dataPayload* PublishData::add_datapayload() { + ::messages::dataPayload* _add = _internal_add_datapayload(); + // @@protoc_insertion_point(field_add:messages.PublishData.DataPayload) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::messages::dataPayload >& +PublishData::datapayload() const { + // @@protoc_insertion_point(field_list:messages.PublishData.DataPayload) + return _impl_.datapayload_; +} + +// ------------------------------------------------------------------- + +// dataPayload + +// string key = 1; +inline void dataPayload::clear_key() { + _impl_.key_.ClearToEmpty(); +} +inline const std::string& dataPayload::key() const { + // @@protoc_insertion_point(field_get:messages.dataPayload.key) + return _internal_key(); +} +template +inline PROTOBUF_ALWAYS_INLINE void dataPayload::set_key(Arg_&& arg, + Args_... args) { + ; + _impl_.key_.Set(static_cast(arg), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:messages.dataPayload.key) +} +inline std::string* dataPayload::mutable_key() { + std::string* _s = _internal_mutable_key(); + // @@protoc_insertion_point(field_mutable:messages.dataPayload.key) + return _s; +} +inline const std::string& dataPayload::_internal_key() const { + return _impl_.key_.Get(); +} +inline void dataPayload::_internal_set_key(const std::string& value) { + ; + + + _impl_.key_.Set(value, GetArenaForAllocation()); +} +inline std::string* dataPayload::_internal_mutable_key() { + ; + return _impl_.key_.Mutable( GetArenaForAllocation()); +} +inline std::string* dataPayload::release_key() { + // @@protoc_insertion_point(field_release:messages.dataPayload.key) + return _impl_.key_.Release(); +} +inline void dataPayload::set_allocated_key(std::string* value) { + _impl_.key_.SetAllocated(value, GetArenaForAllocation()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.key_.IsDefault()) { + _impl_.key_.Set("", GetArenaForAllocation()); + } + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:messages.dataPayload.key) +} + +// string stringValue = 2; +inline void dataPayload::clear_stringvalue() { + _impl_.stringvalue_.ClearToEmpty(); +} +inline const std::string& dataPayload::stringvalue() const { + // @@protoc_insertion_point(field_get:messages.dataPayload.stringValue) + return _internal_stringvalue(); +} +template +inline PROTOBUF_ALWAYS_INLINE void dataPayload::set_stringvalue(Arg_&& arg, + Args_... args) { + ; + _impl_.stringvalue_.Set(static_cast(arg), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:messages.dataPayload.stringValue) +} +inline std::string* dataPayload::mutable_stringvalue() { + std::string* _s = _internal_mutable_stringvalue(); + // @@protoc_insertion_point(field_mutable:messages.dataPayload.stringValue) + return _s; +} +inline const std::string& dataPayload::_internal_stringvalue() const { + return _impl_.stringvalue_.Get(); +} +inline void dataPayload::_internal_set_stringvalue(const std::string& value) { + ; + + + _impl_.stringvalue_.Set(value, GetArenaForAllocation()); +} +inline std::string* dataPayload::_internal_mutable_stringvalue() { + ; + return _impl_.stringvalue_.Mutable( GetArenaForAllocation()); +} +inline std::string* dataPayload::release_stringvalue() { + // @@protoc_insertion_point(field_release:messages.dataPayload.stringValue) + return _impl_.stringvalue_.Release(); +} +inline void dataPayload::set_allocated_stringvalue(std::string* value) { + _impl_.stringvalue_.SetAllocated(value, GetArenaForAllocation()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.stringvalue_.IsDefault()) { + _impl_.stringvalue_.Set("", GetArenaForAllocation()); + } + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:messages.dataPayload.stringValue) +} + +// double doubleValue = 3; +inline void dataPayload::clear_doublevalue() { + _impl_.doublevalue_ = 0; +} +inline double dataPayload::doublevalue() const { + // @@protoc_insertion_point(field_get:messages.dataPayload.doubleValue) + return _internal_doublevalue(); +} +inline void dataPayload::set_doublevalue(double value) { + _internal_set_doublevalue(value); + // @@protoc_insertion_point(field_set:messages.dataPayload.doubleValue) +} +inline double dataPayload::_internal_doublevalue() const { + return _impl_.doublevalue_; +} +inline void dataPayload::_internal_set_doublevalue(double value) { + ; + _impl_.doublevalue_ = value; +} + +// int32 intShortValue = 4; +inline void dataPayload::clear_intshortvalue() { + _impl_.intshortvalue_ = 0; +} +inline ::int32_t dataPayload::intshortvalue() const { + // @@protoc_insertion_point(field_get:messages.dataPayload.intShortValue) + return _internal_intshortvalue(); +} +inline void dataPayload::set_intshortvalue(::int32_t value) { + _internal_set_intshortvalue(value); + // @@protoc_insertion_point(field_set:messages.dataPayload.intShortValue) +} +inline ::int32_t dataPayload::_internal_intshortvalue() const { + return _impl_.intshortvalue_; +} +inline void dataPayload::_internal_set_intshortvalue(::int32_t value) { + ; + _impl_.intshortvalue_ = value; +} + +// int64 intLongValue = 5; +inline void dataPayload::clear_intlongvalue() { + _impl_.intlongvalue_ = ::int64_t{0}; +} +inline ::int64_t dataPayload::intlongvalue() const { + // @@protoc_insertion_point(field_get:messages.dataPayload.intLongValue) + return _internal_intlongvalue(); +} +inline void dataPayload::set_intlongvalue(::int64_t value) { + _internal_set_intlongvalue(value); + // @@protoc_insertion_point(field_set:messages.dataPayload.intLongValue) +} +inline ::int64_t dataPayload::_internal_intlongvalue() const { + return _impl_.intlongvalue_; +} +inline void dataPayload::_internal_set_intlongvalue(::int64_t value) { + ; + _impl_.intlongvalue_ = value; +} + +// bool boolValue = 6; +inline void dataPayload::clear_boolvalue() { + _impl_.boolvalue_ = false; +} +inline bool dataPayload::boolvalue() const { + // @@protoc_insertion_point(field_get:messages.dataPayload.boolValue) + return _internal_boolvalue(); +} +inline void dataPayload::set_boolvalue(bool value) { + _internal_set_boolvalue(value); + // @@protoc_insertion_point(field_set:messages.dataPayload.boolValue) +} +inline bool dataPayload::_internal_boolvalue() const { + return _impl_.boolvalue_; +} +inline void dataPayload::_internal_set_boolvalue(bool value) { + ; + _impl_.boolvalue_ = value; +} + +// bytes bytesValue = 7; +inline void dataPayload::clear_bytesvalue() { + _impl_.bytesvalue_.ClearToEmpty(); +} +inline const std::string& dataPayload::bytesvalue() const { + // @@protoc_insertion_point(field_get:messages.dataPayload.bytesValue) + return _internal_bytesvalue(); +} +template +inline PROTOBUF_ALWAYS_INLINE void dataPayload::set_bytesvalue(Arg_&& arg, + Args_... args) { + ; + _impl_.bytesvalue_.SetBytes(static_cast(arg), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:messages.dataPayload.bytesValue) +} +inline std::string* dataPayload::mutable_bytesvalue() { + std::string* _s = _internal_mutable_bytesvalue(); + // @@protoc_insertion_point(field_mutable:messages.dataPayload.bytesValue) + return _s; +} +inline const std::string& dataPayload::_internal_bytesvalue() const { + return _impl_.bytesvalue_.Get(); +} +inline void dataPayload::_internal_set_bytesvalue(const std::string& value) { + ; + + + _impl_.bytesvalue_.Set(value, GetArenaForAllocation()); +} +inline std::string* dataPayload::_internal_mutable_bytesvalue() { + ; + return _impl_.bytesvalue_.Mutable( GetArenaForAllocation()); +} +inline std::string* dataPayload::release_bytesvalue() { + // @@protoc_insertion_point(field_release:messages.dataPayload.bytesValue) + return _impl_.bytesvalue_.Release(); +} +inline void dataPayload::set_allocated_bytesvalue(std::string* value) { + _impl_.bytesvalue_.SetAllocated(value, GetArenaForAllocation()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.bytesvalue_.IsDefault()) { + _impl_.bytesvalue_.Set("", GetArenaForAllocation()); + } + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:messages.dataPayload.bytesValue) +} + +// ------------------------------------------------------------------- + +// PublishDataCollectionDescriptor + +// bytes dataCollectionScheme = 1; +inline void PublishDataCollectionDescriptor::clear_datacollectionscheme() { + _impl_.datacollectionscheme_.ClearToEmpty(); +} +inline const std::string& PublishDataCollectionDescriptor::datacollectionscheme() const { + // @@protoc_insertion_point(field_get:messages.PublishDataCollectionDescriptor.dataCollectionScheme) + return _internal_datacollectionscheme(); +} +template +inline PROTOBUF_ALWAYS_INLINE void PublishDataCollectionDescriptor::set_datacollectionscheme(Arg_&& arg, + Args_... args) { + ; + _impl_.datacollectionscheme_.SetBytes(static_cast(arg), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:messages.PublishDataCollectionDescriptor.dataCollectionScheme) +} +inline std::string* PublishDataCollectionDescriptor::mutable_datacollectionscheme() { + std::string* _s = _internal_mutable_datacollectionscheme(); + // @@protoc_insertion_point(field_mutable:messages.PublishDataCollectionDescriptor.dataCollectionScheme) + return _s; +} +inline const std::string& PublishDataCollectionDescriptor::_internal_datacollectionscheme() const { + return _impl_.datacollectionscheme_.Get(); +} +inline void PublishDataCollectionDescriptor::_internal_set_datacollectionscheme(const std::string& value) { + ; + + + _impl_.datacollectionscheme_.Set(value, GetArenaForAllocation()); +} +inline std::string* PublishDataCollectionDescriptor::_internal_mutable_datacollectionscheme() { + ; + return _impl_.datacollectionscheme_.Mutable( GetArenaForAllocation()); +} +inline std::string* PublishDataCollectionDescriptor::release_datacollectionscheme() { + // @@protoc_insertion_point(field_release:messages.PublishDataCollectionDescriptor.dataCollectionScheme) + return _impl_.datacollectionscheme_.Release(); +} +inline void PublishDataCollectionDescriptor::set_allocated_datacollectionscheme(std::string* value) { + _impl_.datacollectionscheme_.SetAllocated(value, GetArenaForAllocation()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.datacollectionscheme_.IsDefault()) { + _impl_.datacollectionscheme_.Set("", GetArenaForAllocation()); + } + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:messages.PublishDataCollectionDescriptor.dataCollectionScheme) +} + +// ------------------------------------------------------------------- + +// PublishVehicleModelMapping + +// bytes dataCollectionScheme = 1; +inline void PublishVehicleModelMapping::clear_datacollectionscheme() { + _impl_.datacollectionscheme_.ClearToEmpty(); +} +inline const std::string& PublishVehicleModelMapping::datacollectionscheme() const { + // @@protoc_insertion_point(field_get:messages.PublishVehicleModelMapping.dataCollectionScheme) + return _internal_datacollectionscheme(); +} +template +inline PROTOBUF_ALWAYS_INLINE void PublishVehicleModelMapping::set_datacollectionscheme(Arg_&& arg, + Args_... args) { + ; + _impl_.datacollectionscheme_.SetBytes(static_cast(arg), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:messages.PublishVehicleModelMapping.dataCollectionScheme) +} +inline std::string* PublishVehicleModelMapping::mutable_datacollectionscheme() { + std::string* _s = _internal_mutable_datacollectionscheme(); + // @@protoc_insertion_point(field_mutable:messages.PublishVehicleModelMapping.dataCollectionScheme) + return _s; +} +inline const std::string& PublishVehicleModelMapping::_internal_datacollectionscheme() const { + return _impl_.datacollectionscheme_.Get(); +} +inline void PublishVehicleModelMapping::_internal_set_datacollectionscheme(const std::string& value) { + ; + + + _impl_.datacollectionscheme_.Set(value, GetArenaForAllocation()); +} +inline std::string* PublishVehicleModelMapping::_internal_mutable_datacollectionscheme() { + ; + return _impl_.datacollectionscheme_.Mutable( GetArenaForAllocation()); +} +inline std::string* PublishVehicleModelMapping::release_datacollectionscheme() { + // @@protoc_insertion_point(field_release:messages.PublishVehicleModelMapping.dataCollectionScheme) + return _impl_.datacollectionscheme_.Release(); +} +inline void PublishVehicleModelMapping::set_allocated_datacollectionscheme(std::string* value) { + _impl_.datacollectionscheme_.SetAllocated(value, GetArenaForAllocation()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.datacollectionscheme_.IsDefault()) { + _impl_.datacollectionscheme_.Set("", GetArenaForAllocation()); + } + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:messages.PublishVehicleModelMapping.dataCollectionScheme) +} + +#ifdef __GNUC__ +#pragma GCC diagnostic pop +#endif // __GNUC__ + +// @@protoc_insertion_point(namespace_scope) +} // namespace messages + + +// @@protoc_insertion_point(global_scope) + +#include "google/protobuf/port_undef.inc" + +#endif // GOOGLE_PROTOBUF_INCLUDED_messages_2fVehicleIntelligentDataCollector_2eproto_2epb_2eh diff --git a/bin/main/messages/VehicleMessageHeader$VehicleMessageHeading$1.class b/bin/main/messages/VehicleMessageHeader$VehicleMessageHeading$1.class new file mode 100644 index 0000000..1fedd93 Binary files /dev/null and b/bin/main/messages/VehicleMessageHeader$VehicleMessageHeading$1.class differ diff --git a/bin/main/messages/VehicleMessageHeader$VehicleMessageHeading$Builder.class b/bin/main/messages/VehicleMessageHeader$VehicleMessageHeading$Builder.class new file mode 100644 index 0000000..b86f78d Binary files /dev/null and b/bin/main/messages/VehicleMessageHeader$VehicleMessageHeading$Builder.class differ diff --git a/bin/main/messages/VehicleMessageHeader$VehicleMessageHeading.class b/bin/main/messages/VehicleMessageHeader$VehicleMessageHeading.class new file mode 100644 index 0000000..e18b1cb Binary files /dev/null and b/bin/main/messages/VehicleMessageHeader$VehicleMessageHeading.class differ diff --git a/bin/main/messages/VehicleMessageHeader$VehicleMessageHeadingOrBuilder.class b/bin/main/messages/VehicleMessageHeader$VehicleMessageHeadingOrBuilder.class new file mode 100644 index 0000000..f28e2f1 Binary files /dev/null and b/bin/main/messages/VehicleMessageHeader$VehicleMessageHeadingOrBuilder.class differ diff --git a/bin/main/messages/VehicleMessageHeader$lat_long$1.class b/bin/main/messages/VehicleMessageHeader$lat_long$1.class new file mode 100644 index 0000000..33c05a0 Binary files /dev/null and b/bin/main/messages/VehicleMessageHeader$lat_long$1.class differ diff --git a/bin/main/messages/VehicleMessageHeader$lat_long$Builder.class b/bin/main/messages/VehicleMessageHeader$lat_long$Builder.class new file mode 100644 index 0000000..5aac926 Binary files /dev/null and b/bin/main/messages/VehicleMessageHeader$lat_long$Builder.class differ diff --git a/bin/main/messages/VehicleMessageHeader$lat_long.class b/bin/main/messages/VehicleMessageHeader$lat_long.class new file mode 100644 index 0000000..c1d47ee Binary files /dev/null and b/bin/main/messages/VehicleMessageHeader$lat_long.class differ diff --git a/bin/main/messages/VehicleMessageHeader$lat_longOrBuilder.class b/bin/main/messages/VehicleMessageHeader$lat_longOrBuilder.class new file mode 100644 index 0000000..45ae272 Binary files /dev/null and b/bin/main/messages/VehicleMessageHeader$lat_longOrBuilder.class differ diff --git a/bin/main/messages/VehicleMessageHeader.class b/bin/main/messages/VehicleMessageHeader.class new file mode 100644 index 0000000..49a43f1 Binary files /dev/null and b/bin/main/messages/VehicleMessageHeader.class differ 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 +#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(&_impl_.protocol_version_) - + reinterpret_cast(&_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(&_impl_.protocol_version_) - + reinterpret_cast(&_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(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(_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(_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(&to_msg); + auto& from = static_cast(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(&_impl_.location_), + reinterpret_cast(&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(&_impl_.longitude_) - + reinterpret_cast(&_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(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(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(&to_msg); + auto& from = static_cast(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(&_impl_.latitude_), + reinterpret_cast(&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" diff --git a/bin/main/messages/VehicleMessageHeader.pb.h b/bin/main/messages/VehicleMessageHeader.pb.h new file mode 100644 index 0000000..53aa714 --- /dev/null +++ b/bin/main/messages/VehicleMessageHeader.pb.h @@ -0,0 +1,812 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: messages/VehicleMessageHeader.proto + +#ifndef GOOGLE_PROTOBUF_INCLUDED_messages_2fVehicleMessageHeader_2eproto_2epb_2eh +#define GOOGLE_PROTOBUF_INCLUDED_messages_2fVehicleMessageHeader_2eproto_2epb_2eh + +#include +#include +#include + +#include "google/protobuf/port_def.inc" +#if PROTOBUF_VERSION < 4022000 +#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 4022000 < 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_util.h" +#include "google/protobuf/metadata_lite.h" +#include "google/protobuf/generated_message_reflection.h" +#include "google/protobuf/message.h" +#include "google/protobuf/repeated_field.h" // IWYU pragma: export +#include "google/protobuf/extension_set.h" // IWYU pragma: export +#include "google/protobuf/unknown_field_set.h" +// @@protoc_insertion_point(includes) + +// Must be included last. +#include "google/protobuf/port_def.inc" + +#define PROTOBUF_INTERNAL_EXPORT_messages_2fVehicleMessageHeader_2eproto + +PROTOBUF_NAMESPACE_OPEN +namespace internal { +class AnyMetadata; +} // namespace internal +PROTOBUF_NAMESPACE_CLOSE + +// Internal implementation detail -- do not use these members. +struct TableStruct_messages_2fVehicleMessageHeader_2eproto { + static const ::uint32_t offsets[]; +}; +extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable + descriptor_table_messages_2fVehicleMessageHeader_2eproto; +namespace messages { +class VehicleMessageHeading; +struct VehicleMessageHeadingDefaultTypeInternal; +extern VehicleMessageHeadingDefaultTypeInternal _VehicleMessageHeading_default_instance_; +class lat_long; +struct lat_longDefaultTypeInternal; +extern lat_longDefaultTypeInternal _lat_long_default_instance_; +} // namespace messages +PROTOBUF_NAMESPACE_OPEN +template <> +::messages::VehicleMessageHeading* Arena::CreateMaybeMessage<::messages::VehicleMessageHeading>(Arena*); +template <> +::messages::lat_long* Arena::CreateMaybeMessage<::messages::lat_long>(Arena*); +PROTOBUF_NAMESPACE_CLOSE + +namespace messages { + +// =================================================================== + + +// ------------------------------------------------------------------- + +class VehicleMessageHeading final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:messages.VehicleMessageHeading) */ { + public: + inline VehicleMessageHeading() : VehicleMessageHeading(nullptr) {} + ~VehicleMessageHeading() override; + explicit PROTOBUF_CONSTEXPR VehicleMessageHeading(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + VehicleMessageHeading(const VehicleMessageHeading& from); + VehicleMessageHeading(VehicleMessageHeading&& from) noexcept + : VehicleMessageHeading() { + *this = ::std::move(from); + } + + inline VehicleMessageHeading& operator=(const VehicleMessageHeading& from) { + CopyFrom(from); + return *this; + } + inline VehicleMessageHeading& operator=(VehicleMessageHeading&& 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 VehicleMessageHeading& default_instance() { + return *internal_default_instance(); + } + static inline const VehicleMessageHeading* internal_default_instance() { + return reinterpret_cast( + &_VehicleMessageHeading_default_instance_); + } + static constexpr int kIndexInFileMessages = + 0; + + friend void swap(VehicleMessageHeading& a, VehicleMessageHeading& b) { + a.Swap(&b); + } + inline void Swap(VehicleMessageHeading* 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(VehicleMessageHeading* other) { + if (other == this) return; + ABSL_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + VehicleMessageHeading* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const VehicleMessageHeading& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const VehicleMessageHeading& from) { + VehicleMessageHeading::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); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(VehicleMessageHeading* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::absl::string_view FullMessageName() { + return "messages.VehicleMessageHeading"; + } + protected: + explicit VehicleMessageHeading(::PROTOBUF_NAMESPACE_ID::Arena* arena); + 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 { + kVehicleIdentityFieldNumber = 3, + kVehicleDeviceIdFieldNumber = 7, + kLocationFieldNumber = 6, + kMessageIdFieldNumber = 1, + kCorrelationIdFieldNumber = 2, + kMessageTimestampFieldNumber = 4, + kProtocolVersionFieldNumber = 5, + }; + // string vehicle_identity = 3; + void clear_vehicle_identity() ; + const std::string& vehicle_identity() const; + + + + + template + void set_vehicle_identity(Arg_&& arg, Args_... args); + std::string* mutable_vehicle_identity(); + PROTOBUF_NODISCARD std::string* release_vehicle_identity(); + void set_allocated_vehicle_identity(std::string* ptr); + + private: + const std::string& _internal_vehicle_identity() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_vehicle_identity( + const std::string& value); + std::string* _internal_mutable_vehicle_identity(); + + public: + // string vehicle_device_id = 7; + void clear_vehicle_device_id() ; + const std::string& vehicle_device_id() const; + + + + + template + void set_vehicle_device_id(Arg_&& arg, Args_... args); + std::string* mutable_vehicle_device_id(); + PROTOBUF_NODISCARD std::string* release_vehicle_device_id(); + void set_allocated_vehicle_device_id(std::string* ptr); + + private: + const std::string& _internal_vehicle_device_id() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_vehicle_device_id( + const std::string& value); + std::string* _internal_mutable_vehicle_device_id(); + + public: + // .messages.lat_long location = 6; + bool has_location() const; + private: + bool _internal_has_location() const; + + public: + void clear_location() ; + const ::messages::lat_long& location() const; + PROTOBUF_NODISCARD ::messages::lat_long* release_location(); + ::messages::lat_long* mutable_location(); + void set_allocated_location(::messages::lat_long* location); + private: + const ::messages::lat_long& _internal_location() const; + ::messages::lat_long* _internal_mutable_location(); + public: + void unsafe_arena_set_allocated_location( + ::messages::lat_long* location); + ::messages::lat_long* unsafe_arena_release_location(); + // int32 message_id = 1; + void clear_message_id() ; + ::int32_t message_id() const; + void set_message_id(::int32_t value); + + private: + ::int32_t _internal_message_id() const; + void _internal_set_message_id(::int32_t value); + + public: + // int32 correlation_id = 2; + void clear_correlation_id() ; + ::int32_t correlation_id() const; + void set_correlation_id(::int32_t value); + + private: + ::int32_t _internal_correlation_id() const; + void _internal_set_correlation_id(::int32_t value); + + public: + // int64 message_timestamp = 4; + void clear_message_timestamp() ; + ::int64_t message_timestamp() const; + void set_message_timestamp(::int64_t value); + + private: + ::int64_t _internal_message_timestamp() const; + void _internal_set_message_timestamp(::int64_t value); + + public: + // double protocol_version = 5; + void clear_protocol_version() ; + double protocol_version() const; + void set_protocol_version(double value); + + private: + double _internal_protocol_version() const; + void _internal_set_protocol_version(double value); + + public: + // @@protoc_insertion_point(class_scope:messages.VehicleMessageHeading) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr vehicle_identity_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr vehicle_device_id_; + ::messages::lat_long* location_; + ::int32_t message_id_; + ::int32_t correlation_id_; + ::int64_t message_timestamp_; + double protocol_version_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_messages_2fVehicleMessageHeader_2eproto; +};// ------------------------------------------------------------------- + +class lat_long final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:messages.lat_long) */ { + public: + inline lat_long() : lat_long(nullptr) {} + ~lat_long() override; + explicit PROTOBUF_CONSTEXPR lat_long(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + lat_long(const lat_long& from); + lat_long(lat_long&& from) noexcept + : lat_long() { + *this = ::std::move(from); + } + + inline lat_long& operator=(const lat_long& from) { + CopyFrom(from); + return *this; + } + inline lat_long& operator=(lat_long&& 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 lat_long& default_instance() { + return *internal_default_instance(); + } + static inline const lat_long* internal_default_instance() { + return reinterpret_cast( + &_lat_long_default_instance_); + } + static constexpr int kIndexInFileMessages = + 1; + + friend void swap(lat_long& a, lat_long& b) { + a.Swap(&b); + } + inline void Swap(lat_long* 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(lat_long* other) { + if (other == this) return; + ABSL_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + lat_long* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const lat_long& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const lat_long& from) { + lat_long::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); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(lat_long* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::absl::string_view FullMessageName() { + return "messages.lat_long"; + } + protected: + explicit lat_long(::PROTOBUF_NAMESPACE_ID::Arena* arena); + 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 { + kLatitudeFieldNumber = 1, + kLongitudeFieldNumber = 2, + }; + // double latitude = 1; + void clear_latitude() ; + double latitude() const; + void set_latitude(double value); + + private: + double _internal_latitude() const; + void _internal_set_latitude(double value); + + public: + // double longitude = 2; + void clear_longitude() ; + double longitude() const; + void set_longitude(double value); + + private: + double _internal_longitude() const; + void _internal_set_longitude(double value); + + public: + // @@protoc_insertion_point(class_scope:messages.lat_long) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + double latitude_; + double longitude_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_messages_2fVehicleMessageHeader_2eproto; +}; + +// =================================================================== + + + + +// =================================================================== + + +#ifdef __GNUC__ +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wstrict-aliasing" +#endif // __GNUC__ +// ------------------------------------------------------------------- + +// VehicleMessageHeading + +// int32 message_id = 1; +inline void VehicleMessageHeading::clear_message_id() { + _impl_.message_id_ = 0; +} +inline ::int32_t VehicleMessageHeading::message_id() const { + // @@protoc_insertion_point(field_get:messages.VehicleMessageHeading.message_id) + return _internal_message_id(); +} +inline void VehicleMessageHeading::set_message_id(::int32_t value) { + _internal_set_message_id(value); + // @@protoc_insertion_point(field_set:messages.VehicleMessageHeading.message_id) +} +inline ::int32_t VehicleMessageHeading::_internal_message_id() const { + return _impl_.message_id_; +} +inline void VehicleMessageHeading::_internal_set_message_id(::int32_t value) { + ; + _impl_.message_id_ = value; +} + +// int32 correlation_id = 2; +inline void VehicleMessageHeading::clear_correlation_id() { + _impl_.correlation_id_ = 0; +} +inline ::int32_t VehicleMessageHeading::correlation_id() const { + // @@protoc_insertion_point(field_get:messages.VehicleMessageHeading.correlation_id) + return _internal_correlation_id(); +} +inline void VehicleMessageHeading::set_correlation_id(::int32_t value) { + _internal_set_correlation_id(value); + // @@protoc_insertion_point(field_set:messages.VehicleMessageHeading.correlation_id) +} +inline ::int32_t VehicleMessageHeading::_internal_correlation_id() const { + return _impl_.correlation_id_; +} +inline void VehicleMessageHeading::_internal_set_correlation_id(::int32_t value) { + ; + _impl_.correlation_id_ = value; +} + +// string vehicle_identity = 3; +inline void VehicleMessageHeading::clear_vehicle_identity() { + _impl_.vehicle_identity_.ClearToEmpty(); +} +inline const std::string& VehicleMessageHeading::vehicle_identity() const { + // @@protoc_insertion_point(field_get:messages.VehicleMessageHeading.vehicle_identity) + return _internal_vehicle_identity(); +} +template +inline PROTOBUF_ALWAYS_INLINE void VehicleMessageHeading::set_vehicle_identity(Arg_&& arg, + Args_... args) { + ; + _impl_.vehicle_identity_.Set(static_cast(arg), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:messages.VehicleMessageHeading.vehicle_identity) +} +inline std::string* VehicleMessageHeading::mutable_vehicle_identity() { + std::string* _s = _internal_mutable_vehicle_identity(); + // @@protoc_insertion_point(field_mutable:messages.VehicleMessageHeading.vehicle_identity) + return _s; +} +inline const std::string& VehicleMessageHeading::_internal_vehicle_identity() const { + return _impl_.vehicle_identity_.Get(); +} +inline void VehicleMessageHeading::_internal_set_vehicle_identity(const std::string& value) { + ; + + + _impl_.vehicle_identity_.Set(value, GetArenaForAllocation()); +} +inline std::string* VehicleMessageHeading::_internal_mutable_vehicle_identity() { + ; + return _impl_.vehicle_identity_.Mutable( GetArenaForAllocation()); +} +inline std::string* VehicleMessageHeading::release_vehicle_identity() { + // @@protoc_insertion_point(field_release:messages.VehicleMessageHeading.vehicle_identity) + return _impl_.vehicle_identity_.Release(); +} +inline void VehicleMessageHeading::set_allocated_vehicle_identity(std::string* value) { + _impl_.vehicle_identity_.SetAllocated(value, GetArenaForAllocation()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.vehicle_identity_.IsDefault()) { + _impl_.vehicle_identity_.Set("", GetArenaForAllocation()); + } + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:messages.VehicleMessageHeading.vehicle_identity) +} + +// string vehicle_device_id = 7; +inline void VehicleMessageHeading::clear_vehicle_device_id() { + _impl_.vehicle_device_id_.ClearToEmpty(); +} +inline const std::string& VehicleMessageHeading::vehicle_device_id() const { + // @@protoc_insertion_point(field_get:messages.VehicleMessageHeading.vehicle_device_id) + return _internal_vehicle_device_id(); +} +template +inline PROTOBUF_ALWAYS_INLINE void VehicleMessageHeading::set_vehicle_device_id(Arg_&& arg, + Args_... args) { + ; + _impl_.vehicle_device_id_.Set(static_cast(arg), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:messages.VehicleMessageHeading.vehicle_device_id) +} +inline std::string* VehicleMessageHeading::mutable_vehicle_device_id() { + std::string* _s = _internal_mutable_vehicle_device_id(); + // @@protoc_insertion_point(field_mutable:messages.VehicleMessageHeading.vehicle_device_id) + return _s; +} +inline const std::string& VehicleMessageHeading::_internal_vehicle_device_id() const { + return _impl_.vehicle_device_id_.Get(); +} +inline void VehicleMessageHeading::_internal_set_vehicle_device_id(const std::string& value) { + ; + + + _impl_.vehicle_device_id_.Set(value, GetArenaForAllocation()); +} +inline std::string* VehicleMessageHeading::_internal_mutable_vehicle_device_id() { + ; + return _impl_.vehicle_device_id_.Mutable( GetArenaForAllocation()); +} +inline std::string* VehicleMessageHeading::release_vehicle_device_id() { + // @@protoc_insertion_point(field_release:messages.VehicleMessageHeading.vehicle_device_id) + return _impl_.vehicle_device_id_.Release(); +} +inline void VehicleMessageHeading::set_allocated_vehicle_device_id(std::string* value) { + _impl_.vehicle_device_id_.SetAllocated(value, GetArenaForAllocation()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.vehicle_device_id_.IsDefault()) { + _impl_.vehicle_device_id_.Set("", GetArenaForAllocation()); + } + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:messages.VehicleMessageHeading.vehicle_device_id) +} + +// int64 message_timestamp = 4; +inline void VehicleMessageHeading::clear_message_timestamp() { + _impl_.message_timestamp_ = ::int64_t{0}; +} +inline ::int64_t VehicleMessageHeading::message_timestamp() const { + // @@protoc_insertion_point(field_get:messages.VehicleMessageHeading.message_timestamp) + return _internal_message_timestamp(); +} +inline void VehicleMessageHeading::set_message_timestamp(::int64_t value) { + _internal_set_message_timestamp(value); + // @@protoc_insertion_point(field_set:messages.VehicleMessageHeading.message_timestamp) +} +inline ::int64_t VehicleMessageHeading::_internal_message_timestamp() const { + return _impl_.message_timestamp_; +} +inline void VehicleMessageHeading::_internal_set_message_timestamp(::int64_t value) { + ; + _impl_.message_timestamp_ = value; +} + +// double protocol_version = 5; +inline void VehicleMessageHeading::clear_protocol_version() { + _impl_.protocol_version_ = 0; +} +inline double VehicleMessageHeading::protocol_version() const { + // @@protoc_insertion_point(field_get:messages.VehicleMessageHeading.protocol_version) + return _internal_protocol_version(); +} +inline void VehicleMessageHeading::set_protocol_version(double value) { + _internal_set_protocol_version(value); + // @@protoc_insertion_point(field_set:messages.VehicleMessageHeading.protocol_version) +} +inline double VehicleMessageHeading::_internal_protocol_version() const { + return _impl_.protocol_version_; +} +inline void VehicleMessageHeading::_internal_set_protocol_version(double value) { + ; + _impl_.protocol_version_ = value; +} + +// .messages.lat_long location = 6; +inline bool VehicleMessageHeading::_internal_has_location() const { + return this != internal_default_instance() && _impl_.location_ != nullptr; +} +inline bool VehicleMessageHeading::has_location() const { + return _internal_has_location(); +} +inline void VehicleMessageHeading::clear_location() { + if (GetArenaForAllocation() == nullptr && _impl_.location_ != nullptr) { + delete _impl_.location_; + } + _impl_.location_ = nullptr; +} +inline const ::messages::lat_long& VehicleMessageHeading::_internal_location() const { + const ::messages::lat_long* p = _impl_.location_; + return p != nullptr ? *p : reinterpret_cast( + ::messages::_lat_long_default_instance_); +} +inline const ::messages::lat_long& VehicleMessageHeading::location() const { + // @@protoc_insertion_point(field_get:messages.VehicleMessageHeading.location) + return _internal_location(); +} +inline void VehicleMessageHeading::unsafe_arena_set_allocated_location( + ::messages::lat_long* location) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.location_); + } + _impl_.location_ = location; + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:messages.VehicleMessageHeading.location) +} +inline ::messages::lat_long* VehicleMessageHeading::release_location() { + + ::messages::lat_long* temp = _impl_.location_; + _impl_.location_ = 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::lat_long* VehicleMessageHeading::unsafe_arena_release_location() { + // @@protoc_insertion_point(field_release:messages.VehicleMessageHeading.location) + + ::messages::lat_long* temp = _impl_.location_; + _impl_.location_ = nullptr; + return temp; +} +inline ::messages::lat_long* VehicleMessageHeading::_internal_mutable_location() { + + if (_impl_.location_ == nullptr) { + auto* p = CreateMaybeMessage<::messages::lat_long>(GetArenaForAllocation()); + _impl_.location_ = p; + } + return _impl_.location_; +} +inline ::messages::lat_long* VehicleMessageHeading::mutable_location() { + ::messages::lat_long* _msg = _internal_mutable_location(); + // @@protoc_insertion_point(field_mutable:messages.VehicleMessageHeading.location) + return _msg; +} +inline void VehicleMessageHeading::set_allocated_location(::messages::lat_long* location) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.location_; + } + if (location) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(location); + if (message_arena != submessage_arena) { + location = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, location, submessage_arena); + } + + } else { + + } + _impl_.location_ = location; + // @@protoc_insertion_point(field_set_allocated:messages.VehicleMessageHeading.location) +} + +// ------------------------------------------------------------------- + +// lat_long + +// double latitude = 1; +inline void lat_long::clear_latitude() { + _impl_.latitude_ = 0; +} +inline double lat_long::latitude() const { + // @@protoc_insertion_point(field_get:messages.lat_long.latitude) + return _internal_latitude(); +} +inline void lat_long::set_latitude(double value) { + _internal_set_latitude(value); + // @@protoc_insertion_point(field_set:messages.lat_long.latitude) +} +inline double lat_long::_internal_latitude() const { + return _impl_.latitude_; +} +inline void lat_long::_internal_set_latitude(double value) { + ; + _impl_.latitude_ = value; +} + +// double longitude = 2; +inline void lat_long::clear_longitude() { + _impl_.longitude_ = 0; +} +inline double lat_long::longitude() const { + // @@protoc_insertion_point(field_get:messages.lat_long.longitude) + return _internal_longitude(); +} +inline void lat_long::set_longitude(double value) { + _internal_set_longitude(value); + // @@protoc_insertion_point(field_set:messages.lat_long.longitude) +} +inline double lat_long::_internal_longitude() const { + return _impl_.longitude_; +} +inline void lat_long::_internal_set_longitude(double value) { + ; + _impl_.longitude_ = value; +} + +#ifdef __GNUC__ +#pragma GCC diagnostic pop +#endif // __GNUC__ + +// @@protoc_insertion_point(namespace_scope) +} // namespace messages + + +// @@protoc_insertion_point(global_scope) + +#include "google/protobuf/port_undef.inc" + +#endif // GOOGLE_PROTOBUF_INCLUDED_messages_2fVehicleMessageHeader_2eproto_2epb_2eh diff --git a/bin/main/messages/VehiclePrecisionLocation$PublishCurrentVehicleLocation$1.class b/bin/main/messages/VehiclePrecisionLocation$PublishCurrentVehicleLocation$1.class new file mode 100644 index 0000000..c3303f2 Binary files /dev/null and b/bin/main/messages/VehiclePrecisionLocation$PublishCurrentVehicleLocation$1.class differ diff --git a/bin/main/messages/VehiclePrecisionLocation$PublishCurrentVehicleLocation$Builder.class b/bin/main/messages/VehiclePrecisionLocation$PublishCurrentVehicleLocation$Builder.class new file mode 100644 index 0000000..fc279c5 Binary files /dev/null and b/bin/main/messages/VehiclePrecisionLocation$PublishCurrentVehicleLocation$Builder.class differ diff --git a/bin/main/messages/VehiclePrecisionLocation$PublishCurrentVehicleLocation.class b/bin/main/messages/VehiclePrecisionLocation$PublishCurrentVehicleLocation.class new file mode 100644 index 0000000..c806d7e Binary files /dev/null and b/bin/main/messages/VehiclePrecisionLocation$PublishCurrentVehicleLocation.class differ diff --git a/bin/main/messages/VehiclePrecisionLocation$PublishCurrentVehicleLocationOrBuilder.class b/bin/main/messages/VehiclePrecisionLocation$PublishCurrentVehicleLocationOrBuilder.class new file mode 100644 index 0000000..94e03d3 Binary files /dev/null and b/bin/main/messages/VehiclePrecisionLocation$PublishCurrentVehicleLocationOrBuilder.class differ diff --git a/bin/main/messages/VehiclePrecisionLocation$RequestCurrentVehicleLocationTest$1.class b/bin/main/messages/VehiclePrecisionLocation$RequestCurrentVehicleLocationTest$1.class new file mode 100644 index 0000000..506809c Binary files /dev/null and b/bin/main/messages/VehiclePrecisionLocation$RequestCurrentVehicleLocationTest$1.class differ diff --git a/bin/main/messages/VehiclePrecisionLocation$RequestCurrentVehicleLocationTest$Builder.class b/bin/main/messages/VehiclePrecisionLocation$RequestCurrentVehicleLocationTest$Builder.class new file mode 100644 index 0000000..fb27242 Binary files /dev/null and b/bin/main/messages/VehiclePrecisionLocation$RequestCurrentVehicleLocationTest$Builder.class differ diff --git a/bin/main/messages/VehiclePrecisionLocation$RequestCurrentVehicleLocationTest.class b/bin/main/messages/VehiclePrecisionLocation$RequestCurrentVehicleLocationTest.class new file mode 100644 index 0000000..054af2d Binary files /dev/null and b/bin/main/messages/VehiclePrecisionLocation$RequestCurrentVehicleLocationTest.class differ diff --git a/bin/main/messages/VehiclePrecisionLocation$RequestCurrentVehicleLocationTestOrBuilder.class b/bin/main/messages/VehiclePrecisionLocation$RequestCurrentVehicleLocationTestOrBuilder.class new file mode 100644 index 0000000..bc52735 Binary files /dev/null and b/bin/main/messages/VehiclePrecisionLocation$RequestCurrentVehicleLocationTestOrBuilder.class differ diff --git a/bin/main/messages/VehiclePrecisionLocation$ResponseCurrentVehicleLocation$1.class b/bin/main/messages/VehiclePrecisionLocation$ResponseCurrentVehicleLocation$1.class new file mode 100644 index 0000000..f1f5369 Binary files /dev/null and b/bin/main/messages/VehiclePrecisionLocation$ResponseCurrentVehicleLocation$1.class differ diff --git a/bin/main/messages/VehiclePrecisionLocation$ResponseCurrentVehicleLocation$Builder.class b/bin/main/messages/VehiclePrecisionLocation$ResponseCurrentVehicleLocation$Builder.class new file mode 100644 index 0000000..2b5d279 Binary files /dev/null and b/bin/main/messages/VehiclePrecisionLocation$ResponseCurrentVehicleLocation$Builder.class differ diff --git a/bin/main/messages/VehiclePrecisionLocation$ResponseCurrentVehicleLocation.class b/bin/main/messages/VehiclePrecisionLocation$ResponseCurrentVehicleLocation.class new file mode 100644 index 0000000..03aebef Binary files /dev/null and b/bin/main/messages/VehiclePrecisionLocation$ResponseCurrentVehicleLocation.class differ diff --git a/bin/main/messages/VehiclePrecisionLocation$ResponseCurrentVehicleLocationOrBuilder.class b/bin/main/messages/VehiclePrecisionLocation$ResponseCurrentVehicleLocationOrBuilder.class new file mode 100644 index 0000000..dbe0a90 Binary files /dev/null and b/bin/main/messages/VehiclePrecisionLocation$ResponseCurrentVehicleLocationOrBuilder.class differ diff --git a/bin/main/messages/VehiclePrecisionLocation$ResponseStatusEnum$1.class b/bin/main/messages/VehiclePrecisionLocation$ResponseStatusEnum$1.class new file mode 100644 index 0000000..8db7005 Binary files /dev/null and b/bin/main/messages/VehiclePrecisionLocation$ResponseStatusEnum$1.class differ diff --git a/bin/main/messages/VehiclePrecisionLocation$ResponseStatusEnum.class b/bin/main/messages/VehiclePrecisionLocation$ResponseStatusEnum.class new file mode 100644 index 0000000..8f25c42 Binary files /dev/null and b/bin/main/messages/VehiclePrecisionLocation$ResponseStatusEnum.class differ diff --git a/bin/main/messages/VehiclePrecisionLocation$VehicleCurrentLocation$1.class b/bin/main/messages/VehiclePrecisionLocation$VehicleCurrentLocation$1.class new file mode 100644 index 0000000..7272c22 Binary files /dev/null and b/bin/main/messages/VehiclePrecisionLocation$VehicleCurrentLocation$1.class differ diff --git a/bin/main/messages/VehiclePrecisionLocation$VehicleCurrentLocation$Builder.class b/bin/main/messages/VehiclePrecisionLocation$VehicleCurrentLocation$Builder.class new file mode 100644 index 0000000..182b872 Binary files /dev/null and b/bin/main/messages/VehiclePrecisionLocation$VehicleCurrentLocation$Builder.class differ diff --git a/bin/main/messages/VehiclePrecisionLocation$VehicleCurrentLocation.class b/bin/main/messages/VehiclePrecisionLocation$VehicleCurrentLocation.class new file mode 100644 index 0000000..69a0709 Binary files /dev/null and b/bin/main/messages/VehiclePrecisionLocation$VehicleCurrentLocation.class differ diff --git a/bin/main/messages/VehiclePrecisionLocation$VehicleCurrentLocationGNSSReceiver$1.class b/bin/main/messages/VehiclePrecisionLocation$VehicleCurrentLocationGNSSReceiver$1.class new file mode 100644 index 0000000..2369dc6 Binary files /dev/null and b/bin/main/messages/VehiclePrecisionLocation$VehicleCurrentLocationGNSSReceiver$1.class differ diff --git a/bin/main/messages/VehiclePrecisionLocation$VehicleCurrentLocationGNSSReceiver$Builder.class b/bin/main/messages/VehiclePrecisionLocation$VehicleCurrentLocationGNSSReceiver$Builder.class new file mode 100644 index 0000000..1fffeee Binary files /dev/null and b/bin/main/messages/VehiclePrecisionLocation$VehicleCurrentLocationGNSSReceiver$Builder.class differ diff --git a/bin/main/messages/VehiclePrecisionLocation$VehicleCurrentLocationGNSSReceiver.class b/bin/main/messages/VehiclePrecisionLocation$VehicleCurrentLocationGNSSReceiver.class new file mode 100644 index 0000000..0d7edc5 Binary files /dev/null and b/bin/main/messages/VehiclePrecisionLocation$VehicleCurrentLocationGNSSReceiver.class differ diff --git a/bin/main/messages/VehiclePrecisionLocation$VehicleCurrentLocationGNSSReceiverMountingPosition$1.class b/bin/main/messages/VehiclePrecisionLocation$VehicleCurrentLocationGNSSReceiverMountingPosition$1.class new file mode 100644 index 0000000..a0500fe Binary files /dev/null and b/bin/main/messages/VehiclePrecisionLocation$VehicleCurrentLocationGNSSReceiverMountingPosition$1.class differ diff --git a/bin/main/messages/VehiclePrecisionLocation$VehicleCurrentLocationGNSSReceiverMountingPosition$Builder.class b/bin/main/messages/VehiclePrecisionLocation$VehicleCurrentLocationGNSSReceiverMountingPosition$Builder.class new file mode 100644 index 0000000..eb10049 Binary files /dev/null and b/bin/main/messages/VehiclePrecisionLocation$VehicleCurrentLocationGNSSReceiverMountingPosition$Builder.class differ diff --git a/bin/main/messages/VehiclePrecisionLocation$VehicleCurrentLocationGNSSReceiverMountingPosition.class b/bin/main/messages/VehiclePrecisionLocation$VehicleCurrentLocationGNSSReceiverMountingPosition.class new file mode 100644 index 0000000..c234167 Binary files /dev/null and b/bin/main/messages/VehiclePrecisionLocation$VehicleCurrentLocationGNSSReceiverMountingPosition.class differ diff --git a/bin/main/messages/VehiclePrecisionLocation$VehicleCurrentLocationGNSSReceiverMountingPositionOrBuilder.class b/bin/main/messages/VehiclePrecisionLocation$VehicleCurrentLocationGNSSReceiverMountingPositionOrBuilder.class new file mode 100644 index 0000000..cd08862 Binary files /dev/null and b/bin/main/messages/VehiclePrecisionLocation$VehicleCurrentLocationGNSSReceiverMountingPositionOrBuilder.class differ diff --git a/bin/main/messages/VehiclePrecisionLocation$VehicleCurrentLocationGNSSReceiverOrBuilder.class b/bin/main/messages/VehiclePrecisionLocation$VehicleCurrentLocationGNSSReceiverOrBuilder.class new file mode 100644 index 0000000..70db292 Binary files /dev/null and b/bin/main/messages/VehiclePrecisionLocation$VehicleCurrentLocationGNSSReceiverOrBuilder.class differ diff --git a/bin/main/messages/VehiclePrecisionLocation$VehicleCurrentLocationOrBuilder.class b/bin/main/messages/VehiclePrecisionLocation$VehicleCurrentLocationOrBuilder.class new file mode 100644 index 0000000..c562c55 Binary files /dev/null and b/bin/main/messages/VehiclePrecisionLocation$VehicleCurrentLocationOrBuilder.class differ diff --git a/bin/main/messages/VehiclePrecisionLocation.class b/bin/main/messages/VehiclePrecisionLocation.class new file mode 100644 index 0000000..bf2932b Binary files /dev/null and b/bin/main/messages/VehiclePrecisionLocation.class differ diff --git a/bin/main/messages/VehiclePrecisionLocation.pb.cc b/bin/main/messages/VehiclePrecisionLocation.pb.cc new file mode 100644 index 0000000..5f9974f --- /dev/null +++ b/bin/main/messages/VehiclePrecisionLocation.pb.cc @@ -0,0 +1,2023 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: messages/VehiclePrecisionLocation.proto + +#include "messages/VehiclePrecisionLocation.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" +// @@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 RequestCurrentVehicleLocationTest::RequestCurrentVehicleLocationTest( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_.vehicle_identity_)*/ { + &::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized {} + } + + , /*decltype(_impl_._cached_size_)*/{}} {} +struct RequestCurrentVehicleLocationTestDefaultTypeInternal { + PROTOBUF_CONSTEXPR RequestCurrentVehicleLocationTestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~RequestCurrentVehicleLocationTestDefaultTypeInternal() {} + union { + RequestCurrentVehicleLocationTest _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RequestCurrentVehicleLocationTestDefaultTypeInternal _RequestCurrentVehicleLocationTest_default_instance_; +PROTOBUF_CONSTEXPR ResponseCurrentVehicleLocation::ResponseCurrentVehicleLocation( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_.vehiclemessageheading_)*/nullptr + , /*decltype(_impl_.vehiclecurrentlocation_)*/nullptr + , /*decltype(_impl_.responsestatus_)*/ 0 + + , /*decltype(_impl_._cached_size_)*/{}} {} +struct ResponseCurrentVehicleLocationDefaultTypeInternal { + PROTOBUF_CONSTEXPR ResponseCurrentVehicleLocationDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~ResponseCurrentVehicleLocationDefaultTypeInternal() {} + union { + ResponseCurrentVehicleLocation _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ResponseCurrentVehicleLocationDefaultTypeInternal _ResponseCurrentVehicleLocation_default_instance_; +PROTOBUF_CONSTEXPR PublishCurrentVehicleLocation::PublishCurrentVehicleLocation( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_.vehiclemessageheading_)*/nullptr + , /*decltype(_impl_.vehiclecurrentlocation_)*/nullptr + , /*decltype(_impl_._cached_size_)*/{}} {} +struct PublishCurrentVehicleLocationDefaultTypeInternal { + PROTOBUF_CONSTEXPR PublishCurrentVehicleLocationDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~PublishCurrentVehicleLocationDefaultTypeInternal() {} + union { + PublishCurrentVehicleLocation _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PublishCurrentVehicleLocationDefaultTypeInternal _PublishCurrentVehicleLocation_default_instance_; +PROTOBUF_CONSTEXPR VehicleCurrentLocation::VehicleCurrentLocation( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_.timestamp_)*/ { + &::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized {} + } + + , /*decltype(_impl_.gnssreceiver_)*/nullptr + , /*decltype(_impl_.latitude_)*/ 0 + + , /*decltype(_impl_.longitude_)*/ 0 + + , /*decltype(_impl_.heading_)*/ 0 + + , /*decltype(_impl_.horizontalaccuracy_)*/ 0 + + , /*decltype(_impl_.altitude_)*/ 0 + + , /*decltype(_impl_.verticalaccuracy_)*/ 0 + + , /*decltype(_impl_._cached_size_)*/{}} {} +struct VehicleCurrentLocationDefaultTypeInternal { + PROTOBUF_CONSTEXPR VehicleCurrentLocationDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~VehicleCurrentLocationDefaultTypeInternal() {} + union { + VehicleCurrentLocation _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 VehicleCurrentLocationDefaultTypeInternal _VehicleCurrentLocation_default_instance_; +PROTOBUF_CONSTEXPR VehicleCurrentLocationGNSSReceiver::VehicleCurrentLocationGNSSReceiver( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_.fixtype_)*/ { + &::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized {} + } + + , /*decltype(_impl_.mountingposition_)*/nullptr + , /*decltype(_impl_._cached_size_)*/{}} {} +struct VehicleCurrentLocationGNSSReceiverDefaultTypeInternal { + PROTOBUF_CONSTEXPR VehicleCurrentLocationGNSSReceiverDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~VehicleCurrentLocationGNSSReceiverDefaultTypeInternal() {} + union { + VehicleCurrentLocationGNSSReceiver _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 VehicleCurrentLocationGNSSReceiverDefaultTypeInternal _VehicleCurrentLocationGNSSReceiver_default_instance_; +PROTOBUF_CONSTEXPR VehicleCurrentLocationGNSSReceiverMountingPosition::VehicleCurrentLocationGNSSReceiverMountingPosition( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_.x_)*/ 0 + + , /*decltype(_impl_.y_)*/ 0 + + , /*decltype(_impl_.z_)*/ 0 + + , /*decltype(_impl_._cached_size_)*/{}} {} +struct VehicleCurrentLocationGNSSReceiverMountingPositionDefaultTypeInternal { + PROTOBUF_CONSTEXPR VehicleCurrentLocationGNSSReceiverMountingPositionDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~VehicleCurrentLocationGNSSReceiverMountingPositionDefaultTypeInternal() {} + union { + VehicleCurrentLocationGNSSReceiverMountingPosition _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 VehicleCurrentLocationGNSSReceiverMountingPositionDefaultTypeInternal _VehicleCurrentLocationGNSSReceiverMountingPosition_default_instance_; +} // namespace messages +static ::_pb::Metadata file_level_metadata_messages_2fVehiclePrecisionLocation_2eproto[6]; +static const ::_pb::EnumDescriptor* file_level_enum_descriptors_messages_2fVehiclePrecisionLocation_2eproto[1]; +static constexpr const ::_pb::ServiceDescriptor** + file_level_service_descriptors_messages_2fVehiclePrecisionLocation_2eproto = nullptr; +const ::uint32_t TableStruct_messages_2fVehiclePrecisionLocation_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE( + protodesc_cold) = { + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::messages::RequestCurrentVehicleLocationTest, _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::RequestCurrentVehicleLocationTest, _impl_.vehicle_identity_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::messages::ResponseCurrentVehicleLocation, _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::ResponseCurrentVehicleLocation, _impl_.vehiclemessageheading_), + PROTOBUF_FIELD_OFFSET(::messages::ResponseCurrentVehicleLocation, _impl_.vehiclecurrentlocation_), + PROTOBUF_FIELD_OFFSET(::messages::ResponseCurrentVehicleLocation, _impl_.responsestatus_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::messages::PublishCurrentVehicleLocation, _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::PublishCurrentVehicleLocation, _impl_.vehiclemessageheading_), + PROTOBUF_FIELD_OFFSET(::messages::PublishCurrentVehicleLocation, _impl_.vehiclecurrentlocation_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::messages::VehicleCurrentLocation, _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::VehicleCurrentLocation, _impl_.timestamp_), + PROTOBUF_FIELD_OFFSET(::messages::VehicleCurrentLocation, _impl_.latitude_), + PROTOBUF_FIELD_OFFSET(::messages::VehicleCurrentLocation, _impl_.longitude_), + PROTOBUF_FIELD_OFFSET(::messages::VehicleCurrentLocation, _impl_.heading_), + PROTOBUF_FIELD_OFFSET(::messages::VehicleCurrentLocation, _impl_.horizontalaccuracy_), + PROTOBUF_FIELD_OFFSET(::messages::VehicleCurrentLocation, _impl_.altitude_), + PROTOBUF_FIELD_OFFSET(::messages::VehicleCurrentLocation, _impl_.verticalaccuracy_), + PROTOBUF_FIELD_OFFSET(::messages::VehicleCurrentLocation, _impl_.gnssreceiver_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::messages::VehicleCurrentLocationGNSSReceiver, _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::VehicleCurrentLocationGNSSReceiver, _impl_.fixtype_), + PROTOBUF_FIELD_OFFSET(::messages::VehicleCurrentLocationGNSSReceiver, _impl_.mountingposition_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::messages::VehicleCurrentLocationGNSSReceiverMountingPosition, _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::VehicleCurrentLocationGNSSReceiverMountingPosition, _impl_.x_), + PROTOBUF_FIELD_OFFSET(::messages::VehicleCurrentLocationGNSSReceiverMountingPosition, _impl_.y_), + PROTOBUF_FIELD_OFFSET(::messages::VehicleCurrentLocationGNSSReceiverMountingPosition, _impl_.z_), +}; + +static const ::_pbi::MigrationSchema + schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { + { 0, -1, -1, sizeof(::messages::RequestCurrentVehicleLocationTest)}, + { 9, -1, -1, sizeof(::messages::ResponseCurrentVehicleLocation)}, + { 20, -1, -1, sizeof(::messages::PublishCurrentVehicleLocation)}, + { 30, -1, -1, sizeof(::messages::VehicleCurrentLocation)}, + { 46, -1, -1, sizeof(::messages::VehicleCurrentLocationGNSSReceiver)}, + { 56, -1, -1, sizeof(::messages::VehicleCurrentLocationGNSSReceiverMountingPosition)}, +}; + +static const ::_pb::Message* const file_default_instances[] = { + &::messages::_RequestCurrentVehicleLocationTest_default_instance_._instance, + &::messages::_ResponseCurrentVehicleLocation_default_instance_._instance, + &::messages::_PublishCurrentVehicleLocation_default_instance_._instance, + &::messages::_VehicleCurrentLocation_default_instance_._instance, + &::messages::_VehicleCurrentLocationGNSSReceiver_default_instance_._instance, + &::messages::_VehicleCurrentLocationGNSSReceiverMountingPosition_default_instance_._instance, +}; +const char descriptor_table_protodef_messages_2fVehiclePrecisionLocation_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { + "\n\'messages/VehiclePrecisionLocation.prot" + "o\022\010messages\032#messages/VehicleMessageHead" + "er.proto\"=\n!RequestCurrentVehicleLocatio" + "nTest\022\030\n\020vehicle_identity\030\001 \001(\t\"\330\001\n\036Resp" + "onseCurrentVehicleLocation\022>\n\025vehicleMes" + "sageHeading\030\001 \001(\0132\037.messages.VehicleMess" + "ageHeading\022@\n\026vehicleCurrentLocation\030\002 \001" + "(\0132 .messages.VehicleCurrentLocation\0224\n\016" + "responseStatus\030\003 \001(\0162\034.messages.Response" + "StatusEnum\"\241\001\n\035PublishCurrentVehicleLoca" + "tion\022>\n\025vehicleMessageHeading\030\001 \001(\0132\037.me" + "ssages.VehicleMessageHeading\022@\n\026vehicleC" + "urrentLocation\030\002 \001(\0132 .messages.VehicleC" + "urrentLocation\"\355\001\n\026VehicleCurrentLocatio" + "n\022\021\n\tTimestamp\030\001 \001(\t\022\020\n\010Latitude\030\002 \001(\001\022\021" + "\n\tLongitude\030\003 \001(\001\022\017\n\007Heading\030\004 \001(\001\022\032\n\022Ho" + "rizontalAccuracy\030\005 \001(\001\022\020\n\010Altitude\030\006 \001(\001" + "\022\030\n\020VerticalAccuracy\030\007 \001(\001\022B\n\014GNSSReceiv" + "er\030\010 \001(\0132,.messages.VehicleCurrentLocati" + "onGNSSReceiver\"\215\001\n\"VehicleCurrentLocatio" + "nGNSSReceiver\022\017\n\007FixType\030\001 \001(\t\022V\n\020Mounti" + "ngPosition\030\002 \001(\0132<.messages.VehicleCurre" + "ntLocationGNSSReceiverMountingPosition\"U" + "\n2VehicleCurrentLocationGNSSReceiverMoun" + "tingPosition\022\t\n\001X\030\001 \001(\005\022\t\n\001Y\030\002 \001(\005\022\t\n\001Z\030" + "\003 \001(\005*S\n\022ResponseStatusEnum\022\013\n\007SUCCESS\020\000" + "\022\024\n\020FAIL_NO_RESPONSE\020\001\022\032\n\026FAIL_DEGRADED_" + "RESPONSE\020\002b\006proto3" +}; +static const ::_pbi::DescriptorTable* const descriptor_table_messages_2fVehiclePrecisionLocation_2eproto_deps[1] = + { + &::descriptor_table_messages_2fVehicleMessageHeader_2eproto, +}; +static ::absl::once_flag descriptor_table_messages_2fVehiclePrecisionLocation_2eproto_once; +const ::_pbi::DescriptorTable descriptor_table_messages_2fVehiclePrecisionLocation_2eproto = { + false, + false, + 1098, + descriptor_table_protodef_messages_2fVehiclePrecisionLocation_2eproto, + "messages/VehiclePrecisionLocation.proto", + &descriptor_table_messages_2fVehiclePrecisionLocation_2eproto_once, + descriptor_table_messages_2fVehiclePrecisionLocation_2eproto_deps, + 1, + 6, + schemas, + file_default_instances, + TableStruct_messages_2fVehiclePrecisionLocation_2eproto::offsets, + file_level_metadata_messages_2fVehiclePrecisionLocation_2eproto, + file_level_enum_descriptors_messages_2fVehiclePrecisionLocation_2eproto, + file_level_service_descriptors_messages_2fVehiclePrecisionLocation_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_2fVehiclePrecisionLocation_2eproto_getter() { + return &descriptor_table_messages_2fVehiclePrecisionLocation_2eproto; +} +// Force running AddDescriptors() at dynamic initialization time. +PROTOBUF_ATTRIBUTE_INIT_PRIORITY2 +static ::_pbi::AddDescriptorsRunner dynamic_init_dummy_messages_2fVehiclePrecisionLocation_2eproto(&descriptor_table_messages_2fVehiclePrecisionLocation_2eproto); +namespace messages { +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ResponseStatusEnum_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_messages_2fVehiclePrecisionLocation_2eproto); + return file_level_enum_descriptors_messages_2fVehiclePrecisionLocation_2eproto[0]; +} +bool ResponseStatusEnum_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + return true; + default: + return false; + } +} +// =================================================================== + +class RequestCurrentVehicleLocationTest::_Internal { + public: +}; + +RequestCurrentVehicleLocationTest::RequestCurrentVehicleLocationTest(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:messages.RequestCurrentVehicleLocationTest) +} +RequestCurrentVehicleLocationTest::RequestCurrentVehicleLocationTest(const RequestCurrentVehicleLocationTest& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + RequestCurrentVehicleLocationTest* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_.vehicle_identity_) {} + + , /*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()); + } + // @@protoc_insertion_point(copy_constructor:messages.RequestCurrentVehicleLocationTest) +} + +inline void RequestCurrentVehicleLocationTest::SharedCtor(::_pb::Arena* arena) { + (void)arena; + new (&_impl_) Impl_{ + decltype(_impl_.vehicle_identity_) {} + + , /*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 +} + +RequestCurrentVehicleLocationTest::~RequestCurrentVehicleLocationTest() { + // @@protoc_insertion_point(destructor:messages.RequestCurrentVehicleLocationTest) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void RequestCurrentVehicleLocationTest::SharedDtor() { + ABSL_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.vehicle_identity_.Destroy(); +} + +void RequestCurrentVehicleLocationTest::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void RequestCurrentVehicleLocationTest::Clear() { +// @@protoc_insertion_point(message_clear_start:messages.RequestCurrentVehicleLocationTest) + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.vehicle_identity_.ClearToEmpty(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* RequestCurrentVehicleLocationTest::_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) { + // string vehicle_identity = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) { + auto str = _internal_mutable_vehicle_identity(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + CHK_(::_pbi::VerifyUTF8(str, "messages.RequestCurrentVehicleLocationTest.vehicle_identity")); + } 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* RequestCurrentVehicleLocationTest::_InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:messages.RequestCurrentVehicleLocationTest) + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + // string vehicle_identity = 1; + if (!this->_internal_vehicle_identity().empty()) { + const std::string& _s = this->_internal_vehicle_identity(); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "messages.RequestCurrentVehicleLocationTest.vehicle_identity"); + target = stream->WriteStringMaybeAliased(1, _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.RequestCurrentVehicleLocationTest) + return target; +} + +::size_t RequestCurrentVehicleLocationTest::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:messages.RequestCurrentVehicleLocationTest) + ::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 = 1; + if (!this->_internal_vehicle_identity().empty()) { + total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_vehicle_identity()); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData RequestCurrentVehicleLocationTest::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + RequestCurrentVehicleLocationTest::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*RequestCurrentVehicleLocationTest::GetClassData() const { return &_class_data_; } + + +void RequestCurrentVehicleLocationTest::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.RequestCurrentVehicleLocationTest) + 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()); + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void RequestCurrentVehicleLocationTest::CopyFrom(const RequestCurrentVehicleLocationTest& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:messages.RequestCurrentVehicleLocationTest) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool RequestCurrentVehicleLocationTest::IsInitialized() const { + return true; +} + +void RequestCurrentVehicleLocationTest::InternalSwap(RequestCurrentVehicleLocationTest* 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); +} + +::PROTOBUF_NAMESPACE_ID::Metadata RequestCurrentVehicleLocationTest::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_messages_2fVehiclePrecisionLocation_2eproto_getter, &descriptor_table_messages_2fVehiclePrecisionLocation_2eproto_once, + file_level_metadata_messages_2fVehiclePrecisionLocation_2eproto[0]); +} +// =================================================================== + +class ResponseCurrentVehicleLocation::_Internal { + public: + static const ::messages::VehicleMessageHeading& vehiclemessageheading(const ResponseCurrentVehicleLocation* msg); + static const ::messages::VehicleCurrentLocation& vehiclecurrentlocation(const ResponseCurrentVehicleLocation* msg); +}; + +const ::messages::VehicleMessageHeading& +ResponseCurrentVehicleLocation::_Internal::vehiclemessageheading(const ResponseCurrentVehicleLocation* msg) { + return *msg->_impl_.vehiclemessageheading_; +} +const ::messages::VehicleCurrentLocation& +ResponseCurrentVehicleLocation::_Internal::vehiclecurrentlocation(const ResponseCurrentVehicleLocation* msg) { + return *msg->_impl_.vehiclecurrentlocation_; +} +void ResponseCurrentVehicleLocation::clear_vehiclemessageheading() { + if (GetArenaForAllocation() == nullptr && _impl_.vehiclemessageheading_ != nullptr) { + delete _impl_.vehiclemessageheading_; + } + _impl_.vehiclemessageheading_ = nullptr; +} +ResponseCurrentVehicleLocation::ResponseCurrentVehicleLocation(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:messages.ResponseCurrentVehicleLocation) +} +ResponseCurrentVehicleLocation::ResponseCurrentVehicleLocation(const ResponseCurrentVehicleLocation& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + ResponseCurrentVehicleLocation* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_.vehiclemessageheading_){nullptr} + , decltype(_impl_.vehiclecurrentlocation_){nullptr} + , decltype(_impl_.responsestatus_) {} + + , /*decltype(_impl_._cached_size_)*/{}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_vehiclemessageheading()) { + _this->_impl_.vehiclemessageheading_ = new ::messages::VehicleMessageHeading(*from._impl_.vehiclemessageheading_); + } + if (from._internal_has_vehiclecurrentlocation()) { + _this->_impl_.vehiclecurrentlocation_ = new ::messages::VehicleCurrentLocation(*from._impl_.vehiclecurrentlocation_); + } + _this->_impl_.responsestatus_ = from._impl_.responsestatus_; + // @@protoc_insertion_point(copy_constructor:messages.ResponseCurrentVehicleLocation) +} + +inline void ResponseCurrentVehicleLocation::SharedCtor(::_pb::Arena* arena) { + (void)arena; + new (&_impl_) Impl_{ + decltype(_impl_.vehiclemessageheading_){nullptr} + , decltype(_impl_.vehiclecurrentlocation_){nullptr} + , decltype(_impl_.responsestatus_) { 0 } + + , /*decltype(_impl_._cached_size_)*/{} + }; +} + +ResponseCurrentVehicleLocation::~ResponseCurrentVehicleLocation() { + // @@protoc_insertion_point(destructor:messages.ResponseCurrentVehicleLocation) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void ResponseCurrentVehicleLocation::SharedDtor() { + ABSL_DCHECK(GetArenaForAllocation() == nullptr); + if (this != internal_default_instance()) delete _impl_.vehiclemessageheading_; + if (this != internal_default_instance()) delete _impl_.vehiclecurrentlocation_; +} + +void ResponseCurrentVehicleLocation::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void ResponseCurrentVehicleLocation::Clear() { +// @@protoc_insertion_point(message_clear_start:messages.ResponseCurrentVehicleLocation) + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + if (GetArenaForAllocation() == nullptr && _impl_.vehiclemessageheading_ != nullptr) { + delete _impl_.vehiclemessageheading_; + } + _impl_.vehiclemessageheading_ = nullptr; + if (GetArenaForAllocation() == nullptr && _impl_.vehiclecurrentlocation_ != nullptr) { + delete _impl_.vehiclecurrentlocation_; + } + _impl_.vehiclecurrentlocation_ = nullptr; + _impl_.responsestatus_ = 0; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* ResponseCurrentVehicleLocation::_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) { + // .messages.VehicleMessageHeading vehicleMessageHeading = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_vehiclemessageheading(), ptr); + CHK_(ptr); + } else { + goto handle_unusual; + } + continue; + // .messages.VehicleCurrentLocation vehicleCurrentLocation = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_vehiclecurrentlocation(), ptr); + CHK_(ptr); + } else { + goto handle_unusual; + } + continue; + // .messages.ResponseStatusEnum responseStatus = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) { + ::uint32_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + _internal_set_responsestatus(static_cast<::messages::ResponseStatusEnum>(val)); + } 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* ResponseCurrentVehicleLocation::_InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:messages.ResponseCurrentVehicleLocation) + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + // .messages.VehicleMessageHeading vehicleMessageHeading = 1; + if (this->_internal_has_vehiclemessageheading()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, _Internal::vehiclemessageheading(this), + _Internal::vehiclemessageheading(this).GetCachedSize(), target, stream); + } + + // .messages.VehicleCurrentLocation vehicleCurrentLocation = 2; + if (this->_internal_has_vehiclecurrentlocation()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(2, _Internal::vehiclecurrentlocation(this), + _Internal::vehiclecurrentlocation(this).GetCachedSize(), target, stream); + } + + // .messages.ResponseStatusEnum responseStatus = 3; + if (this->_internal_responsestatus() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 3, this->_internal_responsestatus(), 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.ResponseCurrentVehicleLocation) + return target; +} + +::size_t ResponseCurrentVehicleLocation::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:messages.ResponseCurrentVehicleLocation) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // .messages.VehicleMessageHeading vehicleMessageHeading = 1; + if (this->_internal_has_vehiclemessageheading()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.vehiclemessageheading_); + } + + // .messages.VehicleCurrentLocation vehicleCurrentLocation = 2; + if (this->_internal_has_vehiclecurrentlocation()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.vehiclecurrentlocation_); + } + + // .messages.ResponseStatusEnum responseStatus = 3; + if (this->_internal_responsestatus() != 0) { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_responsestatus()); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ResponseCurrentVehicleLocation::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + ResponseCurrentVehicleLocation::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ResponseCurrentVehicleLocation::GetClassData() const { return &_class_data_; } + + +void ResponseCurrentVehicleLocation::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.ResponseCurrentVehicleLocation) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_has_vehiclemessageheading()) { + _this->_internal_mutable_vehiclemessageheading()->::messages::VehicleMessageHeading::MergeFrom( + from._internal_vehiclemessageheading()); + } + if (from._internal_has_vehiclecurrentlocation()) { + _this->_internal_mutable_vehiclecurrentlocation()->::messages::VehicleCurrentLocation::MergeFrom( + from._internal_vehiclecurrentlocation()); + } + if (from._internal_responsestatus() != 0) { + _this->_internal_set_responsestatus(from._internal_responsestatus()); + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void ResponseCurrentVehicleLocation::CopyFrom(const ResponseCurrentVehicleLocation& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:messages.ResponseCurrentVehicleLocation) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ResponseCurrentVehicleLocation::IsInitialized() const { + return true; +} + +void ResponseCurrentVehicleLocation::InternalSwap(ResponseCurrentVehicleLocation* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(ResponseCurrentVehicleLocation, _impl_.responsestatus_) + + sizeof(ResponseCurrentVehicleLocation::_impl_.responsestatus_) + - PROTOBUF_FIELD_OFFSET(ResponseCurrentVehicleLocation, _impl_.vehiclemessageheading_)>( + reinterpret_cast(&_impl_.vehiclemessageheading_), + reinterpret_cast(&other->_impl_.vehiclemessageheading_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata ResponseCurrentVehicleLocation::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_messages_2fVehiclePrecisionLocation_2eproto_getter, &descriptor_table_messages_2fVehiclePrecisionLocation_2eproto_once, + file_level_metadata_messages_2fVehiclePrecisionLocation_2eproto[1]); +} +// =================================================================== + +class PublishCurrentVehicleLocation::_Internal { + public: + static const ::messages::VehicleMessageHeading& vehiclemessageheading(const PublishCurrentVehicleLocation* msg); + static const ::messages::VehicleCurrentLocation& vehiclecurrentlocation(const PublishCurrentVehicleLocation* msg); +}; + +const ::messages::VehicleMessageHeading& +PublishCurrentVehicleLocation::_Internal::vehiclemessageheading(const PublishCurrentVehicleLocation* msg) { + return *msg->_impl_.vehiclemessageheading_; +} +const ::messages::VehicleCurrentLocation& +PublishCurrentVehicleLocation::_Internal::vehiclecurrentlocation(const PublishCurrentVehicleLocation* msg) { + return *msg->_impl_.vehiclecurrentlocation_; +} +void PublishCurrentVehicleLocation::clear_vehiclemessageheading() { + if (GetArenaForAllocation() == nullptr && _impl_.vehiclemessageheading_ != nullptr) { + delete _impl_.vehiclemessageheading_; + } + _impl_.vehiclemessageheading_ = nullptr; +} +PublishCurrentVehicleLocation::PublishCurrentVehicleLocation(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:messages.PublishCurrentVehicleLocation) +} +PublishCurrentVehicleLocation::PublishCurrentVehicleLocation(const PublishCurrentVehicleLocation& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + PublishCurrentVehicleLocation* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_.vehiclemessageheading_){nullptr} + , decltype(_impl_.vehiclecurrentlocation_){nullptr} + , /*decltype(_impl_._cached_size_)*/{}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_vehiclemessageheading()) { + _this->_impl_.vehiclemessageheading_ = new ::messages::VehicleMessageHeading(*from._impl_.vehiclemessageheading_); + } + if (from._internal_has_vehiclecurrentlocation()) { + _this->_impl_.vehiclecurrentlocation_ = new ::messages::VehicleCurrentLocation(*from._impl_.vehiclecurrentlocation_); + } + // @@protoc_insertion_point(copy_constructor:messages.PublishCurrentVehicleLocation) +} + +inline void PublishCurrentVehicleLocation::SharedCtor(::_pb::Arena* arena) { + (void)arena; + new (&_impl_) Impl_{ + decltype(_impl_.vehiclemessageheading_){nullptr} + , decltype(_impl_.vehiclecurrentlocation_){nullptr} + , /*decltype(_impl_._cached_size_)*/{} + }; +} + +PublishCurrentVehicleLocation::~PublishCurrentVehicleLocation() { + // @@protoc_insertion_point(destructor:messages.PublishCurrentVehicleLocation) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void PublishCurrentVehicleLocation::SharedDtor() { + ABSL_DCHECK(GetArenaForAllocation() == nullptr); + if (this != internal_default_instance()) delete _impl_.vehiclemessageheading_; + if (this != internal_default_instance()) delete _impl_.vehiclecurrentlocation_; +} + +void PublishCurrentVehicleLocation::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void PublishCurrentVehicleLocation::Clear() { +// @@protoc_insertion_point(message_clear_start:messages.PublishCurrentVehicleLocation) + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + if (GetArenaForAllocation() == nullptr && _impl_.vehiclemessageheading_ != nullptr) { + delete _impl_.vehiclemessageheading_; + } + _impl_.vehiclemessageheading_ = nullptr; + if (GetArenaForAllocation() == nullptr && _impl_.vehiclecurrentlocation_ != nullptr) { + delete _impl_.vehiclecurrentlocation_; + } + _impl_.vehiclecurrentlocation_ = nullptr; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* PublishCurrentVehicleLocation::_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) { + // .messages.VehicleMessageHeading vehicleMessageHeading = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_vehiclemessageheading(), ptr); + CHK_(ptr); + } else { + goto handle_unusual; + } + continue; + // .messages.VehicleCurrentLocation vehicleCurrentLocation = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_vehiclecurrentlocation(), 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: + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +::uint8_t* PublishCurrentVehicleLocation::_InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:messages.PublishCurrentVehicleLocation) + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + // .messages.VehicleMessageHeading vehicleMessageHeading = 1; + if (this->_internal_has_vehiclemessageheading()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, _Internal::vehiclemessageheading(this), + _Internal::vehiclemessageheading(this).GetCachedSize(), target, stream); + } + + // .messages.VehicleCurrentLocation vehicleCurrentLocation = 2; + if (this->_internal_has_vehiclecurrentlocation()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(2, _Internal::vehiclecurrentlocation(this), + _Internal::vehiclecurrentlocation(this).GetCachedSize(), target, stream); + } + + 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.PublishCurrentVehicleLocation) + return target; +} + +::size_t PublishCurrentVehicleLocation::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:messages.PublishCurrentVehicleLocation) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // .messages.VehicleMessageHeading vehicleMessageHeading = 1; + if (this->_internal_has_vehiclemessageheading()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.vehiclemessageheading_); + } + + // .messages.VehicleCurrentLocation vehicleCurrentLocation = 2; + if (this->_internal_has_vehiclecurrentlocation()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.vehiclecurrentlocation_); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData PublishCurrentVehicleLocation::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + PublishCurrentVehicleLocation::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*PublishCurrentVehicleLocation::GetClassData() const { return &_class_data_; } + + +void PublishCurrentVehicleLocation::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.PublishCurrentVehicleLocation) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_has_vehiclemessageheading()) { + _this->_internal_mutable_vehiclemessageheading()->::messages::VehicleMessageHeading::MergeFrom( + from._internal_vehiclemessageheading()); + } + if (from._internal_has_vehiclecurrentlocation()) { + _this->_internal_mutable_vehiclecurrentlocation()->::messages::VehicleCurrentLocation::MergeFrom( + from._internal_vehiclecurrentlocation()); + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void PublishCurrentVehicleLocation::CopyFrom(const PublishCurrentVehicleLocation& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:messages.PublishCurrentVehicleLocation) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool PublishCurrentVehicleLocation::IsInitialized() const { + return true; +} + +void PublishCurrentVehicleLocation::InternalSwap(PublishCurrentVehicleLocation* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(PublishCurrentVehicleLocation, _impl_.vehiclecurrentlocation_) + + sizeof(PublishCurrentVehicleLocation::_impl_.vehiclecurrentlocation_) + - PROTOBUF_FIELD_OFFSET(PublishCurrentVehicleLocation, _impl_.vehiclemessageheading_)>( + reinterpret_cast(&_impl_.vehiclemessageheading_), + reinterpret_cast(&other->_impl_.vehiclemessageheading_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata PublishCurrentVehicleLocation::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_messages_2fVehiclePrecisionLocation_2eproto_getter, &descriptor_table_messages_2fVehiclePrecisionLocation_2eproto_once, + file_level_metadata_messages_2fVehiclePrecisionLocation_2eproto[2]); +} +// =================================================================== + +class VehicleCurrentLocation::_Internal { + public: + static const ::messages::VehicleCurrentLocationGNSSReceiver& gnssreceiver(const VehicleCurrentLocation* msg); +}; + +const ::messages::VehicleCurrentLocationGNSSReceiver& +VehicleCurrentLocation::_Internal::gnssreceiver(const VehicleCurrentLocation* msg) { + return *msg->_impl_.gnssreceiver_; +} +VehicleCurrentLocation::VehicleCurrentLocation(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:messages.VehicleCurrentLocation) +} +VehicleCurrentLocation::VehicleCurrentLocation(const VehicleCurrentLocation& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + VehicleCurrentLocation* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_.timestamp_) {} + + , decltype(_impl_.gnssreceiver_){nullptr} + , decltype(_impl_.latitude_) {} + + , decltype(_impl_.longitude_) {} + + , decltype(_impl_.heading_) {} + + , decltype(_impl_.horizontalaccuracy_) {} + + , decltype(_impl_.altitude_) {} + + , decltype(_impl_.verticalaccuracy_) {} + + , /*decltype(_impl_._cached_size_)*/{}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.timestamp_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.timestamp_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (!from._internal_timestamp().empty()) { + _this->_impl_.timestamp_.Set(from._internal_timestamp(), _this->GetArenaForAllocation()); + } + if (from._internal_has_gnssreceiver()) { + _this->_impl_.gnssreceiver_ = new ::messages::VehicleCurrentLocationGNSSReceiver(*from._impl_.gnssreceiver_); + } + ::memcpy(&_impl_.latitude_, &from._impl_.latitude_, + static_cast<::size_t>(reinterpret_cast(&_impl_.verticalaccuracy_) - + reinterpret_cast(&_impl_.latitude_)) + sizeof(_impl_.verticalaccuracy_)); + // @@protoc_insertion_point(copy_constructor:messages.VehicleCurrentLocation) +} + +inline void VehicleCurrentLocation::SharedCtor(::_pb::Arena* arena) { + (void)arena; + new (&_impl_) Impl_{ + decltype(_impl_.timestamp_) {} + + , decltype(_impl_.gnssreceiver_){nullptr} + , decltype(_impl_.latitude_) { 0 } + + , decltype(_impl_.longitude_) { 0 } + + , decltype(_impl_.heading_) { 0 } + + , decltype(_impl_.horizontalaccuracy_) { 0 } + + , decltype(_impl_.altitude_) { 0 } + + , decltype(_impl_.verticalaccuracy_) { 0 } + + , /*decltype(_impl_._cached_size_)*/{} + }; + _impl_.timestamp_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.timestamp_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +VehicleCurrentLocation::~VehicleCurrentLocation() { + // @@protoc_insertion_point(destructor:messages.VehicleCurrentLocation) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void VehicleCurrentLocation::SharedDtor() { + ABSL_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.timestamp_.Destroy(); + if (this != internal_default_instance()) delete _impl_.gnssreceiver_; +} + +void VehicleCurrentLocation::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void VehicleCurrentLocation::Clear() { +// @@protoc_insertion_point(message_clear_start:messages.VehicleCurrentLocation) + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.timestamp_.ClearToEmpty(); + if (GetArenaForAllocation() == nullptr && _impl_.gnssreceiver_ != nullptr) { + delete _impl_.gnssreceiver_; + } + _impl_.gnssreceiver_ = nullptr; + ::memset(&_impl_.latitude_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.verticalaccuracy_) - + reinterpret_cast(&_impl_.latitude_)) + sizeof(_impl_.verticalaccuracy_)); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* VehicleCurrentLocation::_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) { + // string Timestamp = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) { + auto str = _internal_mutable_timestamp(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + CHK_(::_pbi::VerifyUTF8(str, "messages.VehicleCurrentLocation.Timestamp")); + } else { + goto handle_unusual; + } + continue; + // double Latitude = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 17)) { + _impl_.latitude_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(double); + } else { + goto handle_unusual; + } + continue; + // double Longitude = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 25)) { + _impl_.longitude_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(double); + } else { + goto handle_unusual; + } + continue; + // double Heading = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 33)) { + _impl_.heading_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(double); + } else { + goto handle_unusual; + } + continue; + // double HorizontalAccuracy = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 41)) { + _impl_.horizontalaccuracy_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(double); + } else { + goto handle_unusual; + } + continue; + // double Altitude = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 49)) { + _impl_.altitude_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(double); + } else { + goto handle_unusual; + } + continue; + // double VerticalAccuracy = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 57)) { + _impl_.verticalaccuracy_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(double); + } else { + goto handle_unusual; + } + continue; + // .messages.VehicleCurrentLocationGNSSReceiver GNSSReceiver = 8; + case 8: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 66)) { + ptr = ctx->ParseMessage(_internal_mutable_gnssreceiver(), 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: + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +::uint8_t* VehicleCurrentLocation::_InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:messages.VehicleCurrentLocation) + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + // string Timestamp = 1; + if (!this->_internal_timestamp().empty()) { + const std::string& _s = this->_internal_timestamp(); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "messages.VehicleCurrentLocation.Timestamp"); + target = stream->WriteStringMaybeAliased(1, _s, target); + } + + // double Latitude = 2; + 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( + 2, this->_internal_latitude(), target); + } + + // double Longitude = 3; + 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( + 3, this->_internal_longitude(), target); + } + + // double Heading = 4; + static_assert(sizeof(::uint64_t) == sizeof(double), "Code assumes ::uint64_t and double are the same size."); + double tmp_heading = this->_internal_heading(); + ::uint64_t raw_heading; + memcpy(&raw_heading, &tmp_heading, sizeof(tmp_heading)); + if (raw_heading != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 4, this->_internal_heading(), target); + } + + // double HorizontalAccuracy = 5; + static_assert(sizeof(::uint64_t) == sizeof(double), "Code assumes ::uint64_t and double are the same size."); + double tmp_horizontalaccuracy = this->_internal_horizontalaccuracy(); + ::uint64_t raw_horizontalaccuracy; + memcpy(&raw_horizontalaccuracy, &tmp_horizontalaccuracy, sizeof(tmp_horizontalaccuracy)); + if (raw_horizontalaccuracy != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 5, this->_internal_horizontalaccuracy(), target); + } + + // double Altitude = 6; + static_assert(sizeof(::uint64_t) == sizeof(double), "Code assumes ::uint64_t and double are the same size."); + double tmp_altitude = this->_internal_altitude(); + ::uint64_t raw_altitude; + memcpy(&raw_altitude, &tmp_altitude, sizeof(tmp_altitude)); + if (raw_altitude != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 6, this->_internal_altitude(), target); + } + + // double VerticalAccuracy = 7; + static_assert(sizeof(::uint64_t) == sizeof(double), "Code assumes ::uint64_t and double are the same size."); + double tmp_verticalaccuracy = this->_internal_verticalaccuracy(); + ::uint64_t raw_verticalaccuracy; + memcpy(&raw_verticalaccuracy, &tmp_verticalaccuracy, sizeof(tmp_verticalaccuracy)); + if (raw_verticalaccuracy != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 7, this->_internal_verticalaccuracy(), target); + } + + // .messages.VehicleCurrentLocationGNSSReceiver GNSSReceiver = 8; + if (this->_internal_has_gnssreceiver()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(8, _Internal::gnssreceiver(this), + _Internal::gnssreceiver(this).GetCachedSize(), target, stream); + } + + 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.VehicleCurrentLocation) + return target; +} + +::size_t VehicleCurrentLocation::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:messages.VehicleCurrentLocation) + ::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 Timestamp = 1; + if (!this->_internal_timestamp().empty()) { + total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_timestamp()); + } + + // .messages.VehicleCurrentLocationGNSSReceiver GNSSReceiver = 8; + if (this->_internal_has_gnssreceiver()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.gnssreceiver_); + } + + // double Latitude = 2; + 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 = 3; + 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; + } + + // double Heading = 4; + static_assert(sizeof(::uint64_t) == sizeof(double), "Code assumes ::uint64_t and double are the same size."); + double tmp_heading = this->_internal_heading(); + ::uint64_t raw_heading; + memcpy(&raw_heading, &tmp_heading, sizeof(tmp_heading)); + if (raw_heading != 0) { + total_size += 9; + } + + // double HorizontalAccuracy = 5; + static_assert(sizeof(::uint64_t) == sizeof(double), "Code assumes ::uint64_t and double are the same size."); + double tmp_horizontalaccuracy = this->_internal_horizontalaccuracy(); + ::uint64_t raw_horizontalaccuracy; + memcpy(&raw_horizontalaccuracy, &tmp_horizontalaccuracy, sizeof(tmp_horizontalaccuracy)); + if (raw_horizontalaccuracy != 0) { + total_size += 9; + } + + // double Altitude = 6; + static_assert(sizeof(::uint64_t) == sizeof(double), "Code assumes ::uint64_t and double are the same size."); + double tmp_altitude = this->_internal_altitude(); + ::uint64_t raw_altitude; + memcpy(&raw_altitude, &tmp_altitude, sizeof(tmp_altitude)); + if (raw_altitude != 0) { + total_size += 9; + } + + // double VerticalAccuracy = 7; + static_assert(sizeof(::uint64_t) == sizeof(double), "Code assumes ::uint64_t and double are the same size."); + double tmp_verticalaccuracy = this->_internal_verticalaccuracy(); + ::uint64_t raw_verticalaccuracy; + memcpy(&raw_verticalaccuracy, &tmp_verticalaccuracy, sizeof(tmp_verticalaccuracy)); + if (raw_verticalaccuracy != 0) { + total_size += 9; + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData VehicleCurrentLocation::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + VehicleCurrentLocation::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*VehicleCurrentLocation::GetClassData() const { return &_class_data_; } + + +void VehicleCurrentLocation::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.VehicleCurrentLocation) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (!from._internal_timestamp().empty()) { + _this->_internal_set_timestamp(from._internal_timestamp()); + } + if (from._internal_has_gnssreceiver()) { + _this->_internal_mutable_gnssreceiver()->::messages::VehicleCurrentLocationGNSSReceiver::MergeFrom( + from._internal_gnssreceiver()); + } + 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()); + } + static_assert(sizeof(::uint64_t) == sizeof(double), "Code assumes ::uint64_t and double are the same size."); + double tmp_heading = from._internal_heading(); + ::uint64_t raw_heading; + memcpy(&raw_heading, &tmp_heading, sizeof(tmp_heading)); + if (raw_heading != 0) { + _this->_internal_set_heading(from._internal_heading()); + } + static_assert(sizeof(::uint64_t) == sizeof(double), "Code assumes ::uint64_t and double are the same size."); + double tmp_horizontalaccuracy = from._internal_horizontalaccuracy(); + ::uint64_t raw_horizontalaccuracy; + memcpy(&raw_horizontalaccuracy, &tmp_horizontalaccuracy, sizeof(tmp_horizontalaccuracy)); + if (raw_horizontalaccuracy != 0) { + _this->_internal_set_horizontalaccuracy(from._internal_horizontalaccuracy()); + } + static_assert(sizeof(::uint64_t) == sizeof(double), "Code assumes ::uint64_t and double are the same size."); + double tmp_altitude = from._internal_altitude(); + ::uint64_t raw_altitude; + memcpy(&raw_altitude, &tmp_altitude, sizeof(tmp_altitude)); + if (raw_altitude != 0) { + _this->_internal_set_altitude(from._internal_altitude()); + } + static_assert(sizeof(::uint64_t) == sizeof(double), "Code assumes ::uint64_t and double are the same size."); + double tmp_verticalaccuracy = from._internal_verticalaccuracy(); + ::uint64_t raw_verticalaccuracy; + memcpy(&raw_verticalaccuracy, &tmp_verticalaccuracy, sizeof(tmp_verticalaccuracy)); + if (raw_verticalaccuracy != 0) { + _this->_internal_set_verticalaccuracy(from._internal_verticalaccuracy()); + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void VehicleCurrentLocation::CopyFrom(const VehicleCurrentLocation& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:messages.VehicleCurrentLocation) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool VehicleCurrentLocation::IsInitialized() const { + return true; +} + +void VehicleCurrentLocation::InternalSwap(VehicleCurrentLocation* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.timestamp_, lhs_arena, + &other->_impl_.timestamp_, rhs_arena); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(VehicleCurrentLocation, _impl_.verticalaccuracy_) + + sizeof(VehicleCurrentLocation::_impl_.verticalaccuracy_) + - PROTOBUF_FIELD_OFFSET(VehicleCurrentLocation, _impl_.gnssreceiver_)>( + reinterpret_cast(&_impl_.gnssreceiver_), + reinterpret_cast(&other->_impl_.gnssreceiver_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata VehicleCurrentLocation::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_messages_2fVehiclePrecisionLocation_2eproto_getter, &descriptor_table_messages_2fVehiclePrecisionLocation_2eproto_once, + file_level_metadata_messages_2fVehiclePrecisionLocation_2eproto[3]); +} +// =================================================================== + +class VehicleCurrentLocationGNSSReceiver::_Internal { + public: + static const ::messages::VehicleCurrentLocationGNSSReceiverMountingPosition& mountingposition(const VehicleCurrentLocationGNSSReceiver* msg); +}; + +const ::messages::VehicleCurrentLocationGNSSReceiverMountingPosition& +VehicleCurrentLocationGNSSReceiver::_Internal::mountingposition(const VehicleCurrentLocationGNSSReceiver* msg) { + return *msg->_impl_.mountingposition_; +} +VehicleCurrentLocationGNSSReceiver::VehicleCurrentLocationGNSSReceiver(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:messages.VehicleCurrentLocationGNSSReceiver) +} +VehicleCurrentLocationGNSSReceiver::VehicleCurrentLocationGNSSReceiver(const VehicleCurrentLocationGNSSReceiver& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + VehicleCurrentLocationGNSSReceiver* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_.fixtype_) {} + + , decltype(_impl_.mountingposition_){nullptr} + , /*decltype(_impl_._cached_size_)*/{}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.fixtype_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.fixtype_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (!from._internal_fixtype().empty()) { + _this->_impl_.fixtype_.Set(from._internal_fixtype(), _this->GetArenaForAllocation()); + } + if (from._internal_has_mountingposition()) { + _this->_impl_.mountingposition_ = new ::messages::VehicleCurrentLocationGNSSReceiverMountingPosition(*from._impl_.mountingposition_); + } + // @@protoc_insertion_point(copy_constructor:messages.VehicleCurrentLocationGNSSReceiver) +} + +inline void VehicleCurrentLocationGNSSReceiver::SharedCtor(::_pb::Arena* arena) { + (void)arena; + new (&_impl_) Impl_{ + decltype(_impl_.fixtype_) {} + + , decltype(_impl_.mountingposition_){nullptr} + , /*decltype(_impl_._cached_size_)*/{} + }; + _impl_.fixtype_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.fixtype_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +VehicleCurrentLocationGNSSReceiver::~VehicleCurrentLocationGNSSReceiver() { + // @@protoc_insertion_point(destructor:messages.VehicleCurrentLocationGNSSReceiver) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void VehicleCurrentLocationGNSSReceiver::SharedDtor() { + ABSL_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.fixtype_.Destroy(); + if (this != internal_default_instance()) delete _impl_.mountingposition_; +} + +void VehicleCurrentLocationGNSSReceiver::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void VehicleCurrentLocationGNSSReceiver::Clear() { +// @@protoc_insertion_point(message_clear_start:messages.VehicleCurrentLocationGNSSReceiver) + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.fixtype_.ClearToEmpty(); + if (GetArenaForAllocation() == nullptr && _impl_.mountingposition_ != nullptr) { + delete _impl_.mountingposition_; + } + _impl_.mountingposition_ = nullptr; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* VehicleCurrentLocationGNSSReceiver::_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) { + // string FixType = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) { + auto str = _internal_mutable_fixtype(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + CHK_(::_pbi::VerifyUTF8(str, "messages.VehicleCurrentLocationGNSSReceiver.FixType")); + } else { + goto handle_unusual; + } + continue; + // .messages.VehicleCurrentLocationGNSSReceiverMountingPosition MountingPosition = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_mountingposition(), 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: + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +::uint8_t* VehicleCurrentLocationGNSSReceiver::_InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:messages.VehicleCurrentLocationGNSSReceiver) + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + // string FixType = 1; + if (!this->_internal_fixtype().empty()) { + const std::string& _s = this->_internal_fixtype(); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "messages.VehicleCurrentLocationGNSSReceiver.FixType"); + target = stream->WriteStringMaybeAliased(1, _s, target); + } + + // .messages.VehicleCurrentLocationGNSSReceiverMountingPosition MountingPosition = 2; + if (this->_internal_has_mountingposition()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(2, _Internal::mountingposition(this), + _Internal::mountingposition(this).GetCachedSize(), target, stream); + } + + 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.VehicleCurrentLocationGNSSReceiver) + return target; +} + +::size_t VehicleCurrentLocationGNSSReceiver::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:messages.VehicleCurrentLocationGNSSReceiver) + ::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 FixType = 1; + if (!this->_internal_fixtype().empty()) { + total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_fixtype()); + } + + // .messages.VehicleCurrentLocationGNSSReceiverMountingPosition MountingPosition = 2; + if (this->_internal_has_mountingposition()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.mountingposition_); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData VehicleCurrentLocationGNSSReceiver::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + VehicleCurrentLocationGNSSReceiver::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*VehicleCurrentLocationGNSSReceiver::GetClassData() const { return &_class_data_; } + + +void VehicleCurrentLocationGNSSReceiver::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.VehicleCurrentLocationGNSSReceiver) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (!from._internal_fixtype().empty()) { + _this->_internal_set_fixtype(from._internal_fixtype()); + } + if (from._internal_has_mountingposition()) { + _this->_internal_mutable_mountingposition()->::messages::VehicleCurrentLocationGNSSReceiverMountingPosition::MergeFrom( + from._internal_mountingposition()); + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void VehicleCurrentLocationGNSSReceiver::CopyFrom(const VehicleCurrentLocationGNSSReceiver& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:messages.VehicleCurrentLocationGNSSReceiver) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool VehicleCurrentLocationGNSSReceiver::IsInitialized() const { + return true; +} + +void VehicleCurrentLocationGNSSReceiver::InternalSwap(VehicleCurrentLocationGNSSReceiver* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.fixtype_, lhs_arena, + &other->_impl_.fixtype_, rhs_arena); + swap(_impl_.mountingposition_, other->_impl_.mountingposition_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata VehicleCurrentLocationGNSSReceiver::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_messages_2fVehiclePrecisionLocation_2eproto_getter, &descriptor_table_messages_2fVehiclePrecisionLocation_2eproto_once, + file_level_metadata_messages_2fVehiclePrecisionLocation_2eproto[4]); +} +// =================================================================== + +class VehicleCurrentLocationGNSSReceiverMountingPosition::_Internal { + public: +}; + +VehicleCurrentLocationGNSSReceiverMountingPosition::VehicleCurrentLocationGNSSReceiverMountingPosition(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:messages.VehicleCurrentLocationGNSSReceiverMountingPosition) +} +VehicleCurrentLocationGNSSReceiverMountingPosition::VehicleCurrentLocationGNSSReceiverMountingPosition(const VehicleCurrentLocationGNSSReceiverMountingPosition& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), _impl_(from._impl_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>( + from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:messages.VehicleCurrentLocationGNSSReceiverMountingPosition) +} + +inline void VehicleCurrentLocationGNSSReceiverMountingPosition::SharedCtor(::_pb::Arena* arena) { + (void)arena; + new (&_impl_) Impl_{ + decltype(_impl_.x_) { 0 } + + , decltype(_impl_.y_) { 0 } + + , decltype(_impl_.z_) { 0 } + + , /*decltype(_impl_._cached_size_)*/{} + }; +} + +VehicleCurrentLocationGNSSReceiverMountingPosition::~VehicleCurrentLocationGNSSReceiverMountingPosition() { + // @@protoc_insertion_point(destructor:messages.VehicleCurrentLocationGNSSReceiverMountingPosition) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void VehicleCurrentLocationGNSSReceiverMountingPosition::SharedDtor() { + ABSL_DCHECK(GetArenaForAllocation() == nullptr); +} + +void VehicleCurrentLocationGNSSReceiverMountingPosition::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void VehicleCurrentLocationGNSSReceiverMountingPosition::Clear() { +// @@protoc_insertion_point(message_clear_start:messages.VehicleCurrentLocationGNSSReceiverMountingPosition) + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + ::memset(&_impl_.x_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.z_) - + reinterpret_cast(&_impl_.x_)) + sizeof(_impl_.z_)); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* VehicleCurrentLocationGNSSReceiverMountingPosition::_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 X = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) { + _impl_.x_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else { + goto handle_unusual; + } + continue; + // int32 Y = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) { + _impl_.y_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else { + goto handle_unusual; + } + continue; + // int32 Z = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) { + _impl_.z_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&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: + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +::uint8_t* VehicleCurrentLocationGNSSReceiverMountingPosition::_InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:messages.VehicleCurrentLocationGNSSReceiverMountingPosition) + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + // int32 X = 1; + if (this->_internal_x() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt32ToArray( + 1, this->_internal_x(), target); + } + + // int32 Y = 2; + if (this->_internal_y() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt32ToArray( + 2, this->_internal_y(), target); + } + + // int32 Z = 3; + if (this->_internal_z() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt32ToArray( + 3, this->_internal_z(), 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.VehicleCurrentLocationGNSSReceiverMountingPosition) + return target; +} + +::size_t VehicleCurrentLocationGNSSReceiverMountingPosition::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:messages.VehicleCurrentLocationGNSSReceiverMountingPosition) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // int32 X = 1; + if (this->_internal_x() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this->_internal_x()); + } + + // int32 Y = 2; + if (this->_internal_y() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this->_internal_y()); + } + + // int32 Z = 3; + if (this->_internal_z() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this->_internal_z()); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData VehicleCurrentLocationGNSSReceiverMountingPosition::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + VehicleCurrentLocationGNSSReceiverMountingPosition::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*VehicleCurrentLocationGNSSReceiverMountingPosition::GetClassData() const { return &_class_data_; } + + +void VehicleCurrentLocationGNSSReceiverMountingPosition::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.VehicleCurrentLocationGNSSReceiverMountingPosition) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_x() != 0) { + _this->_internal_set_x(from._internal_x()); + } + if (from._internal_y() != 0) { + _this->_internal_set_y(from._internal_y()); + } + if (from._internal_z() != 0) { + _this->_internal_set_z(from._internal_z()); + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void VehicleCurrentLocationGNSSReceiverMountingPosition::CopyFrom(const VehicleCurrentLocationGNSSReceiverMountingPosition& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:messages.VehicleCurrentLocationGNSSReceiverMountingPosition) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool VehicleCurrentLocationGNSSReceiverMountingPosition::IsInitialized() const { + return true; +} + +void VehicleCurrentLocationGNSSReceiverMountingPosition::InternalSwap(VehicleCurrentLocationGNSSReceiverMountingPosition* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(VehicleCurrentLocationGNSSReceiverMountingPosition, _impl_.z_) + + sizeof(VehicleCurrentLocationGNSSReceiverMountingPosition::_impl_.z_) + - PROTOBUF_FIELD_OFFSET(VehicleCurrentLocationGNSSReceiverMountingPosition, _impl_.x_)>( + reinterpret_cast(&_impl_.x_), + reinterpret_cast(&other->_impl_.x_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata VehicleCurrentLocationGNSSReceiverMountingPosition::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_messages_2fVehiclePrecisionLocation_2eproto_getter, &descriptor_table_messages_2fVehiclePrecisionLocation_2eproto_once, + file_level_metadata_messages_2fVehiclePrecisionLocation_2eproto[5]); +} +// @@protoc_insertion_point(namespace_scope) +} // namespace messages +PROTOBUF_NAMESPACE_OPEN +template<> PROTOBUF_NOINLINE ::messages::RequestCurrentVehicleLocationTest* +Arena::CreateMaybeMessage< ::messages::RequestCurrentVehicleLocationTest >(Arena* arena) { + return Arena::CreateMessageInternal< ::messages::RequestCurrentVehicleLocationTest >(arena); +} +template<> PROTOBUF_NOINLINE ::messages::ResponseCurrentVehicleLocation* +Arena::CreateMaybeMessage< ::messages::ResponseCurrentVehicleLocation >(Arena* arena) { + return Arena::CreateMessageInternal< ::messages::ResponseCurrentVehicleLocation >(arena); +} +template<> PROTOBUF_NOINLINE ::messages::PublishCurrentVehicleLocation* +Arena::CreateMaybeMessage< ::messages::PublishCurrentVehicleLocation >(Arena* arena) { + return Arena::CreateMessageInternal< ::messages::PublishCurrentVehicleLocation >(arena); +} +template<> PROTOBUF_NOINLINE ::messages::VehicleCurrentLocation* +Arena::CreateMaybeMessage< ::messages::VehicleCurrentLocation >(Arena* arena) { + return Arena::CreateMessageInternal< ::messages::VehicleCurrentLocation >(arena); +} +template<> PROTOBUF_NOINLINE ::messages::VehicleCurrentLocationGNSSReceiver* +Arena::CreateMaybeMessage< ::messages::VehicleCurrentLocationGNSSReceiver >(Arena* arena) { + return Arena::CreateMessageInternal< ::messages::VehicleCurrentLocationGNSSReceiver >(arena); +} +template<> PROTOBUF_NOINLINE ::messages::VehicleCurrentLocationGNSSReceiverMountingPosition* +Arena::CreateMaybeMessage< ::messages::VehicleCurrentLocationGNSSReceiverMountingPosition >(Arena* arena) { + return Arena::CreateMessageInternal< ::messages::VehicleCurrentLocationGNSSReceiverMountingPosition >(arena); +} +PROTOBUF_NAMESPACE_CLOSE +// @@protoc_insertion_point(global_scope) +#include "google/protobuf/port_undef.inc" diff --git a/bin/main/messages/VehiclePrecisionLocation.pb.h b/bin/main/messages/VehiclePrecisionLocation.pb.h new file mode 100644 index 0000000..8724e0e --- /dev/null +++ b/bin/main/messages/VehiclePrecisionLocation.pb.h @@ -0,0 +1,2146 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: messages/VehiclePrecisionLocation.proto + +#ifndef GOOGLE_PROTOBUF_INCLUDED_messages_2fVehiclePrecisionLocation_2eproto_2epb_2eh +#define GOOGLE_PROTOBUF_INCLUDED_messages_2fVehiclePrecisionLocation_2eproto_2epb_2eh + +#include +#include +#include + +#include "google/protobuf/port_def.inc" +#if PROTOBUF_VERSION < 4022000 +#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 4022000 < 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_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/generated_enum_reflection.h" +#include "google/protobuf/unknown_field_set.h" +#include "messages/VehicleMessageHeader.pb.h" +// @@protoc_insertion_point(includes) + +// Must be included last. +#include "google/protobuf/port_def.inc" + +#define PROTOBUF_INTERNAL_EXPORT_messages_2fVehiclePrecisionLocation_2eproto + +PROTOBUF_NAMESPACE_OPEN +namespace internal { +class AnyMetadata; +} // namespace internal +PROTOBUF_NAMESPACE_CLOSE + +// Internal implementation detail -- do not use these members. +struct TableStruct_messages_2fVehiclePrecisionLocation_2eproto { + static const ::uint32_t offsets[]; +}; +extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable + descriptor_table_messages_2fVehiclePrecisionLocation_2eproto; +namespace messages { +class PublishCurrentVehicleLocation; +struct PublishCurrentVehicleLocationDefaultTypeInternal; +extern PublishCurrentVehicleLocationDefaultTypeInternal _PublishCurrentVehicleLocation_default_instance_; +class RequestCurrentVehicleLocationTest; +struct RequestCurrentVehicleLocationTestDefaultTypeInternal; +extern RequestCurrentVehicleLocationTestDefaultTypeInternal _RequestCurrentVehicleLocationTest_default_instance_; +class ResponseCurrentVehicleLocation; +struct ResponseCurrentVehicleLocationDefaultTypeInternal; +extern ResponseCurrentVehicleLocationDefaultTypeInternal _ResponseCurrentVehicleLocation_default_instance_; +class VehicleCurrentLocation; +struct VehicleCurrentLocationDefaultTypeInternal; +extern VehicleCurrentLocationDefaultTypeInternal _VehicleCurrentLocation_default_instance_; +class VehicleCurrentLocationGNSSReceiver; +struct VehicleCurrentLocationGNSSReceiverDefaultTypeInternal; +extern VehicleCurrentLocationGNSSReceiverDefaultTypeInternal _VehicleCurrentLocationGNSSReceiver_default_instance_; +class VehicleCurrentLocationGNSSReceiverMountingPosition; +struct VehicleCurrentLocationGNSSReceiverMountingPositionDefaultTypeInternal; +extern VehicleCurrentLocationGNSSReceiverMountingPositionDefaultTypeInternal _VehicleCurrentLocationGNSSReceiverMountingPosition_default_instance_; +} // namespace messages +PROTOBUF_NAMESPACE_OPEN +template <> +::messages::PublishCurrentVehicleLocation* Arena::CreateMaybeMessage<::messages::PublishCurrentVehicleLocation>(Arena*); +template <> +::messages::RequestCurrentVehicleLocationTest* Arena::CreateMaybeMessage<::messages::RequestCurrentVehicleLocationTest>(Arena*); +template <> +::messages::ResponseCurrentVehicleLocation* Arena::CreateMaybeMessage<::messages::ResponseCurrentVehicleLocation>(Arena*); +template <> +::messages::VehicleCurrentLocation* Arena::CreateMaybeMessage<::messages::VehicleCurrentLocation>(Arena*); +template <> +::messages::VehicleCurrentLocationGNSSReceiver* Arena::CreateMaybeMessage<::messages::VehicleCurrentLocationGNSSReceiver>(Arena*); +template <> +::messages::VehicleCurrentLocationGNSSReceiverMountingPosition* Arena::CreateMaybeMessage<::messages::VehicleCurrentLocationGNSSReceiverMountingPosition>(Arena*); +PROTOBUF_NAMESPACE_CLOSE + +namespace messages { +enum ResponseStatusEnum : int { + SUCCESS = 0, + FAIL_NO_RESPONSE = 1, + FAIL_DEGRADED_RESPONSE = 2, + ResponseStatusEnum_INT_MIN_SENTINEL_DO_NOT_USE_ = + std::numeric_limits<::int32_t>::min(), + ResponseStatusEnum_INT_MAX_SENTINEL_DO_NOT_USE_ = + std::numeric_limits<::int32_t>::max(), +}; + +bool ResponseStatusEnum_IsValid(int value); +constexpr ResponseStatusEnum ResponseStatusEnum_MIN = static_cast(0); +constexpr ResponseStatusEnum ResponseStatusEnum_MAX = static_cast(2); +constexpr int ResponseStatusEnum_ARRAYSIZE = 2 + 1; +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* +ResponseStatusEnum_descriptor(); +template +const std::string& ResponseStatusEnum_Name(T value) { + static_assert(std::is_same::value || + std::is_integral::value, + "Incorrect type passed to ResponseStatusEnum_Name()."); + return ResponseStatusEnum_Name(static_cast(value)); +} +template <> +inline const std::string& ResponseStatusEnum_Name(ResponseStatusEnum value) { + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfDenseEnum( + static_cast(value)); +} +inline bool ResponseStatusEnum_Parse(absl::string_view name, ResponseStatusEnum* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + ResponseStatusEnum_descriptor(), name, value); +} + +// =================================================================== + + +// ------------------------------------------------------------------- + +class RequestCurrentVehicleLocationTest final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:messages.RequestCurrentVehicleLocationTest) */ { + public: + inline RequestCurrentVehicleLocationTest() : RequestCurrentVehicleLocationTest(nullptr) {} + ~RequestCurrentVehicleLocationTest() override; + explicit PROTOBUF_CONSTEXPR RequestCurrentVehicleLocationTest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + RequestCurrentVehicleLocationTest(const RequestCurrentVehicleLocationTest& from); + RequestCurrentVehicleLocationTest(RequestCurrentVehicleLocationTest&& from) noexcept + : RequestCurrentVehicleLocationTest() { + *this = ::std::move(from); + } + + inline RequestCurrentVehicleLocationTest& operator=(const RequestCurrentVehicleLocationTest& from) { + CopyFrom(from); + return *this; + } + inline RequestCurrentVehicleLocationTest& operator=(RequestCurrentVehicleLocationTest&& 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 RequestCurrentVehicleLocationTest& default_instance() { + return *internal_default_instance(); + } + static inline const RequestCurrentVehicleLocationTest* internal_default_instance() { + return reinterpret_cast( + &_RequestCurrentVehicleLocationTest_default_instance_); + } + static constexpr int kIndexInFileMessages = + 0; + + friend void swap(RequestCurrentVehicleLocationTest& a, RequestCurrentVehicleLocationTest& b) { + a.Swap(&b); + } + inline void Swap(RequestCurrentVehicleLocationTest* 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(RequestCurrentVehicleLocationTest* other) { + if (other == this) return; + ABSL_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + RequestCurrentVehicleLocationTest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const RequestCurrentVehicleLocationTest& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const RequestCurrentVehicleLocationTest& from) { + RequestCurrentVehicleLocationTest::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); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(RequestCurrentVehicleLocationTest* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::absl::string_view FullMessageName() { + return "messages.RequestCurrentVehicleLocationTest"; + } + protected: + explicit RequestCurrentVehicleLocationTest(::PROTOBUF_NAMESPACE_ID::Arena* arena); + 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 { + kVehicleIdentityFieldNumber = 1, + }; + // string vehicle_identity = 1; + void clear_vehicle_identity() ; + const std::string& vehicle_identity() const; + + + + + template + void set_vehicle_identity(Arg_&& arg, Args_... args); + std::string* mutable_vehicle_identity(); + PROTOBUF_NODISCARD std::string* release_vehicle_identity(); + void set_allocated_vehicle_identity(std::string* ptr); + + private: + const std::string& _internal_vehicle_identity() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_vehicle_identity( + const std::string& value); + std::string* _internal_mutable_vehicle_identity(); + + public: + // @@protoc_insertion_point(class_scope:messages.RequestCurrentVehicleLocationTest) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr vehicle_identity_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_messages_2fVehiclePrecisionLocation_2eproto; +};// ------------------------------------------------------------------- + +class ResponseCurrentVehicleLocation final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:messages.ResponseCurrentVehicleLocation) */ { + public: + inline ResponseCurrentVehicleLocation() : ResponseCurrentVehicleLocation(nullptr) {} + ~ResponseCurrentVehicleLocation() override; + explicit PROTOBUF_CONSTEXPR ResponseCurrentVehicleLocation(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + ResponseCurrentVehicleLocation(const ResponseCurrentVehicleLocation& from); + ResponseCurrentVehicleLocation(ResponseCurrentVehicleLocation&& from) noexcept + : ResponseCurrentVehicleLocation() { + *this = ::std::move(from); + } + + inline ResponseCurrentVehicleLocation& operator=(const ResponseCurrentVehicleLocation& from) { + CopyFrom(from); + return *this; + } + inline ResponseCurrentVehicleLocation& operator=(ResponseCurrentVehicleLocation&& 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 ResponseCurrentVehicleLocation& default_instance() { + return *internal_default_instance(); + } + static inline const ResponseCurrentVehicleLocation* internal_default_instance() { + return reinterpret_cast( + &_ResponseCurrentVehicleLocation_default_instance_); + } + static constexpr int kIndexInFileMessages = + 1; + + friend void swap(ResponseCurrentVehicleLocation& a, ResponseCurrentVehicleLocation& b) { + a.Swap(&b); + } + inline void Swap(ResponseCurrentVehicleLocation* 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(ResponseCurrentVehicleLocation* other) { + if (other == this) return; + ABSL_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ResponseCurrentVehicleLocation* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const ResponseCurrentVehicleLocation& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const ResponseCurrentVehicleLocation& from) { + ResponseCurrentVehicleLocation::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); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(ResponseCurrentVehicleLocation* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::absl::string_view FullMessageName() { + return "messages.ResponseCurrentVehicleLocation"; + } + protected: + explicit ResponseCurrentVehicleLocation(::PROTOBUF_NAMESPACE_ID::Arena* arena); + 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 { + kVehicleMessageHeadingFieldNumber = 1, + kVehicleCurrentLocationFieldNumber = 2, + kResponseStatusFieldNumber = 3, + }; + // .messages.VehicleMessageHeading vehicleMessageHeading = 1; + bool has_vehiclemessageheading() const; + private: + bool _internal_has_vehiclemessageheading() const; + + public: + void clear_vehiclemessageheading() ; + const ::messages::VehicleMessageHeading& vehiclemessageheading() const; + PROTOBUF_NODISCARD ::messages::VehicleMessageHeading* release_vehiclemessageheading(); + ::messages::VehicleMessageHeading* mutable_vehiclemessageheading(); + void set_allocated_vehiclemessageheading(::messages::VehicleMessageHeading* vehiclemessageheading); + private: + const ::messages::VehicleMessageHeading& _internal_vehiclemessageheading() const; + ::messages::VehicleMessageHeading* _internal_mutable_vehiclemessageheading(); + public: + void unsafe_arena_set_allocated_vehiclemessageheading( + ::messages::VehicleMessageHeading* vehiclemessageheading); + ::messages::VehicleMessageHeading* unsafe_arena_release_vehiclemessageheading(); + // .messages.VehicleCurrentLocation vehicleCurrentLocation = 2; + bool has_vehiclecurrentlocation() const; + private: + bool _internal_has_vehiclecurrentlocation() const; + + public: + void clear_vehiclecurrentlocation() ; + const ::messages::VehicleCurrentLocation& vehiclecurrentlocation() const; + PROTOBUF_NODISCARD ::messages::VehicleCurrentLocation* release_vehiclecurrentlocation(); + ::messages::VehicleCurrentLocation* mutable_vehiclecurrentlocation(); + void set_allocated_vehiclecurrentlocation(::messages::VehicleCurrentLocation* vehiclecurrentlocation); + private: + const ::messages::VehicleCurrentLocation& _internal_vehiclecurrentlocation() const; + ::messages::VehicleCurrentLocation* _internal_mutable_vehiclecurrentlocation(); + public: + void unsafe_arena_set_allocated_vehiclecurrentlocation( + ::messages::VehicleCurrentLocation* vehiclecurrentlocation); + ::messages::VehicleCurrentLocation* unsafe_arena_release_vehiclecurrentlocation(); + // .messages.ResponseStatusEnum responseStatus = 3; + void clear_responsestatus() ; + ::messages::ResponseStatusEnum responsestatus() const; + void set_responsestatus(::messages::ResponseStatusEnum value); + + private: + ::messages::ResponseStatusEnum _internal_responsestatus() const; + void _internal_set_responsestatus(::messages::ResponseStatusEnum value); + + public: + // @@protoc_insertion_point(class_scope:messages.ResponseCurrentVehicleLocation) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::messages::VehicleMessageHeading* vehiclemessageheading_; + ::messages::VehicleCurrentLocation* vehiclecurrentlocation_; + int responsestatus_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_messages_2fVehiclePrecisionLocation_2eproto; +};// ------------------------------------------------------------------- + +class PublishCurrentVehicleLocation final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:messages.PublishCurrentVehicleLocation) */ { + public: + inline PublishCurrentVehicleLocation() : PublishCurrentVehicleLocation(nullptr) {} + ~PublishCurrentVehicleLocation() override; + explicit PROTOBUF_CONSTEXPR PublishCurrentVehicleLocation(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + PublishCurrentVehicleLocation(const PublishCurrentVehicleLocation& from); + PublishCurrentVehicleLocation(PublishCurrentVehicleLocation&& from) noexcept + : PublishCurrentVehicleLocation() { + *this = ::std::move(from); + } + + inline PublishCurrentVehicleLocation& operator=(const PublishCurrentVehicleLocation& from) { + CopyFrom(from); + return *this; + } + inline PublishCurrentVehicleLocation& operator=(PublishCurrentVehicleLocation&& 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 PublishCurrentVehicleLocation& default_instance() { + return *internal_default_instance(); + } + static inline const PublishCurrentVehicleLocation* internal_default_instance() { + return reinterpret_cast( + &_PublishCurrentVehicleLocation_default_instance_); + } + static constexpr int kIndexInFileMessages = + 2; + + friend void swap(PublishCurrentVehicleLocation& a, PublishCurrentVehicleLocation& b) { + a.Swap(&b); + } + inline void Swap(PublishCurrentVehicleLocation* 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(PublishCurrentVehicleLocation* other) { + if (other == this) return; + ABSL_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + PublishCurrentVehicleLocation* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const PublishCurrentVehicleLocation& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const PublishCurrentVehicleLocation& from) { + PublishCurrentVehicleLocation::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); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(PublishCurrentVehicleLocation* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::absl::string_view FullMessageName() { + return "messages.PublishCurrentVehicleLocation"; + } + protected: + explicit PublishCurrentVehicleLocation(::PROTOBUF_NAMESPACE_ID::Arena* arena); + 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 { + kVehicleMessageHeadingFieldNumber = 1, + kVehicleCurrentLocationFieldNumber = 2, + }; + // .messages.VehicleMessageHeading vehicleMessageHeading = 1; + bool has_vehiclemessageheading() const; + private: + bool _internal_has_vehiclemessageheading() const; + + public: + void clear_vehiclemessageheading() ; + const ::messages::VehicleMessageHeading& vehiclemessageheading() const; + PROTOBUF_NODISCARD ::messages::VehicleMessageHeading* release_vehiclemessageheading(); + ::messages::VehicleMessageHeading* mutable_vehiclemessageheading(); + void set_allocated_vehiclemessageheading(::messages::VehicleMessageHeading* vehiclemessageheading); + private: + const ::messages::VehicleMessageHeading& _internal_vehiclemessageheading() const; + ::messages::VehicleMessageHeading* _internal_mutable_vehiclemessageheading(); + public: + void unsafe_arena_set_allocated_vehiclemessageheading( + ::messages::VehicleMessageHeading* vehiclemessageheading); + ::messages::VehicleMessageHeading* unsafe_arena_release_vehiclemessageheading(); + // .messages.VehicleCurrentLocation vehicleCurrentLocation = 2; + bool has_vehiclecurrentlocation() const; + private: + bool _internal_has_vehiclecurrentlocation() const; + + public: + void clear_vehiclecurrentlocation() ; + const ::messages::VehicleCurrentLocation& vehiclecurrentlocation() const; + PROTOBUF_NODISCARD ::messages::VehicleCurrentLocation* release_vehiclecurrentlocation(); + ::messages::VehicleCurrentLocation* mutable_vehiclecurrentlocation(); + void set_allocated_vehiclecurrentlocation(::messages::VehicleCurrentLocation* vehiclecurrentlocation); + private: + const ::messages::VehicleCurrentLocation& _internal_vehiclecurrentlocation() const; + ::messages::VehicleCurrentLocation* _internal_mutable_vehiclecurrentlocation(); + public: + void unsafe_arena_set_allocated_vehiclecurrentlocation( + ::messages::VehicleCurrentLocation* vehiclecurrentlocation); + ::messages::VehicleCurrentLocation* unsafe_arena_release_vehiclecurrentlocation(); + // @@protoc_insertion_point(class_scope:messages.PublishCurrentVehicleLocation) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::messages::VehicleMessageHeading* vehiclemessageheading_; + ::messages::VehicleCurrentLocation* vehiclecurrentlocation_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_messages_2fVehiclePrecisionLocation_2eproto; +};// ------------------------------------------------------------------- + +class VehicleCurrentLocation final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:messages.VehicleCurrentLocation) */ { + public: + inline VehicleCurrentLocation() : VehicleCurrentLocation(nullptr) {} + ~VehicleCurrentLocation() override; + explicit PROTOBUF_CONSTEXPR VehicleCurrentLocation(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + VehicleCurrentLocation(const VehicleCurrentLocation& from); + VehicleCurrentLocation(VehicleCurrentLocation&& from) noexcept + : VehicleCurrentLocation() { + *this = ::std::move(from); + } + + inline VehicleCurrentLocation& operator=(const VehicleCurrentLocation& from) { + CopyFrom(from); + return *this; + } + inline VehicleCurrentLocation& operator=(VehicleCurrentLocation&& 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 VehicleCurrentLocation& default_instance() { + return *internal_default_instance(); + } + static inline const VehicleCurrentLocation* internal_default_instance() { + return reinterpret_cast( + &_VehicleCurrentLocation_default_instance_); + } + static constexpr int kIndexInFileMessages = + 3; + + friend void swap(VehicleCurrentLocation& a, VehicleCurrentLocation& b) { + a.Swap(&b); + } + inline void Swap(VehicleCurrentLocation* 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(VehicleCurrentLocation* other) { + if (other == this) return; + ABSL_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + VehicleCurrentLocation* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const VehicleCurrentLocation& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const VehicleCurrentLocation& from) { + VehicleCurrentLocation::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); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(VehicleCurrentLocation* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::absl::string_view FullMessageName() { + return "messages.VehicleCurrentLocation"; + } + protected: + explicit VehicleCurrentLocation(::PROTOBUF_NAMESPACE_ID::Arena* arena); + 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 { + kTimestampFieldNumber = 1, + kGNSSReceiverFieldNumber = 8, + kLatitudeFieldNumber = 2, + kLongitudeFieldNumber = 3, + kHeadingFieldNumber = 4, + kHorizontalAccuracyFieldNumber = 5, + kAltitudeFieldNumber = 6, + kVerticalAccuracyFieldNumber = 7, + }; + // string Timestamp = 1; + void clear_timestamp() ; + const std::string& timestamp() const; + + + + + template + void set_timestamp(Arg_&& arg, Args_... args); + std::string* mutable_timestamp(); + PROTOBUF_NODISCARD std::string* release_timestamp(); + void set_allocated_timestamp(std::string* ptr); + + private: + const std::string& _internal_timestamp() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_timestamp( + const std::string& value); + std::string* _internal_mutable_timestamp(); + + public: + // .messages.VehicleCurrentLocationGNSSReceiver GNSSReceiver = 8; + bool has_gnssreceiver() const; + private: + bool _internal_has_gnssreceiver() const; + + public: + void clear_gnssreceiver() ; + const ::messages::VehicleCurrentLocationGNSSReceiver& gnssreceiver() const; + PROTOBUF_NODISCARD ::messages::VehicleCurrentLocationGNSSReceiver* release_gnssreceiver(); + ::messages::VehicleCurrentLocationGNSSReceiver* mutable_gnssreceiver(); + void set_allocated_gnssreceiver(::messages::VehicleCurrentLocationGNSSReceiver* gnssreceiver); + private: + const ::messages::VehicleCurrentLocationGNSSReceiver& _internal_gnssreceiver() const; + ::messages::VehicleCurrentLocationGNSSReceiver* _internal_mutable_gnssreceiver(); + public: + void unsafe_arena_set_allocated_gnssreceiver( + ::messages::VehicleCurrentLocationGNSSReceiver* gnssreceiver); + ::messages::VehicleCurrentLocationGNSSReceiver* unsafe_arena_release_gnssreceiver(); + // double Latitude = 2; + void clear_latitude() ; + double latitude() const; + void set_latitude(double value); + + private: + double _internal_latitude() const; + void _internal_set_latitude(double value); + + public: + // double Longitude = 3; + void clear_longitude() ; + double longitude() const; + void set_longitude(double value); + + private: + double _internal_longitude() const; + void _internal_set_longitude(double value); + + public: + // double Heading = 4; + void clear_heading() ; + double heading() const; + void set_heading(double value); + + private: + double _internal_heading() const; + void _internal_set_heading(double value); + + public: + // double HorizontalAccuracy = 5; + void clear_horizontalaccuracy() ; + double horizontalaccuracy() const; + void set_horizontalaccuracy(double value); + + private: + double _internal_horizontalaccuracy() const; + void _internal_set_horizontalaccuracy(double value); + + public: + // double Altitude = 6; + void clear_altitude() ; + double altitude() const; + void set_altitude(double value); + + private: + double _internal_altitude() const; + void _internal_set_altitude(double value); + + public: + // double VerticalAccuracy = 7; + void clear_verticalaccuracy() ; + double verticalaccuracy() const; + void set_verticalaccuracy(double value); + + private: + double _internal_verticalaccuracy() const; + void _internal_set_verticalaccuracy(double value); + + public: + // @@protoc_insertion_point(class_scope:messages.VehicleCurrentLocation) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr timestamp_; + ::messages::VehicleCurrentLocationGNSSReceiver* gnssreceiver_; + double latitude_; + double longitude_; + double heading_; + double horizontalaccuracy_; + double altitude_; + double verticalaccuracy_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_messages_2fVehiclePrecisionLocation_2eproto; +};// ------------------------------------------------------------------- + +class VehicleCurrentLocationGNSSReceiver final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:messages.VehicleCurrentLocationGNSSReceiver) */ { + public: + inline VehicleCurrentLocationGNSSReceiver() : VehicleCurrentLocationGNSSReceiver(nullptr) {} + ~VehicleCurrentLocationGNSSReceiver() override; + explicit PROTOBUF_CONSTEXPR VehicleCurrentLocationGNSSReceiver(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + VehicleCurrentLocationGNSSReceiver(const VehicleCurrentLocationGNSSReceiver& from); + VehicleCurrentLocationGNSSReceiver(VehicleCurrentLocationGNSSReceiver&& from) noexcept + : VehicleCurrentLocationGNSSReceiver() { + *this = ::std::move(from); + } + + inline VehicleCurrentLocationGNSSReceiver& operator=(const VehicleCurrentLocationGNSSReceiver& from) { + CopyFrom(from); + return *this; + } + inline VehicleCurrentLocationGNSSReceiver& operator=(VehicleCurrentLocationGNSSReceiver&& 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 VehicleCurrentLocationGNSSReceiver& default_instance() { + return *internal_default_instance(); + } + static inline const VehicleCurrentLocationGNSSReceiver* internal_default_instance() { + return reinterpret_cast( + &_VehicleCurrentLocationGNSSReceiver_default_instance_); + } + static constexpr int kIndexInFileMessages = + 4; + + friend void swap(VehicleCurrentLocationGNSSReceiver& a, VehicleCurrentLocationGNSSReceiver& b) { + a.Swap(&b); + } + inline void Swap(VehicleCurrentLocationGNSSReceiver* 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(VehicleCurrentLocationGNSSReceiver* other) { + if (other == this) return; + ABSL_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + VehicleCurrentLocationGNSSReceiver* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const VehicleCurrentLocationGNSSReceiver& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const VehicleCurrentLocationGNSSReceiver& from) { + VehicleCurrentLocationGNSSReceiver::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); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(VehicleCurrentLocationGNSSReceiver* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::absl::string_view FullMessageName() { + return "messages.VehicleCurrentLocationGNSSReceiver"; + } + protected: + explicit VehicleCurrentLocationGNSSReceiver(::PROTOBUF_NAMESPACE_ID::Arena* arena); + 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 { + kFixTypeFieldNumber = 1, + kMountingPositionFieldNumber = 2, + }; + // string FixType = 1; + void clear_fixtype() ; + const std::string& fixtype() const; + + + + + template + void set_fixtype(Arg_&& arg, Args_... args); + std::string* mutable_fixtype(); + PROTOBUF_NODISCARD std::string* release_fixtype(); + void set_allocated_fixtype(std::string* ptr); + + private: + const std::string& _internal_fixtype() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_fixtype( + const std::string& value); + std::string* _internal_mutable_fixtype(); + + public: + // .messages.VehicleCurrentLocationGNSSReceiverMountingPosition MountingPosition = 2; + bool has_mountingposition() const; + private: + bool _internal_has_mountingposition() const; + + public: + void clear_mountingposition() ; + const ::messages::VehicleCurrentLocationGNSSReceiverMountingPosition& mountingposition() const; + PROTOBUF_NODISCARD ::messages::VehicleCurrentLocationGNSSReceiverMountingPosition* release_mountingposition(); + ::messages::VehicleCurrentLocationGNSSReceiverMountingPosition* mutable_mountingposition(); + void set_allocated_mountingposition(::messages::VehicleCurrentLocationGNSSReceiverMountingPosition* mountingposition); + private: + const ::messages::VehicleCurrentLocationGNSSReceiverMountingPosition& _internal_mountingposition() const; + ::messages::VehicleCurrentLocationGNSSReceiverMountingPosition* _internal_mutable_mountingposition(); + public: + void unsafe_arena_set_allocated_mountingposition( + ::messages::VehicleCurrentLocationGNSSReceiverMountingPosition* mountingposition); + ::messages::VehicleCurrentLocationGNSSReceiverMountingPosition* unsafe_arena_release_mountingposition(); + // @@protoc_insertion_point(class_scope:messages.VehicleCurrentLocationGNSSReceiver) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fixtype_; + ::messages::VehicleCurrentLocationGNSSReceiverMountingPosition* mountingposition_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_messages_2fVehiclePrecisionLocation_2eproto; +};// ------------------------------------------------------------------- + +class VehicleCurrentLocationGNSSReceiverMountingPosition final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:messages.VehicleCurrentLocationGNSSReceiverMountingPosition) */ { + public: + inline VehicleCurrentLocationGNSSReceiverMountingPosition() : VehicleCurrentLocationGNSSReceiverMountingPosition(nullptr) {} + ~VehicleCurrentLocationGNSSReceiverMountingPosition() override; + explicit PROTOBUF_CONSTEXPR VehicleCurrentLocationGNSSReceiverMountingPosition(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + VehicleCurrentLocationGNSSReceiverMountingPosition(const VehicleCurrentLocationGNSSReceiverMountingPosition& from); + VehicleCurrentLocationGNSSReceiverMountingPosition(VehicleCurrentLocationGNSSReceiverMountingPosition&& from) noexcept + : VehicleCurrentLocationGNSSReceiverMountingPosition() { + *this = ::std::move(from); + } + + inline VehicleCurrentLocationGNSSReceiverMountingPosition& operator=(const VehicleCurrentLocationGNSSReceiverMountingPosition& from) { + CopyFrom(from); + return *this; + } + inline VehicleCurrentLocationGNSSReceiverMountingPosition& operator=(VehicleCurrentLocationGNSSReceiverMountingPosition&& 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 VehicleCurrentLocationGNSSReceiverMountingPosition& default_instance() { + return *internal_default_instance(); + } + static inline const VehicleCurrentLocationGNSSReceiverMountingPosition* internal_default_instance() { + return reinterpret_cast( + &_VehicleCurrentLocationGNSSReceiverMountingPosition_default_instance_); + } + static constexpr int kIndexInFileMessages = + 5; + + friend void swap(VehicleCurrentLocationGNSSReceiverMountingPosition& a, VehicleCurrentLocationGNSSReceiverMountingPosition& b) { + a.Swap(&b); + } + inline void Swap(VehicleCurrentLocationGNSSReceiverMountingPosition* 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(VehicleCurrentLocationGNSSReceiverMountingPosition* other) { + if (other == this) return; + ABSL_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + VehicleCurrentLocationGNSSReceiverMountingPosition* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const VehicleCurrentLocationGNSSReceiverMountingPosition& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const VehicleCurrentLocationGNSSReceiverMountingPosition& from) { + VehicleCurrentLocationGNSSReceiverMountingPosition::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); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(VehicleCurrentLocationGNSSReceiverMountingPosition* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::absl::string_view FullMessageName() { + return "messages.VehicleCurrentLocationGNSSReceiverMountingPosition"; + } + protected: + explicit VehicleCurrentLocationGNSSReceiverMountingPosition(::PROTOBUF_NAMESPACE_ID::Arena* arena); + 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 { + kXFieldNumber = 1, + kYFieldNumber = 2, + kZFieldNumber = 3, + }; + // int32 X = 1; + void clear_x() ; + ::int32_t x() const; + void set_x(::int32_t value); + + private: + ::int32_t _internal_x() const; + void _internal_set_x(::int32_t value); + + public: + // int32 Y = 2; + void clear_y() ; + ::int32_t y() const; + void set_y(::int32_t value); + + private: + ::int32_t _internal_y() const; + void _internal_set_y(::int32_t value); + + public: + // int32 Z = 3; + void clear_z() ; + ::int32_t z() const; + void set_z(::int32_t value); + + private: + ::int32_t _internal_z() const; + void _internal_set_z(::int32_t value); + + public: + // @@protoc_insertion_point(class_scope:messages.VehicleCurrentLocationGNSSReceiverMountingPosition) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::int32_t x_; + ::int32_t y_; + ::int32_t z_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_messages_2fVehiclePrecisionLocation_2eproto; +}; + +// =================================================================== + + + + +// =================================================================== + + +#ifdef __GNUC__ +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wstrict-aliasing" +#endif // __GNUC__ +// ------------------------------------------------------------------- + +// RequestCurrentVehicleLocationTest + +// string vehicle_identity = 1; +inline void RequestCurrentVehicleLocationTest::clear_vehicle_identity() { + _impl_.vehicle_identity_.ClearToEmpty(); +} +inline const std::string& RequestCurrentVehicleLocationTest::vehicle_identity() const { + // @@protoc_insertion_point(field_get:messages.RequestCurrentVehicleLocationTest.vehicle_identity) + return _internal_vehicle_identity(); +} +template +inline PROTOBUF_ALWAYS_INLINE void RequestCurrentVehicleLocationTest::set_vehicle_identity(Arg_&& arg, + Args_... args) { + ; + _impl_.vehicle_identity_.Set(static_cast(arg), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:messages.RequestCurrentVehicleLocationTest.vehicle_identity) +} +inline std::string* RequestCurrentVehicleLocationTest::mutable_vehicle_identity() { + std::string* _s = _internal_mutable_vehicle_identity(); + // @@protoc_insertion_point(field_mutable:messages.RequestCurrentVehicleLocationTest.vehicle_identity) + return _s; +} +inline const std::string& RequestCurrentVehicleLocationTest::_internal_vehicle_identity() const { + return _impl_.vehicle_identity_.Get(); +} +inline void RequestCurrentVehicleLocationTest::_internal_set_vehicle_identity(const std::string& value) { + ; + + + _impl_.vehicle_identity_.Set(value, GetArenaForAllocation()); +} +inline std::string* RequestCurrentVehicleLocationTest::_internal_mutable_vehicle_identity() { + ; + return _impl_.vehicle_identity_.Mutable( GetArenaForAllocation()); +} +inline std::string* RequestCurrentVehicleLocationTest::release_vehicle_identity() { + // @@protoc_insertion_point(field_release:messages.RequestCurrentVehicleLocationTest.vehicle_identity) + return _impl_.vehicle_identity_.Release(); +} +inline void RequestCurrentVehicleLocationTest::set_allocated_vehicle_identity(std::string* value) { + _impl_.vehicle_identity_.SetAllocated(value, GetArenaForAllocation()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.vehicle_identity_.IsDefault()) { + _impl_.vehicle_identity_.Set("", GetArenaForAllocation()); + } + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:messages.RequestCurrentVehicleLocationTest.vehicle_identity) +} + +// ------------------------------------------------------------------- + +// ResponseCurrentVehicleLocation + +// .messages.VehicleMessageHeading vehicleMessageHeading = 1; +inline bool ResponseCurrentVehicleLocation::_internal_has_vehiclemessageheading() const { + return this != internal_default_instance() && _impl_.vehiclemessageheading_ != nullptr; +} +inline bool ResponseCurrentVehicleLocation::has_vehiclemessageheading() const { + return _internal_has_vehiclemessageheading(); +} +inline const ::messages::VehicleMessageHeading& ResponseCurrentVehicleLocation::_internal_vehiclemessageheading() const { + const ::messages::VehicleMessageHeading* p = _impl_.vehiclemessageheading_; + return p != nullptr ? *p : reinterpret_cast( + ::messages::_VehicleMessageHeading_default_instance_); +} +inline const ::messages::VehicleMessageHeading& ResponseCurrentVehicleLocation::vehiclemessageheading() const { + // @@protoc_insertion_point(field_get:messages.ResponseCurrentVehicleLocation.vehicleMessageHeading) + return _internal_vehiclemessageheading(); +} +inline void ResponseCurrentVehicleLocation::unsafe_arena_set_allocated_vehiclemessageheading( + ::messages::VehicleMessageHeading* vehiclemessageheading) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.vehiclemessageheading_); + } + _impl_.vehiclemessageheading_ = vehiclemessageheading; + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:messages.ResponseCurrentVehicleLocation.vehicleMessageHeading) +} +inline ::messages::VehicleMessageHeading* ResponseCurrentVehicleLocation::release_vehiclemessageheading() { + + ::messages::VehicleMessageHeading* temp = _impl_.vehiclemessageheading_; + _impl_.vehiclemessageheading_ = 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::VehicleMessageHeading* ResponseCurrentVehicleLocation::unsafe_arena_release_vehiclemessageheading() { + // @@protoc_insertion_point(field_release:messages.ResponseCurrentVehicleLocation.vehicleMessageHeading) + + ::messages::VehicleMessageHeading* temp = _impl_.vehiclemessageheading_; + _impl_.vehiclemessageheading_ = nullptr; + return temp; +} +inline ::messages::VehicleMessageHeading* ResponseCurrentVehicleLocation::_internal_mutable_vehiclemessageheading() { + + if (_impl_.vehiclemessageheading_ == nullptr) { + auto* p = CreateMaybeMessage<::messages::VehicleMessageHeading>(GetArenaForAllocation()); + _impl_.vehiclemessageheading_ = p; + } + return _impl_.vehiclemessageheading_; +} +inline ::messages::VehicleMessageHeading* ResponseCurrentVehicleLocation::mutable_vehiclemessageheading() { + ::messages::VehicleMessageHeading* _msg = _internal_mutable_vehiclemessageheading(); + // @@protoc_insertion_point(field_mutable:messages.ResponseCurrentVehicleLocation.vehicleMessageHeading) + return _msg; +} +inline void ResponseCurrentVehicleLocation::set_allocated_vehiclemessageheading(::messages::VehicleMessageHeading* vehiclemessageheading) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.vehiclemessageheading_); + } + if (vehiclemessageheading) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena( + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(vehiclemessageheading)); + if (message_arena != submessage_arena) { + vehiclemessageheading = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, vehiclemessageheading, submessage_arena); + } + + } else { + + } + _impl_.vehiclemessageheading_ = vehiclemessageheading; + // @@protoc_insertion_point(field_set_allocated:messages.ResponseCurrentVehicleLocation.vehicleMessageHeading) +} + +// .messages.VehicleCurrentLocation vehicleCurrentLocation = 2; +inline bool ResponseCurrentVehicleLocation::_internal_has_vehiclecurrentlocation() const { + return this != internal_default_instance() && _impl_.vehiclecurrentlocation_ != nullptr; +} +inline bool ResponseCurrentVehicleLocation::has_vehiclecurrentlocation() const { + return _internal_has_vehiclecurrentlocation(); +} +inline void ResponseCurrentVehicleLocation::clear_vehiclecurrentlocation() { + if (GetArenaForAllocation() == nullptr && _impl_.vehiclecurrentlocation_ != nullptr) { + delete _impl_.vehiclecurrentlocation_; + } + _impl_.vehiclecurrentlocation_ = nullptr; +} +inline const ::messages::VehicleCurrentLocation& ResponseCurrentVehicleLocation::_internal_vehiclecurrentlocation() const { + const ::messages::VehicleCurrentLocation* p = _impl_.vehiclecurrentlocation_; + return p != nullptr ? *p : reinterpret_cast( + ::messages::_VehicleCurrentLocation_default_instance_); +} +inline const ::messages::VehicleCurrentLocation& ResponseCurrentVehicleLocation::vehiclecurrentlocation() const { + // @@protoc_insertion_point(field_get:messages.ResponseCurrentVehicleLocation.vehicleCurrentLocation) + return _internal_vehiclecurrentlocation(); +} +inline void ResponseCurrentVehicleLocation::unsafe_arena_set_allocated_vehiclecurrentlocation( + ::messages::VehicleCurrentLocation* vehiclecurrentlocation) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.vehiclecurrentlocation_); + } + _impl_.vehiclecurrentlocation_ = vehiclecurrentlocation; + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:messages.ResponseCurrentVehicleLocation.vehicleCurrentLocation) +} +inline ::messages::VehicleCurrentLocation* ResponseCurrentVehicleLocation::release_vehiclecurrentlocation() { + + ::messages::VehicleCurrentLocation* temp = _impl_.vehiclecurrentlocation_; + _impl_.vehiclecurrentlocation_ = 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::VehicleCurrentLocation* ResponseCurrentVehicleLocation::unsafe_arena_release_vehiclecurrentlocation() { + // @@protoc_insertion_point(field_release:messages.ResponseCurrentVehicleLocation.vehicleCurrentLocation) + + ::messages::VehicleCurrentLocation* temp = _impl_.vehiclecurrentlocation_; + _impl_.vehiclecurrentlocation_ = nullptr; + return temp; +} +inline ::messages::VehicleCurrentLocation* ResponseCurrentVehicleLocation::_internal_mutable_vehiclecurrentlocation() { + + if (_impl_.vehiclecurrentlocation_ == nullptr) { + auto* p = CreateMaybeMessage<::messages::VehicleCurrentLocation>(GetArenaForAllocation()); + _impl_.vehiclecurrentlocation_ = p; + } + return _impl_.vehiclecurrentlocation_; +} +inline ::messages::VehicleCurrentLocation* ResponseCurrentVehicleLocation::mutable_vehiclecurrentlocation() { + ::messages::VehicleCurrentLocation* _msg = _internal_mutable_vehiclecurrentlocation(); + // @@protoc_insertion_point(field_mutable:messages.ResponseCurrentVehicleLocation.vehicleCurrentLocation) + return _msg; +} +inline void ResponseCurrentVehicleLocation::set_allocated_vehiclecurrentlocation(::messages::VehicleCurrentLocation* vehiclecurrentlocation) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.vehiclecurrentlocation_; + } + if (vehiclecurrentlocation) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(vehiclecurrentlocation); + if (message_arena != submessage_arena) { + vehiclecurrentlocation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, vehiclecurrentlocation, submessage_arena); + } + + } else { + + } + _impl_.vehiclecurrentlocation_ = vehiclecurrentlocation; + // @@protoc_insertion_point(field_set_allocated:messages.ResponseCurrentVehicleLocation.vehicleCurrentLocation) +} + +// .messages.ResponseStatusEnum responseStatus = 3; +inline void ResponseCurrentVehicleLocation::clear_responsestatus() { + _impl_.responsestatus_ = 0; +} +inline ::messages::ResponseStatusEnum ResponseCurrentVehicleLocation::responsestatus() const { + // @@protoc_insertion_point(field_get:messages.ResponseCurrentVehicleLocation.responseStatus) + return _internal_responsestatus(); +} +inline void ResponseCurrentVehicleLocation::set_responsestatus(::messages::ResponseStatusEnum value) { + _internal_set_responsestatus(value); + // @@protoc_insertion_point(field_set:messages.ResponseCurrentVehicleLocation.responseStatus) +} +inline ::messages::ResponseStatusEnum ResponseCurrentVehicleLocation::_internal_responsestatus() const { + return static_cast<::messages::ResponseStatusEnum>(_impl_.responsestatus_); +} +inline void ResponseCurrentVehicleLocation::_internal_set_responsestatus(::messages::ResponseStatusEnum value) { + ; + _impl_.responsestatus_ = value; +} + +// ------------------------------------------------------------------- + +// PublishCurrentVehicleLocation + +// .messages.VehicleMessageHeading vehicleMessageHeading = 1; +inline bool PublishCurrentVehicleLocation::_internal_has_vehiclemessageheading() const { + return this != internal_default_instance() && _impl_.vehiclemessageheading_ != nullptr; +} +inline bool PublishCurrentVehicleLocation::has_vehiclemessageheading() const { + return _internal_has_vehiclemessageheading(); +} +inline const ::messages::VehicleMessageHeading& PublishCurrentVehicleLocation::_internal_vehiclemessageheading() const { + const ::messages::VehicleMessageHeading* p = _impl_.vehiclemessageheading_; + return p != nullptr ? *p : reinterpret_cast( + ::messages::_VehicleMessageHeading_default_instance_); +} +inline const ::messages::VehicleMessageHeading& PublishCurrentVehicleLocation::vehiclemessageheading() const { + // @@protoc_insertion_point(field_get:messages.PublishCurrentVehicleLocation.vehicleMessageHeading) + return _internal_vehiclemessageheading(); +} +inline void PublishCurrentVehicleLocation::unsafe_arena_set_allocated_vehiclemessageheading( + ::messages::VehicleMessageHeading* vehiclemessageheading) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.vehiclemessageheading_); + } + _impl_.vehiclemessageheading_ = vehiclemessageheading; + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:messages.PublishCurrentVehicleLocation.vehicleMessageHeading) +} +inline ::messages::VehicleMessageHeading* PublishCurrentVehicleLocation::release_vehiclemessageheading() { + + ::messages::VehicleMessageHeading* temp = _impl_.vehiclemessageheading_; + _impl_.vehiclemessageheading_ = 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::VehicleMessageHeading* PublishCurrentVehicleLocation::unsafe_arena_release_vehiclemessageheading() { + // @@protoc_insertion_point(field_release:messages.PublishCurrentVehicleLocation.vehicleMessageHeading) + + ::messages::VehicleMessageHeading* temp = _impl_.vehiclemessageheading_; + _impl_.vehiclemessageheading_ = nullptr; + return temp; +} +inline ::messages::VehicleMessageHeading* PublishCurrentVehicleLocation::_internal_mutable_vehiclemessageheading() { + + if (_impl_.vehiclemessageheading_ == nullptr) { + auto* p = CreateMaybeMessage<::messages::VehicleMessageHeading>(GetArenaForAllocation()); + _impl_.vehiclemessageheading_ = p; + } + return _impl_.vehiclemessageheading_; +} +inline ::messages::VehicleMessageHeading* PublishCurrentVehicleLocation::mutable_vehiclemessageheading() { + ::messages::VehicleMessageHeading* _msg = _internal_mutable_vehiclemessageheading(); + // @@protoc_insertion_point(field_mutable:messages.PublishCurrentVehicleLocation.vehicleMessageHeading) + return _msg; +} +inline void PublishCurrentVehicleLocation::set_allocated_vehiclemessageheading(::messages::VehicleMessageHeading* vehiclemessageheading) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.vehiclemessageheading_); + } + if (vehiclemessageheading) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena( + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(vehiclemessageheading)); + if (message_arena != submessage_arena) { + vehiclemessageheading = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, vehiclemessageheading, submessage_arena); + } + + } else { + + } + _impl_.vehiclemessageheading_ = vehiclemessageheading; + // @@protoc_insertion_point(field_set_allocated:messages.PublishCurrentVehicleLocation.vehicleMessageHeading) +} + +// .messages.VehicleCurrentLocation vehicleCurrentLocation = 2; +inline bool PublishCurrentVehicleLocation::_internal_has_vehiclecurrentlocation() const { + return this != internal_default_instance() && _impl_.vehiclecurrentlocation_ != nullptr; +} +inline bool PublishCurrentVehicleLocation::has_vehiclecurrentlocation() const { + return _internal_has_vehiclecurrentlocation(); +} +inline void PublishCurrentVehicleLocation::clear_vehiclecurrentlocation() { + if (GetArenaForAllocation() == nullptr && _impl_.vehiclecurrentlocation_ != nullptr) { + delete _impl_.vehiclecurrentlocation_; + } + _impl_.vehiclecurrentlocation_ = nullptr; +} +inline const ::messages::VehicleCurrentLocation& PublishCurrentVehicleLocation::_internal_vehiclecurrentlocation() const { + const ::messages::VehicleCurrentLocation* p = _impl_.vehiclecurrentlocation_; + return p != nullptr ? *p : reinterpret_cast( + ::messages::_VehicleCurrentLocation_default_instance_); +} +inline const ::messages::VehicleCurrentLocation& PublishCurrentVehicleLocation::vehiclecurrentlocation() const { + // @@protoc_insertion_point(field_get:messages.PublishCurrentVehicleLocation.vehicleCurrentLocation) + return _internal_vehiclecurrentlocation(); +} +inline void PublishCurrentVehicleLocation::unsafe_arena_set_allocated_vehiclecurrentlocation( + ::messages::VehicleCurrentLocation* vehiclecurrentlocation) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.vehiclecurrentlocation_); + } + _impl_.vehiclecurrentlocation_ = vehiclecurrentlocation; + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:messages.PublishCurrentVehicleLocation.vehicleCurrentLocation) +} +inline ::messages::VehicleCurrentLocation* PublishCurrentVehicleLocation::release_vehiclecurrentlocation() { + + ::messages::VehicleCurrentLocation* temp = _impl_.vehiclecurrentlocation_; + _impl_.vehiclecurrentlocation_ = 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::VehicleCurrentLocation* PublishCurrentVehicleLocation::unsafe_arena_release_vehiclecurrentlocation() { + // @@protoc_insertion_point(field_release:messages.PublishCurrentVehicleLocation.vehicleCurrentLocation) + + ::messages::VehicleCurrentLocation* temp = _impl_.vehiclecurrentlocation_; + _impl_.vehiclecurrentlocation_ = nullptr; + return temp; +} +inline ::messages::VehicleCurrentLocation* PublishCurrentVehicleLocation::_internal_mutable_vehiclecurrentlocation() { + + if (_impl_.vehiclecurrentlocation_ == nullptr) { + auto* p = CreateMaybeMessage<::messages::VehicleCurrentLocation>(GetArenaForAllocation()); + _impl_.vehiclecurrentlocation_ = p; + } + return _impl_.vehiclecurrentlocation_; +} +inline ::messages::VehicleCurrentLocation* PublishCurrentVehicleLocation::mutable_vehiclecurrentlocation() { + ::messages::VehicleCurrentLocation* _msg = _internal_mutable_vehiclecurrentlocation(); + // @@protoc_insertion_point(field_mutable:messages.PublishCurrentVehicleLocation.vehicleCurrentLocation) + return _msg; +} +inline void PublishCurrentVehicleLocation::set_allocated_vehiclecurrentlocation(::messages::VehicleCurrentLocation* vehiclecurrentlocation) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.vehiclecurrentlocation_; + } + if (vehiclecurrentlocation) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(vehiclecurrentlocation); + if (message_arena != submessage_arena) { + vehiclecurrentlocation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, vehiclecurrentlocation, submessage_arena); + } + + } else { + + } + _impl_.vehiclecurrentlocation_ = vehiclecurrentlocation; + // @@protoc_insertion_point(field_set_allocated:messages.PublishCurrentVehicleLocation.vehicleCurrentLocation) +} + +// ------------------------------------------------------------------- + +// VehicleCurrentLocation + +// string Timestamp = 1; +inline void VehicleCurrentLocation::clear_timestamp() { + _impl_.timestamp_.ClearToEmpty(); +} +inline const std::string& VehicleCurrentLocation::timestamp() const { + // @@protoc_insertion_point(field_get:messages.VehicleCurrentLocation.Timestamp) + return _internal_timestamp(); +} +template +inline PROTOBUF_ALWAYS_INLINE void VehicleCurrentLocation::set_timestamp(Arg_&& arg, + Args_... args) { + ; + _impl_.timestamp_.Set(static_cast(arg), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:messages.VehicleCurrentLocation.Timestamp) +} +inline std::string* VehicleCurrentLocation::mutable_timestamp() { + std::string* _s = _internal_mutable_timestamp(); + // @@protoc_insertion_point(field_mutable:messages.VehicleCurrentLocation.Timestamp) + return _s; +} +inline const std::string& VehicleCurrentLocation::_internal_timestamp() const { + return _impl_.timestamp_.Get(); +} +inline void VehicleCurrentLocation::_internal_set_timestamp(const std::string& value) { + ; + + + _impl_.timestamp_.Set(value, GetArenaForAllocation()); +} +inline std::string* VehicleCurrentLocation::_internal_mutable_timestamp() { + ; + return _impl_.timestamp_.Mutable( GetArenaForAllocation()); +} +inline std::string* VehicleCurrentLocation::release_timestamp() { + // @@protoc_insertion_point(field_release:messages.VehicleCurrentLocation.Timestamp) + return _impl_.timestamp_.Release(); +} +inline void VehicleCurrentLocation::set_allocated_timestamp(std::string* value) { + _impl_.timestamp_.SetAllocated(value, GetArenaForAllocation()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.timestamp_.IsDefault()) { + _impl_.timestamp_.Set("", GetArenaForAllocation()); + } + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:messages.VehicleCurrentLocation.Timestamp) +} + +// double Latitude = 2; +inline void VehicleCurrentLocation::clear_latitude() { + _impl_.latitude_ = 0; +} +inline double VehicleCurrentLocation::latitude() const { + // @@protoc_insertion_point(field_get:messages.VehicleCurrentLocation.Latitude) + return _internal_latitude(); +} +inline void VehicleCurrentLocation::set_latitude(double value) { + _internal_set_latitude(value); + // @@protoc_insertion_point(field_set:messages.VehicleCurrentLocation.Latitude) +} +inline double VehicleCurrentLocation::_internal_latitude() const { + return _impl_.latitude_; +} +inline void VehicleCurrentLocation::_internal_set_latitude(double value) { + ; + _impl_.latitude_ = value; +} + +// double Longitude = 3; +inline void VehicleCurrentLocation::clear_longitude() { + _impl_.longitude_ = 0; +} +inline double VehicleCurrentLocation::longitude() const { + // @@protoc_insertion_point(field_get:messages.VehicleCurrentLocation.Longitude) + return _internal_longitude(); +} +inline void VehicleCurrentLocation::set_longitude(double value) { + _internal_set_longitude(value); + // @@protoc_insertion_point(field_set:messages.VehicleCurrentLocation.Longitude) +} +inline double VehicleCurrentLocation::_internal_longitude() const { + return _impl_.longitude_; +} +inline void VehicleCurrentLocation::_internal_set_longitude(double value) { + ; + _impl_.longitude_ = value; +} + +// double Heading = 4; +inline void VehicleCurrentLocation::clear_heading() { + _impl_.heading_ = 0; +} +inline double VehicleCurrentLocation::heading() const { + // @@protoc_insertion_point(field_get:messages.VehicleCurrentLocation.Heading) + return _internal_heading(); +} +inline void VehicleCurrentLocation::set_heading(double value) { + _internal_set_heading(value); + // @@protoc_insertion_point(field_set:messages.VehicleCurrentLocation.Heading) +} +inline double VehicleCurrentLocation::_internal_heading() const { + return _impl_.heading_; +} +inline void VehicleCurrentLocation::_internal_set_heading(double value) { + ; + _impl_.heading_ = value; +} + +// double HorizontalAccuracy = 5; +inline void VehicleCurrentLocation::clear_horizontalaccuracy() { + _impl_.horizontalaccuracy_ = 0; +} +inline double VehicleCurrentLocation::horizontalaccuracy() const { + // @@protoc_insertion_point(field_get:messages.VehicleCurrentLocation.HorizontalAccuracy) + return _internal_horizontalaccuracy(); +} +inline void VehicleCurrentLocation::set_horizontalaccuracy(double value) { + _internal_set_horizontalaccuracy(value); + // @@protoc_insertion_point(field_set:messages.VehicleCurrentLocation.HorizontalAccuracy) +} +inline double VehicleCurrentLocation::_internal_horizontalaccuracy() const { + return _impl_.horizontalaccuracy_; +} +inline void VehicleCurrentLocation::_internal_set_horizontalaccuracy(double value) { + ; + _impl_.horizontalaccuracy_ = value; +} + +// double Altitude = 6; +inline void VehicleCurrentLocation::clear_altitude() { + _impl_.altitude_ = 0; +} +inline double VehicleCurrentLocation::altitude() const { + // @@protoc_insertion_point(field_get:messages.VehicleCurrentLocation.Altitude) + return _internal_altitude(); +} +inline void VehicleCurrentLocation::set_altitude(double value) { + _internal_set_altitude(value); + // @@protoc_insertion_point(field_set:messages.VehicleCurrentLocation.Altitude) +} +inline double VehicleCurrentLocation::_internal_altitude() const { + return _impl_.altitude_; +} +inline void VehicleCurrentLocation::_internal_set_altitude(double value) { + ; + _impl_.altitude_ = value; +} + +// double VerticalAccuracy = 7; +inline void VehicleCurrentLocation::clear_verticalaccuracy() { + _impl_.verticalaccuracy_ = 0; +} +inline double VehicleCurrentLocation::verticalaccuracy() const { + // @@protoc_insertion_point(field_get:messages.VehicleCurrentLocation.VerticalAccuracy) + return _internal_verticalaccuracy(); +} +inline void VehicleCurrentLocation::set_verticalaccuracy(double value) { + _internal_set_verticalaccuracy(value); + // @@protoc_insertion_point(field_set:messages.VehicleCurrentLocation.VerticalAccuracy) +} +inline double VehicleCurrentLocation::_internal_verticalaccuracy() const { + return _impl_.verticalaccuracy_; +} +inline void VehicleCurrentLocation::_internal_set_verticalaccuracy(double value) { + ; + _impl_.verticalaccuracy_ = value; +} + +// .messages.VehicleCurrentLocationGNSSReceiver GNSSReceiver = 8; +inline bool VehicleCurrentLocation::_internal_has_gnssreceiver() const { + return this != internal_default_instance() && _impl_.gnssreceiver_ != nullptr; +} +inline bool VehicleCurrentLocation::has_gnssreceiver() const { + return _internal_has_gnssreceiver(); +} +inline void VehicleCurrentLocation::clear_gnssreceiver() { + if (GetArenaForAllocation() == nullptr && _impl_.gnssreceiver_ != nullptr) { + delete _impl_.gnssreceiver_; + } + _impl_.gnssreceiver_ = nullptr; +} +inline const ::messages::VehicleCurrentLocationGNSSReceiver& VehicleCurrentLocation::_internal_gnssreceiver() const { + const ::messages::VehicleCurrentLocationGNSSReceiver* p = _impl_.gnssreceiver_; + return p != nullptr ? *p : reinterpret_cast( + ::messages::_VehicleCurrentLocationGNSSReceiver_default_instance_); +} +inline const ::messages::VehicleCurrentLocationGNSSReceiver& VehicleCurrentLocation::gnssreceiver() const { + // @@protoc_insertion_point(field_get:messages.VehicleCurrentLocation.GNSSReceiver) + return _internal_gnssreceiver(); +} +inline void VehicleCurrentLocation::unsafe_arena_set_allocated_gnssreceiver( + ::messages::VehicleCurrentLocationGNSSReceiver* gnssreceiver) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.gnssreceiver_); + } + _impl_.gnssreceiver_ = gnssreceiver; + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:messages.VehicleCurrentLocation.GNSSReceiver) +} +inline ::messages::VehicleCurrentLocationGNSSReceiver* VehicleCurrentLocation::release_gnssreceiver() { + + ::messages::VehicleCurrentLocationGNSSReceiver* temp = _impl_.gnssreceiver_; + _impl_.gnssreceiver_ = 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::VehicleCurrentLocationGNSSReceiver* VehicleCurrentLocation::unsafe_arena_release_gnssreceiver() { + // @@protoc_insertion_point(field_release:messages.VehicleCurrentLocation.GNSSReceiver) + + ::messages::VehicleCurrentLocationGNSSReceiver* temp = _impl_.gnssreceiver_; + _impl_.gnssreceiver_ = nullptr; + return temp; +} +inline ::messages::VehicleCurrentLocationGNSSReceiver* VehicleCurrentLocation::_internal_mutable_gnssreceiver() { + + if (_impl_.gnssreceiver_ == nullptr) { + auto* p = CreateMaybeMessage<::messages::VehicleCurrentLocationGNSSReceiver>(GetArenaForAllocation()); + _impl_.gnssreceiver_ = p; + } + return _impl_.gnssreceiver_; +} +inline ::messages::VehicleCurrentLocationGNSSReceiver* VehicleCurrentLocation::mutable_gnssreceiver() { + ::messages::VehicleCurrentLocationGNSSReceiver* _msg = _internal_mutable_gnssreceiver(); + // @@protoc_insertion_point(field_mutable:messages.VehicleCurrentLocation.GNSSReceiver) + return _msg; +} +inline void VehicleCurrentLocation::set_allocated_gnssreceiver(::messages::VehicleCurrentLocationGNSSReceiver* gnssreceiver) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.gnssreceiver_; + } + if (gnssreceiver) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(gnssreceiver); + if (message_arena != submessage_arena) { + gnssreceiver = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, gnssreceiver, submessage_arena); + } + + } else { + + } + _impl_.gnssreceiver_ = gnssreceiver; + // @@protoc_insertion_point(field_set_allocated:messages.VehicleCurrentLocation.GNSSReceiver) +} + +// ------------------------------------------------------------------- + +// VehicleCurrentLocationGNSSReceiver + +// string FixType = 1; +inline void VehicleCurrentLocationGNSSReceiver::clear_fixtype() { + _impl_.fixtype_.ClearToEmpty(); +} +inline const std::string& VehicleCurrentLocationGNSSReceiver::fixtype() const { + // @@protoc_insertion_point(field_get:messages.VehicleCurrentLocationGNSSReceiver.FixType) + return _internal_fixtype(); +} +template +inline PROTOBUF_ALWAYS_INLINE void VehicleCurrentLocationGNSSReceiver::set_fixtype(Arg_&& arg, + Args_... args) { + ; + _impl_.fixtype_.Set(static_cast(arg), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:messages.VehicleCurrentLocationGNSSReceiver.FixType) +} +inline std::string* VehicleCurrentLocationGNSSReceiver::mutable_fixtype() { + std::string* _s = _internal_mutable_fixtype(); + // @@protoc_insertion_point(field_mutable:messages.VehicleCurrentLocationGNSSReceiver.FixType) + return _s; +} +inline const std::string& VehicleCurrentLocationGNSSReceiver::_internal_fixtype() const { + return _impl_.fixtype_.Get(); +} +inline void VehicleCurrentLocationGNSSReceiver::_internal_set_fixtype(const std::string& value) { + ; + + + _impl_.fixtype_.Set(value, GetArenaForAllocation()); +} +inline std::string* VehicleCurrentLocationGNSSReceiver::_internal_mutable_fixtype() { + ; + return _impl_.fixtype_.Mutable( GetArenaForAllocation()); +} +inline std::string* VehicleCurrentLocationGNSSReceiver::release_fixtype() { + // @@protoc_insertion_point(field_release:messages.VehicleCurrentLocationGNSSReceiver.FixType) + return _impl_.fixtype_.Release(); +} +inline void VehicleCurrentLocationGNSSReceiver::set_allocated_fixtype(std::string* value) { + _impl_.fixtype_.SetAllocated(value, GetArenaForAllocation()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.fixtype_.IsDefault()) { + _impl_.fixtype_.Set("", GetArenaForAllocation()); + } + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:messages.VehicleCurrentLocationGNSSReceiver.FixType) +} + +// .messages.VehicleCurrentLocationGNSSReceiverMountingPosition MountingPosition = 2; +inline bool VehicleCurrentLocationGNSSReceiver::_internal_has_mountingposition() const { + return this != internal_default_instance() && _impl_.mountingposition_ != nullptr; +} +inline bool VehicleCurrentLocationGNSSReceiver::has_mountingposition() const { + return _internal_has_mountingposition(); +} +inline void VehicleCurrentLocationGNSSReceiver::clear_mountingposition() { + if (GetArenaForAllocation() == nullptr && _impl_.mountingposition_ != nullptr) { + delete _impl_.mountingposition_; + } + _impl_.mountingposition_ = nullptr; +} +inline const ::messages::VehicleCurrentLocationGNSSReceiverMountingPosition& VehicleCurrentLocationGNSSReceiver::_internal_mountingposition() const { + const ::messages::VehicleCurrentLocationGNSSReceiverMountingPosition* p = _impl_.mountingposition_; + return p != nullptr ? *p : reinterpret_cast( + ::messages::_VehicleCurrentLocationGNSSReceiverMountingPosition_default_instance_); +} +inline const ::messages::VehicleCurrentLocationGNSSReceiverMountingPosition& VehicleCurrentLocationGNSSReceiver::mountingposition() const { + // @@protoc_insertion_point(field_get:messages.VehicleCurrentLocationGNSSReceiver.MountingPosition) + return _internal_mountingposition(); +} +inline void VehicleCurrentLocationGNSSReceiver::unsafe_arena_set_allocated_mountingposition( + ::messages::VehicleCurrentLocationGNSSReceiverMountingPosition* mountingposition) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.mountingposition_); + } + _impl_.mountingposition_ = mountingposition; + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:messages.VehicleCurrentLocationGNSSReceiver.MountingPosition) +} +inline ::messages::VehicleCurrentLocationGNSSReceiverMountingPosition* VehicleCurrentLocationGNSSReceiver::release_mountingposition() { + + ::messages::VehicleCurrentLocationGNSSReceiverMountingPosition* temp = _impl_.mountingposition_; + _impl_.mountingposition_ = 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::VehicleCurrentLocationGNSSReceiverMountingPosition* VehicleCurrentLocationGNSSReceiver::unsafe_arena_release_mountingposition() { + // @@protoc_insertion_point(field_release:messages.VehicleCurrentLocationGNSSReceiver.MountingPosition) + + ::messages::VehicleCurrentLocationGNSSReceiverMountingPosition* temp = _impl_.mountingposition_; + _impl_.mountingposition_ = nullptr; + return temp; +} +inline ::messages::VehicleCurrentLocationGNSSReceiverMountingPosition* VehicleCurrentLocationGNSSReceiver::_internal_mutable_mountingposition() { + + if (_impl_.mountingposition_ == nullptr) { + auto* p = CreateMaybeMessage<::messages::VehicleCurrentLocationGNSSReceiverMountingPosition>(GetArenaForAllocation()); + _impl_.mountingposition_ = p; + } + return _impl_.mountingposition_; +} +inline ::messages::VehicleCurrentLocationGNSSReceiverMountingPosition* VehicleCurrentLocationGNSSReceiver::mutable_mountingposition() { + ::messages::VehicleCurrentLocationGNSSReceiverMountingPosition* _msg = _internal_mutable_mountingposition(); + // @@protoc_insertion_point(field_mutable:messages.VehicleCurrentLocationGNSSReceiver.MountingPosition) + return _msg; +} +inline void VehicleCurrentLocationGNSSReceiver::set_allocated_mountingposition(::messages::VehicleCurrentLocationGNSSReceiverMountingPosition* mountingposition) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.mountingposition_; + } + if (mountingposition) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(mountingposition); + if (message_arena != submessage_arena) { + mountingposition = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, mountingposition, submessage_arena); + } + + } else { + + } + _impl_.mountingposition_ = mountingposition; + // @@protoc_insertion_point(field_set_allocated:messages.VehicleCurrentLocationGNSSReceiver.MountingPosition) +} + +// ------------------------------------------------------------------- + +// VehicleCurrentLocationGNSSReceiverMountingPosition + +// int32 X = 1; +inline void VehicleCurrentLocationGNSSReceiverMountingPosition::clear_x() { + _impl_.x_ = 0; +} +inline ::int32_t VehicleCurrentLocationGNSSReceiverMountingPosition::x() const { + // @@protoc_insertion_point(field_get:messages.VehicleCurrentLocationGNSSReceiverMountingPosition.X) + return _internal_x(); +} +inline void VehicleCurrentLocationGNSSReceiverMountingPosition::set_x(::int32_t value) { + _internal_set_x(value); + // @@protoc_insertion_point(field_set:messages.VehicleCurrentLocationGNSSReceiverMountingPosition.X) +} +inline ::int32_t VehicleCurrentLocationGNSSReceiverMountingPosition::_internal_x() const { + return _impl_.x_; +} +inline void VehicleCurrentLocationGNSSReceiverMountingPosition::_internal_set_x(::int32_t value) { + ; + _impl_.x_ = value; +} + +// int32 Y = 2; +inline void VehicleCurrentLocationGNSSReceiverMountingPosition::clear_y() { + _impl_.y_ = 0; +} +inline ::int32_t VehicleCurrentLocationGNSSReceiverMountingPosition::y() const { + // @@protoc_insertion_point(field_get:messages.VehicleCurrentLocationGNSSReceiverMountingPosition.Y) + return _internal_y(); +} +inline void VehicleCurrentLocationGNSSReceiverMountingPosition::set_y(::int32_t value) { + _internal_set_y(value); + // @@protoc_insertion_point(field_set:messages.VehicleCurrentLocationGNSSReceiverMountingPosition.Y) +} +inline ::int32_t VehicleCurrentLocationGNSSReceiverMountingPosition::_internal_y() const { + return _impl_.y_; +} +inline void VehicleCurrentLocationGNSSReceiverMountingPosition::_internal_set_y(::int32_t value) { + ; + _impl_.y_ = value; +} + +// int32 Z = 3; +inline void VehicleCurrentLocationGNSSReceiverMountingPosition::clear_z() { + _impl_.z_ = 0; +} +inline ::int32_t VehicleCurrentLocationGNSSReceiverMountingPosition::z() const { + // @@protoc_insertion_point(field_get:messages.VehicleCurrentLocationGNSSReceiverMountingPosition.Z) + return _internal_z(); +} +inline void VehicleCurrentLocationGNSSReceiverMountingPosition::set_z(::int32_t value) { + _internal_set_z(value); + // @@protoc_insertion_point(field_set:messages.VehicleCurrentLocationGNSSReceiverMountingPosition.Z) +} +inline ::int32_t VehicleCurrentLocationGNSSReceiverMountingPosition::_internal_z() const { + return _impl_.z_; +} +inline void VehicleCurrentLocationGNSSReceiverMountingPosition::_internal_set_z(::int32_t value) { + ; + _impl_.z_ = value; +} + +#ifdef __GNUC__ +#pragma GCC diagnostic pop +#endif // __GNUC__ + +// @@protoc_insertion_point(namespace_scope) +} // namespace messages + + +PROTOBUF_NAMESPACE_OPEN + +template <> +struct is_proto_enum<::messages::ResponseStatusEnum> : std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor<::messages::ResponseStatusEnum>() { + return ::messages::ResponseStatusEnum_descriptor(); +} + +PROTOBUF_NAMESPACE_CLOSE + +// @@protoc_insertion_point(global_scope) + +#include "google/protobuf/port_undef.inc" + +#endif // GOOGLE_PROTOBUF_INCLUDED_messages_2fVehiclePrecisionLocation_2eproto_2epb_2eh diff --git a/bin/main/messages/VehicleRemoteHvac$CabinConditionStatusPublish$1.class b/bin/main/messages/VehicleRemoteHvac$CabinConditionStatusPublish$1.class new file mode 100644 index 0000000..6884330 Binary files /dev/null and b/bin/main/messages/VehicleRemoteHvac$CabinConditionStatusPublish$1.class differ diff --git a/bin/main/messages/VehicleRemoteHvac$CabinConditionStatusPublish$Builder.class b/bin/main/messages/VehicleRemoteHvac$CabinConditionStatusPublish$Builder.class new file mode 100644 index 0000000..4decc8c Binary files /dev/null and b/bin/main/messages/VehicleRemoteHvac$CabinConditionStatusPublish$Builder.class differ diff --git a/bin/main/messages/VehicleRemoteHvac$CabinConditionStatusPublish.class b/bin/main/messages/VehicleRemoteHvac$CabinConditionStatusPublish.class new file mode 100644 index 0000000..d41812d Binary files /dev/null and b/bin/main/messages/VehicleRemoteHvac$CabinConditionStatusPublish.class differ diff --git a/bin/main/messages/VehicleRemoteHvac$CabinConditionStatusPublishOrBuilder.class b/bin/main/messages/VehicleRemoteHvac$CabinConditionStatusPublishOrBuilder.class new file mode 100644 index 0000000..2d36289 Binary files /dev/null and b/bin/main/messages/VehicleRemoteHvac$CabinConditionStatusPublishOrBuilder.class differ diff --git a/bin/main/messages/VehicleRemoteHvac$CabinTemperature$1.class b/bin/main/messages/VehicleRemoteHvac$CabinTemperature$1.class new file mode 100644 index 0000000..fd66ec8 Binary files /dev/null and b/bin/main/messages/VehicleRemoteHvac$CabinTemperature$1.class differ diff --git a/bin/main/messages/VehicleRemoteHvac$CabinTemperature$Builder.class b/bin/main/messages/VehicleRemoteHvac$CabinTemperature$Builder.class new file mode 100644 index 0000000..62a9bb4 Binary files /dev/null and b/bin/main/messages/VehicleRemoteHvac$CabinTemperature$Builder.class differ diff --git a/bin/main/messages/VehicleRemoteHvac$CabinTemperature.class b/bin/main/messages/VehicleRemoteHvac$CabinTemperature.class new file mode 100644 index 0000000..1da45a4 Binary files /dev/null and b/bin/main/messages/VehicleRemoteHvac$CabinTemperature.class differ diff --git a/bin/main/messages/VehicleRemoteHvac$CabinTemperatureOrBuilder.class b/bin/main/messages/VehicleRemoteHvac$CabinTemperatureOrBuilder.class new file mode 100644 index 0000000..4969e9b Binary files /dev/null and b/bin/main/messages/VehicleRemoteHvac$CabinTemperatureOrBuilder.class differ diff --git a/bin/main/messages/VehicleRemoteHvac$HVACState$1.class b/bin/main/messages/VehicleRemoteHvac$HVACState$1.class new file mode 100644 index 0000000..ca51dcf Binary files /dev/null and b/bin/main/messages/VehicleRemoteHvac$HVACState$1.class differ diff --git a/bin/main/messages/VehicleRemoteHvac$HVACState$Builder.class b/bin/main/messages/VehicleRemoteHvac$HVACState$Builder.class new file mode 100644 index 0000000..89e0f38 Binary files /dev/null and b/bin/main/messages/VehicleRemoteHvac$HVACState$Builder.class differ diff --git a/bin/main/messages/VehicleRemoteHvac$HVACState$State$1.class b/bin/main/messages/VehicleRemoteHvac$HVACState$State$1.class new file mode 100644 index 0000000..6c24d67 Binary files /dev/null and b/bin/main/messages/VehicleRemoteHvac$HVACState$State$1.class differ diff --git a/bin/main/messages/VehicleRemoteHvac$HVACState$State.class b/bin/main/messages/VehicleRemoteHvac$HVACState$State.class new file mode 100644 index 0000000..db8c0f3 Binary files /dev/null and b/bin/main/messages/VehicleRemoteHvac$HVACState$State.class differ diff --git a/bin/main/messages/VehicleRemoteHvac$HVACState.class b/bin/main/messages/VehicleRemoteHvac$HVACState.class new file mode 100644 index 0000000..687b873 Binary files /dev/null and b/bin/main/messages/VehicleRemoteHvac$HVACState.class differ diff --git a/bin/main/messages/VehicleRemoteHvac$HVACStateOrBuilder.class b/bin/main/messages/VehicleRemoteHvac$HVACStateOrBuilder.class new file mode 100644 index 0000000..1a40cdf Binary files /dev/null and b/bin/main/messages/VehicleRemoteHvac$HVACStateOrBuilder.class differ diff --git a/bin/main/messages/VehicleRemoteHvac$HVACZone$1.class b/bin/main/messages/VehicleRemoteHvac$HVACZone$1.class new file mode 100644 index 0000000..b4ec060 Binary files /dev/null and b/bin/main/messages/VehicleRemoteHvac$HVACZone$1.class differ diff --git a/bin/main/messages/VehicleRemoteHvac$HVACZone$Builder.class b/bin/main/messages/VehicleRemoteHvac$HVACZone$Builder.class new file mode 100644 index 0000000..3d19cce Binary files /dev/null and b/bin/main/messages/VehicleRemoteHvac$HVACZone$Builder.class differ diff --git a/bin/main/messages/VehicleRemoteHvac$HVACZone$Zone$1.class b/bin/main/messages/VehicleRemoteHvac$HVACZone$Zone$1.class new file mode 100644 index 0000000..04958f8 Binary files /dev/null and b/bin/main/messages/VehicleRemoteHvac$HVACZone$Zone$1.class differ diff --git a/bin/main/messages/VehicleRemoteHvac$HVACZone$Zone.class b/bin/main/messages/VehicleRemoteHvac$HVACZone$Zone.class new file mode 100644 index 0000000..c9452e4 Binary files /dev/null and b/bin/main/messages/VehicleRemoteHvac$HVACZone$Zone.class differ diff --git a/bin/main/messages/VehicleRemoteHvac$HVACZone.class b/bin/main/messages/VehicleRemoteHvac$HVACZone.class new file mode 100644 index 0000000..0331f15 Binary files /dev/null and b/bin/main/messages/VehicleRemoteHvac$HVACZone.class differ diff --git a/bin/main/messages/VehicleRemoteHvac$HVACZoneOrBuilder.class b/bin/main/messages/VehicleRemoteHvac$HVACZoneOrBuilder.class new file mode 100644 index 0000000..04cba43 Binary files /dev/null and b/bin/main/messages/VehicleRemoteHvac$HVACZoneOrBuilder.class differ diff --git a/bin/main/messages/VehicleRemoteHvac$PreconditionRequest$1.class b/bin/main/messages/VehicleRemoteHvac$PreconditionRequest$1.class new file mode 100644 index 0000000..2fa6ffc Binary files /dev/null and b/bin/main/messages/VehicleRemoteHvac$PreconditionRequest$1.class differ diff --git a/bin/main/messages/VehicleRemoteHvac$PreconditionRequest$Builder.class b/bin/main/messages/VehicleRemoteHvac$PreconditionRequest$Builder.class new file mode 100644 index 0000000..7885b9e Binary files /dev/null and b/bin/main/messages/VehicleRemoteHvac$PreconditionRequest$Builder.class differ diff --git a/bin/main/messages/VehicleRemoteHvac$PreconditionRequest.class b/bin/main/messages/VehicleRemoteHvac$PreconditionRequest.class new file mode 100644 index 0000000..9d315b0 Binary files /dev/null and b/bin/main/messages/VehicleRemoteHvac$PreconditionRequest.class differ diff --git a/bin/main/messages/VehicleRemoteHvac$PreconditionRequestOrBuilder.class b/bin/main/messages/VehicleRemoteHvac$PreconditionRequestOrBuilder.class new file mode 100644 index 0000000..efc80ab Binary files /dev/null and b/bin/main/messages/VehicleRemoteHvac$PreconditionRequestOrBuilder.class differ diff --git a/bin/main/messages/VehicleRemoteHvac$PreconditionResponse$1.class b/bin/main/messages/VehicleRemoteHvac$PreconditionResponse$1.class new file mode 100644 index 0000000..68b6bbd Binary files /dev/null and b/bin/main/messages/VehicleRemoteHvac$PreconditionResponse$1.class differ diff --git a/bin/main/messages/VehicleRemoteHvac$PreconditionResponse$Builder.class b/bin/main/messages/VehicleRemoteHvac$PreconditionResponse$Builder.class new file mode 100644 index 0000000..48fd51e Binary files /dev/null and b/bin/main/messages/VehicleRemoteHvac$PreconditionResponse$Builder.class differ diff --git a/bin/main/messages/VehicleRemoteHvac$PreconditionResponse$Status$1.class b/bin/main/messages/VehicleRemoteHvac$PreconditionResponse$Status$1.class new file mode 100644 index 0000000..89a0440 Binary files /dev/null and b/bin/main/messages/VehicleRemoteHvac$PreconditionResponse$Status$1.class differ diff --git a/bin/main/messages/VehicleRemoteHvac$PreconditionResponse$Status.class b/bin/main/messages/VehicleRemoteHvac$PreconditionResponse$Status.class new file mode 100644 index 0000000..290da9d Binary files /dev/null and b/bin/main/messages/VehicleRemoteHvac$PreconditionResponse$Status.class differ diff --git a/bin/main/messages/VehicleRemoteHvac$PreconditionResponse.class b/bin/main/messages/VehicleRemoteHvac$PreconditionResponse.class new file mode 100644 index 0000000..8e90fb3 Binary files /dev/null and b/bin/main/messages/VehicleRemoteHvac$PreconditionResponse.class differ diff --git a/bin/main/messages/VehicleRemoteHvac$PreconditionResponseOrBuilder.class b/bin/main/messages/VehicleRemoteHvac$PreconditionResponseOrBuilder.class new file mode 100644 index 0000000..eeabbe9 Binary files /dev/null and b/bin/main/messages/VehicleRemoteHvac$PreconditionResponseOrBuilder.class differ diff --git a/bin/main/messages/VehicleRemoteHvac$Temperature$1.class b/bin/main/messages/VehicleRemoteHvac$Temperature$1.class new file mode 100644 index 0000000..970f87d Binary files /dev/null and b/bin/main/messages/VehicleRemoteHvac$Temperature$1.class differ diff --git a/bin/main/messages/VehicleRemoteHvac$Temperature$Builder.class b/bin/main/messages/VehicleRemoteHvac$Temperature$Builder.class new file mode 100644 index 0000000..14f9c07 Binary files /dev/null and b/bin/main/messages/VehicleRemoteHvac$Temperature$Builder.class differ diff --git a/bin/main/messages/VehicleRemoteHvac$Temperature.class b/bin/main/messages/VehicleRemoteHvac$Temperature.class new file mode 100644 index 0000000..0d1fdfc Binary files /dev/null and b/bin/main/messages/VehicleRemoteHvac$Temperature.class differ diff --git a/bin/main/messages/VehicleRemoteHvac$TemperatureOrBuilder.class b/bin/main/messages/VehicleRemoteHvac$TemperatureOrBuilder.class new file mode 100644 index 0000000..5812a5f Binary files /dev/null and b/bin/main/messages/VehicleRemoteHvac$TemperatureOrBuilder.class differ diff --git a/bin/main/messages/VehicleRemoteHvac.class b/bin/main/messages/VehicleRemoteHvac.class new file mode 100644 index 0000000..522ca3f Binary files /dev/null and b/bin/main/messages/VehicleRemoteHvac.class differ diff --git a/bin/main/messages/VehicleRemoteHvac.pb.cc b/bin/main/messages/VehicleRemoteHvac.pb.cc new file mode 100644 index 0000000..b5e6d96 --- /dev/null +++ b/bin/main/messages/VehicleRemoteHvac.pb.cc @@ -0,0 +1,2097 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: messages/VehicleRemoteHvac.proto + +#include "messages/VehicleRemoteHvac.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" +// @@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 CabinConditionStatusPublish::CabinConditionStatusPublish( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_.event_time_)*/nullptr + , /*decltype(_impl_.hvac_state_)*/nullptr + , /*decltype(_impl_.cabin_temperature_)*/nullptr + , /*decltype(_impl_._cached_size_)*/{}} {} +struct CabinConditionStatusPublishDefaultTypeInternal { + PROTOBUF_CONSTEXPR CabinConditionStatusPublishDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~CabinConditionStatusPublishDefaultTypeInternal() {} + union { + CabinConditionStatusPublish _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CabinConditionStatusPublishDefaultTypeInternal _CabinConditionStatusPublish_default_instance_; +PROTOBUF_CONSTEXPR PreconditionRequest::PreconditionRequest( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_.hvac_zones_)*/{} + , /*decltype(_impl_.start_time_)*/nullptr + , /*decltype(_impl_._cached_size_)*/{}} {} +struct PreconditionRequestDefaultTypeInternal { + PROTOBUF_CONSTEXPR PreconditionRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~PreconditionRequestDefaultTypeInternal() {} + union { + PreconditionRequest _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PreconditionRequestDefaultTypeInternal _PreconditionRequest_default_instance_; +PROTOBUF_CONSTEXPR PreconditionResponse::PreconditionResponse( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_.message_)*/ { + &::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized {} + } + + , /*decltype(_impl_.status_)*/ 0 + + , /*decltype(_impl_._cached_size_)*/{}} {} +struct PreconditionResponseDefaultTypeInternal { + PROTOBUF_CONSTEXPR PreconditionResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~PreconditionResponseDefaultTypeInternal() {} + union { + PreconditionResponse _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PreconditionResponseDefaultTypeInternal _PreconditionResponse_default_instance_; +PROTOBUF_CONSTEXPR CabinTemperature::CabinTemperature( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_.temperature_)*/nullptr + , /*decltype(_impl_.zone_)*/nullptr + , /*decltype(_impl_._cached_size_)*/{}} {} +struct CabinTemperatureDefaultTypeInternal { + PROTOBUF_CONSTEXPR CabinTemperatureDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~CabinTemperatureDefaultTypeInternal() {} + union { + CabinTemperature _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CabinTemperatureDefaultTypeInternal _CabinTemperature_default_instance_; +PROTOBUF_CONSTEXPR Temperature::Temperature( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_.unit_)*/ { + &::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized {} + } + + , /*decltype(_impl_.value_)*/ 0 + + , /*decltype(_impl_._cached_size_)*/{}} {} +struct TemperatureDefaultTypeInternal { + PROTOBUF_CONSTEXPR TemperatureDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~TemperatureDefaultTypeInternal() {} + union { + Temperature _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TemperatureDefaultTypeInternal _Temperature_default_instance_; +PROTOBUF_CONSTEXPR HVACZone::HVACZone( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_.target_temperature_)*/nullptr + , /*decltype(_impl_.zone_)*/ 0 + + , /*decltype(_impl_._cached_size_)*/{}} {} +struct HVACZoneDefaultTypeInternal { + PROTOBUF_CONSTEXPR HVACZoneDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~HVACZoneDefaultTypeInternal() {} + union { + HVACZone _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 HVACZoneDefaultTypeInternal _HVACZone_default_instance_; +PROTOBUF_CONSTEXPR HVACState::HVACState( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_.current_zone_)*/nullptr + , /*decltype(_impl_.state_)*/ 0 + + , /*decltype(_impl_._cached_size_)*/{}} {} +struct HVACStateDefaultTypeInternal { + PROTOBUF_CONSTEXPR HVACStateDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~HVACStateDefaultTypeInternal() {} + union { + HVACState _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 HVACStateDefaultTypeInternal _HVACState_default_instance_; +} // namespace messages +static ::_pb::Metadata file_level_metadata_messages_2fVehicleRemoteHvac_2eproto[7]; +static const ::_pb::EnumDescriptor* file_level_enum_descriptors_messages_2fVehicleRemoteHvac_2eproto[3]; +static constexpr const ::_pb::ServiceDescriptor** + file_level_service_descriptors_messages_2fVehicleRemoteHvac_2eproto = nullptr; +const ::uint32_t TableStruct_messages_2fVehicleRemoteHvac_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE( + protodesc_cold) = { + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::messages::CabinConditionStatusPublish, _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::CabinConditionStatusPublish, _impl_.event_time_), + PROTOBUF_FIELD_OFFSET(::messages::CabinConditionStatusPublish, _impl_.hvac_state_), + PROTOBUF_FIELD_OFFSET(::messages::CabinConditionStatusPublish, _impl_.cabin_temperature_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::messages::PreconditionRequest, _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::PreconditionRequest, _impl_.hvac_zones_), + PROTOBUF_FIELD_OFFSET(::messages::PreconditionRequest, _impl_.start_time_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::messages::PreconditionResponse, _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::PreconditionResponse, _impl_.status_), + PROTOBUF_FIELD_OFFSET(::messages::PreconditionResponse, _impl_.message_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::messages::CabinTemperature, _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::CabinTemperature, _impl_.temperature_), + PROTOBUF_FIELD_OFFSET(::messages::CabinTemperature, _impl_.zone_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::messages::Temperature, _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::Temperature, _impl_.value_), + PROTOBUF_FIELD_OFFSET(::messages::Temperature, _impl_.unit_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::messages::HVACZone, _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::HVACZone, _impl_.zone_), + PROTOBUF_FIELD_OFFSET(::messages::HVACZone, _impl_.target_temperature_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::messages::HVACState, _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::HVACState, _impl_.state_), + PROTOBUF_FIELD_OFFSET(::messages::HVACState, _impl_.current_zone_), +}; + +static const ::_pbi::MigrationSchema + schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { + { 0, -1, -1, sizeof(::messages::CabinConditionStatusPublish)}, + { 11, -1, -1, sizeof(::messages::PreconditionRequest)}, + { 21, -1, -1, sizeof(::messages::PreconditionResponse)}, + { 31, -1, -1, sizeof(::messages::CabinTemperature)}, + { 41, -1, -1, sizeof(::messages::Temperature)}, + { 51, -1, -1, sizeof(::messages::HVACZone)}, + { 61, -1, -1, sizeof(::messages::HVACState)}, +}; + +static const ::_pb::Message* const file_default_instances[] = { + &::messages::_CabinConditionStatusPublish_default_instance_._instance, + &::messages::_PreconditionRequest_default_instance_._instance, + &::messages::_PreconditionResponse_default_instance_._instance, + &::messages::_CabinTemperature_default_instance_._instance, + &::messages::_Temperature_default_instance_._instance, + &::messages::_HVACZone_default_instance_._instance, + &::messages::_HVACState_default_instance_._instance, +}; +const char descriptor_table_protodef_messages_2fVehicleRemoteHvac_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { + "\n messages/VehicleRemoteHvac.proto\022\010mess" + "ages\032\037google/protobuf/timestamp.proto\"\255\001" + "\n\033CabinConditionStatusPublish\022.\n\nevent_t" + "ime\030\001 \001(\0132\032.google.protobuf.Timestamp\022\'\n" + "\nhvac_state\030\002 \001(\0132\023.messages.HVACState\0225" + "\n\021cabin_temperature\030\003 \001(\0132\032.messages.Cab" + "inTemperature\"m\n\023PreconditionRequest\022&\n\n" + "hvac_zones\030\001 \003(\0132\022.messages.HVACZone\022.\n\n" + "start_time\030\002 \001(\0132\032.google.protobuf.Times" + "tamp\"\217\001\n\024PreconditionResponse\0225\n\006status\030" + "\001 \001(\0162%.messages.PreconditionResponse.St" + "atus\022\017\n\007message\030\002 \001(\t\"/\n\006Status\022\013\n\007SUCCE" + "SS\020\000\022\013\n\007FAILURE\020\001\022\013\n\007PENDING\020\002\"`\n\020CabinT" + "emperature\022*\n\013temperature\030\001 \001(\0132\025.messag" + "es.Temperature\022 \n\004zone\030\002 \001(\0132\022.messages." + "HVACZone\"*\n\013Temperature\022\r\n\005value\030\001 \001(\002\022\014" + "\n\004unit\030\002 \001(\t\"\246\001\n\010HVACZone\022%\n\004zone\030\001 \001(\0162" + "\027.messages.HVACZone.Zone\0221\n\022target_tempe" + "rature\030\002 \001(\0132\025.messages.Temperature\"@\n\004Z" + "one\022\n\n\006DRIVER\020\000\022\r\n\tPASSENGER\020\001\022\r\n\tREAR_L" + "EFT\020\002\022\016\n\nREAR_RIGHT\020\003\"\225\001\n\tHVACState\022(\n\005s" + "tate\030\001 \001(\0162\031.messages.HVACState.State\022(\n" + "\014current_zone\030\002 \001(\0132\022.messages.HVACZone\"" + "4\n\005State\022\007\n\003OFF\020\000\022\013\n\007HEATING\020\001\022\013\n\007COOLIN" + "G\020\002\022\010\n\004IDLE\020\003b\006proto3" +}; +static const ::_pbi::DescriptorTable* const descriptor_table_messages_2fVehicleRemoteHvac_2eproto_deps[1] = + { + &::descriptor_table_google_2fprotobuf_2ftimestamp_2eproto, +}; +static ::absl::once_flag descriptor_table_messages_2fVehicleRemoteHvac_2eproto_once; +const ::_pbi::DescriptorTable descriptor_table_messages_2fVehicleRemoteHvac_2eproto = { + false, + false, + 981, + descriptor_table_protodef_messages_2fVehicleRemoteHvac_2eproto, + "messages/VehicleRemoteHvac.proto", + &descriptor_table_messages_2fVehicleRemoteHvac_2eproto_once, + descriptor_table_messages_2fVehicleRemoteHvac_2eproto_deps, + 1, + 7, + schemas, + file_default_instances, + TableStruct_messages_2fVehicleRemoteHvac_2eproto::offsets, + file_level_metadata_messages_2fVehicleRemoteHvac_2eproto, + file_level_enum_descriptors_messages_2fVehicleRemoteHvac_2eproto, + file_level_service_descriptors_messages_2fVehicleRemoteHvac_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_2fVehicleRemoteHvac_2eproto_getter() { + return &descriptor_table_messages_2fVehicleRemoteHvac_2eproto; +} +// Force running AddDescriptors() at dynamic initialization time. +PROTOBUF_ATTRIBUTE_INIT_PRIORITY2 +static ::_pbi::AddDescriptorsRunner dynamic_init_dummy_messages_2fVehicleRemoteHvac_2eproto(&descriptor_table_messages_2fVehicleRemoteHvac_2eproto); +namespace messages { +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* PreconditionResponse_Status_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_messages_2fVehicleRemoteHvac_2eproto); + return file_level_enum_descriptors_messages_2fVehicleRemoteHvac_2eproto[0]; +} +bool PreconditionResponse_Status_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + return true; + default: + return false; + } +} +#if (__cplusplus < 201703) && \ + (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) + +constexpr PreconditionResponse_Status PreconditionResponse::SUCCESS; +constexpr PreconditionResponse_Status PreconditionResponse::FAILURE; +constexpr PreconditionResponse_Status PreconditionResponse::PENDING; +constexpr PreconditionResponse_Status PreconditionResponse::Status_MIN; +constexpr PreconditionResponse_Status PreconditionResponse::Status_MAX; +constexpr int PreconditionResponse::Status_ARRAYSIZE; + +#endif // (__cplusplus < 201703) && + // (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* HVACZone_Zone_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_messages_2fVehicleRemoteHvac_2eproto); + return file_level_enum_descriptors_messages_2fVehicleRemoteHvac_2eproto[1]; +} +bool HVACZone_Zone_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + case 3: + return true; + default: + return false; + } +} +#if (__cplusplus < 201703) && \ + (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) + +constexpr HVACZone_Zone HVACZone::DRIVER; +constexpr HVACZone_Zone HVACZone::PASSENGER; +constexpr HVACZone_Zone HVACZone::REAR_LEFT; +constexpr HVACZone_Zone HVACZone::REAR_RIGHT; +constexpr HVACZone_Zone HVACZone::Zone_MIN; +constexpr HVACZone_Zone HVACZone::Zone_MAX; +constexpr int HVACZone::Zone_ARRAYSIZE; + +#endif // (__cplusplus < 201703) && + // (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* HVACState_State_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_messages_2fVehicleRemoteHvac_2eproto); + return file_level_enum_descriptors_messages_2fVehicleRemoteHvac_2eproto[2]; +} +bool HVACState_State_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + case 3: + return true; + default: + return false; + } +} +#if (__cplusplus < 201703) && \ + (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) + +constexpr HVACState_State HVACState::OFF; +constexpr HVACState_State HVACState::HEATING; +constexpr HVACState_State HVACState::COOLING; +constexpr HVACState_State HVACState::IDLE; +constexpr HVACState_State HVACState::State_MIN; +constexpr HVACState_State HVACState::State_MAX; +constexpr int HVACState::State_ARRAYSIZE; + +#endif // (__cplusplus < 201703) && + // (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +// =================================================================== + +class CabinConditionStatusPublish::_Internal { + public: + static const ::PROTOBUF_NAMESPACE_ID::Timestamp& event_time(const CabinConditionStatusPublish* msg); + static const ::messages::HVACState& hvac_state(const CabinConditionStatusPublish* msg); + static const ::messages::CabinTemperature& cabin_temperature(const CabinConditionStatusPublish* msg); +}; + +const ::PROTOBUF_NAMESPACE_ID::Timestamp& +CabinConditionStatusPublish::_Internal::event_time(const CabinConditionStatusPublish* msg) { + return *msg->_impl_.event_time_; +} +const ::messages::HVACState& +CabinConditionStatusPublish::_Internal::hvac_state(const CabinConditionStatusPublish* msg) { + return *msg->_impl_.hvac_state_; +} +const ::messages::CabinTemperature& +CabinConditionStatusPublish::_Internal::cabin_temperature(const CabinConditionStatusPublish* msg) { + return *msg->_impl_.cabin_temperature_; +} +void CabinConditionStatusPublish::clear_event_time() { + if (GetArenaForAllocation() == nullptr && _impl_.event_time_ != nullptr) { + delete _impl_.event_time_; + } + _impl_.event_time_ = nullptr; +} +CabinConditionStatusPublish::CabinConditionStatusPublish(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:messages.CabinConditionStatusPublish) +} +CabinConditionStatusPublish::CabinConditionStatusPublish(const CabinConditionStatusPublish& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + CabinConditionStatusPublish* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_.event_time_){nullptr} + , decltype(_impl_.hvac_state_){nullptr} + , decltype(_impl_.cabin_temperature_){nullptr} + , /*decltype(_impl_._cached_size_)*/{}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_event_time()) { + _this->_impl_.event_time_ = new ::PROTOBUF_NAMESPACE_ID::Timestamp(*from._impl_.event_time_); + } + if (from._internal_has_hvac_state()) { + _this->_impl_.hvac_state_ = new ::messages::HVACState(*from._impl_.hvac_state_); + } + if (from._internal_has_cabin_temperature()) { + _this->_impl_.cabin_temperature_ = new ::messages::CabinTemperature(*from._impl_.cabin_temperature_); + } + // @@protoc_insertion_point(copy_constructor:messages.CabinConditionStatusPublish) +} + +inline void CabinConditionStatusPublish::SharedCtor(::_pb::Arena* arena) { + (void)arena; + new (&_impl_) Impl_{ + decltype(_impl_.event_time_){nullptr} + , decltype(_impl_.hvac_state_){nullptr} + , decltype(_impl_.cabin_temperature_){nullptr} + , /*decltype(_impl_._cached_size_)*/{} + }; +} + +CabinConditionStatusPublish::~CabinConditionStatusPublish() { + // @@protoc_insertion_point(destructor:messages.CabinConditionStatusPublish) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void CabinConditionStatusPublish::SharedDtor() { + ABSL_DCHECK(GetArenaForAllocation() == nullptr); + if (this != internal_default_instance()) delete _impl_.event_time_; + if (this != internal_default_instance()) delete _impl_.hvac_state_; + if (this != internal_default_instance()) delete _impl_.cabin_temperature_; +} + +void CabinConditionStatusPublish::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void CabinConditionStatusPublish::Clear() { +// @@protoc_insertion_point(message_clear_start:messages.CabinConditionStatusPublish) + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + if (GetArenaForAllocation() == nullptr && _impl_.event_time_ != nullptr) { + delete _impl_.event_time_; + } + _impl_.event_time_ = nullptr; + if (GetArenaForAllocation() == nullptr && _impl_.hvac_state_ != nullptr) { + delete _impl_.hvac_state_; + } + _impl_.hvac_state_ = nullptr; + if (GetArenaForAllocation() == nullptr && _impl_.cabin_temperature_ != nullptr) { + delete _impl_.cabin_temperature_; + } + _impl_.cabin_temperature_ = nullptr; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* CabinConditionStatusPublish::_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) { + // .google.protobuf.Timestamp event_time = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_event_time(), ptr); + CHK_(ptr); + } else { + goto handle_unusual; + } + continue; + // .messages.HVACState hvac_state = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_hvac_state(), ptr); + CHK_(ptr); + } else { + goto handle_unusual; + } + continue; + // .messages.CabinTemperature cabin_temperature = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) { + ptr = ctx->ParseMessage(_internal_mutable_cabin_temperature(), 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: + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +::uint8_t* CabinConditionStatusPublish::_InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:messages.CabinConditionStatusPublish) + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + // .google.protobuf.Timestamp event_time = 1; + if (this->_internal_has_event_time()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, _Internal::event_time(this), + _Internal::event_time(this).GetCachedSize(), target, stream); + } + + // .messages.HVACState hvac_state = 2; + if (this->_internal_has_hvac_state()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(2, _Internal::hvac_state(this), + _Internal::hvac_state(this).GetCachedSize(), target, stream); + } + + // .messages.CabinTemperature cabin_temperature = 3; + if (this->_internal_has_cabin_temperature()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(3, _Internal::cabin_temperature(this), + _Internal::cabin_temperature(this).GetCachedSize(), target, stream); + } + + 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.CabinConditionStatusPublish) + return target; +} + +::size_t CabinConditionStatusPublish::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:messages.CabinConditionStatusPublish) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // .google.protobuf.Timestamp event_time = 1; + if (this->_internal_has_event_time()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.event_time_); + } + + // .messages.HVACState hvac_state = 2; + if (this->_internal_has_hvac_state()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.hvac_state_); + } + + // .messages.CabinTemperature cabin_temperature = 3; + if (this->_internal_has_cabin_temperature()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.cabin_temperature_); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData CabinConditionStatusPublish::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + CabinConditionStatusPublish::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*CabinConditionStatusPublish::GetClassData() const { return &_class_data_; } + + +void CabinConditionStatusPublish::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.CabinConditionStatusPublish) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_has_event_time()) { + _this->_internal_mutable_event_time()->::PROTOBUF_NAMESPACE_ID::Timestamp::MergeFrom( + from._internal_event_time()); + } + if (from._internal_has_hvac_state()) { + _this->_internal_mutable_hvac_state()->::messages::HVACState::MergeFrom( + from._internal_hvac_state()); + } + if (from._internal_has_cabin_temperature()) { + _this->_internal_mutable_cabin_temperature()->::messages::CabinTemperature::MergeFrom( + from._internal_cabin_temperature()); + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void CabinConditionStatusPublish::CopyFrom(const CabinConditionStatusPublish& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:messages.CabinConditionStatusPublish) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool CabinConditionStatusPublish::IsInitialized() const { + return true; +} + +void CabinConditionStatusPublish::InternalSwap(CabinConditionStatusPublish* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(CabinConditionStatusPublish, _impl_.cabin_temperature_) + + sizeof(CabinConditionStatusPublish::_impl_.cabin_temperature_) + - PROTOBUF_FIELD_OFFSET(CabinConditionStatusPublish, _impl_.event_time_)>( + reinterpret_cast(&_impl_.event_time_), + reinterpret_cast(&other->_impl_.event_time_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata CabinConditionStatusPublish::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_messages_2fVehicleRemoteHvac_2eproto_getter, &descriptor_table_messages_2fVehicleRemoteHvac_2eproto_once, + file_level_metadata_messages_2fVehicleRemoteHvac_2eproto[0]); +} +// =================================================================== + +class PreconditionRequest::_Internal { + public: + static const ::PROTOBUF_NAMESPACE_ID::Timestamp& start_time(const PreconditionRequest* msg); +}; + +const ::PROTOBUF_NAMESPACE_ID::Timestamp& +PreconditionRequest::_Internal::start_time(const PreconditionRequest* msg) { + return *msg->_impl_.start_time_; +} +void PreconditionRequest::clear_start_time() { + if (GetArenaForAllocation() == nullptr && _impl_.start_time_ != nullptr) { + delete _impl_.start_time_; + } + _impl_.start_time_ = nullptr; +} +PreconditionRequest::PreconditionRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:messages.PreconditionRequest) +} +PreconditionRequest::PreconditionRequest(const PreconditionRequest& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + PreconditionRequest* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_.hvac_zones_){from._impl_.hvac_zones_} + , decltype(_impl_.start_time_){nullptr} + , /*decltype(_impl_._cached_size_)*/{}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_start_time()) { + _this->_impl_.start_time_ = new ::PROTOBUF_NAMESPACE_ID::Timestamp(*from._impl_.start_time_); + } + // @@protoc_insertion_point(copy_constructor:messages.PreconditionRequest) +} + +inline void PreconditionRequest::SharedCtor(::_pb::Arena* arena) { + (void)arena; + new (&_impl_) Impl_{ + decltype(_impl_.hvac_zones_){arena} + , decltype(_impl_.start_time_){nullptr} + , /*decltype(_impl_._cached_size_)*/{} + }; +} + +PreconditionRequest::~PreconditionRequest() { + // @@protoc_insertion_point(destructor:messages.PreconditionRequest) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void PreconditionRequest::SharedDtor() { + ABSL_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.hvac_zones_.~RepeatedPtrField(); + if (this != internal_default_instance()) delete _impl_.start_time_; +} + +void PreconditionRequest::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void PreconditionRequest::Clear() { +// @@protoc_insertion_point(message_clear_start:messages.PreconditionRequest) + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.hvac_zones_.Clear(); + if (GetArenaForAllocation() == nullptr && _impl_.start_time_ != nullptr) { + delete _impl_.start_time_; + } + _impl_.start_time_ = nullptr; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* PreconditionRequest::_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) { + // repeated .messages.HVACZone hvac_zones = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_hvac_zones(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); + } else { + goto handle_unusual; + } + continue; + // .google.protobuf.Timestamp start_time = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_start_time(), 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: + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +::uint8_t* PreconditionRequest::_InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:messages.PreconditionRequest) + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + // repeated .messages.HVACZone hvac_zones = 1; + for (unsigned i = 0, + n = static_cast(this->_internal_hvac_zones_size()); i < n; i++) { + const auto& repfield = this->_internal_hvac_zones(i); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, repfield, repfield.GetCachedSize(), target, stream); + } + + // .google.protobuf.Timestamp start_time = 2; + if (this->_internal_has_start_time()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(2, _Internal::start_time(this), + _Internal::start_time(this).GetCachedSize(), target, stream); + } + + 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.PreconditionRequest) + return target; +} + +::size_t PreconditionRequest::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:messages.PreconditionRequest) + ::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.HVACZone hvac_zones = 1; + total_size += 1UL * this->_internal_hvac_zones_size(); + for (const auto& msg : this->_impl_.hvac_zones_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // .google.protobuf.Timestamp start_time = 2; + if (this->_internal_has_start_time()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.start_time_); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData PreconditionRequest::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + PreconditionRequest::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*PreconditionRequest::GetClassData() const { return &_class_data_; } + + +void PreconditionRequest::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.PreconditionRequest) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + _this->_impl_.hvac_zones_.MergeFrom(from._impl_.hvac_zones_); + if (from._internal_has_start_time()) { + _this->_internal_mutable_start_time()->::PROTOBUF_NAMESPACE_ID::Timestamp::MergeFrom( + from._internal_start_time()); + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void PreconditionRequest::CopyFrom(const PreconditionRequest& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:messages.PreconditionRequest) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool PreconditionRequest::IsInitialized() const { + return true; +} + +void PreconditionRequest::InternalSwap(PreconditionRequest* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + _impl_.hvac_zones_.InternalSwap(&other->_impl_.hvac_zones_); + swap(_impl_.start_time_, other->_impl_.start_time_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata PreconditionRequest::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_messages_2fVehicleRemoteHvac_2eproto_getter, &descriptor_table_messages_2fVehicleRemoteHvac_2eproto_once, + file_level_metadata_messages_2fVehicleRemoteHvac_2eproto[1]); +} +// =================================================================== + +class PreconditionResponse::_Internal { + public: +}; + +PreconditionResponse::PreconditionResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:messages.PreconditionResponse) +} +PreconditionResponse::PreconditionResponse(const PreconditionResponse& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + PreconditionResponse* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_.message_) {} + + , decltype(_impl_.status_) {} + + , /*decltype(_impl_._cached_size_)*/{}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.message_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.message_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (!from._internal_message().empty()) { + _this->_impl_.message_.Set(from._internal_message(), _this->GetArenaForAllocation()); + } + _this->_impl_.status_ = from._impl_.status_; + // @@protoc_insertion_point(copy_constructor:messages.PreconditionResponse) +} + +inline void PreconditionResponse::SharedCtor(::_pb::Arena* arena) { + (void)arena; + new (&_impl_) Impl_{ + decltype(_impl_.message_) {} + + , decltype(_impl_.status_) { 0 } + + , /*decltype(_impl_._cached_size_)*/{} + }; + _impl_.message_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.message_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +PreconditionResponse::~PreconditionResponse() { + // @@protoc_insertion_point(destructor:messages.PreconditionResponse) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void PreconditionResponse::SharedDtor() { + ABSL_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.message_.Destroy(); +} + +void PreconditionResponse::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void PreconditionResponse::Clear() { +// @@protoc_insertion_point(message_clear_start:messages.PreconditionResponse) + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.message_.ClearToEmpty(); + _impl_.status_ = 0; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* PreconditionResponse::_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) { + // .messages.PreconditionResponse.Status status = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) { + ::uint32_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + _internal_set_status(static_cast<::messages::PreconditionResponse_Status>(val)); + } else { + goto handle_unusual; + } + continue; + // string message = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) { + auto str = _internal_mutable_message(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + CHK_(::_pbi::VerifyUTF8(str, "messages.PreconditionResponse.message")); + } 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* PreconditionResponse::_InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:messages.PreconditionResponse) + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + // .messages.PreconditionResponse.Status status = 1; + if (this->_internal_status() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 1, this->_internal_status(), target); + } + + // string message = 2; + if (!this->_internal_message().empty()) { + const std::string& _s = this->_internal_message(); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "messages.PreconditionResponse.message"); + target = stream->WriteStringMaybeAliased(2, _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.PreconditionResponse) + return target; +} + +::size_t PreconditionResponse::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:messages.PreconditionResponse) + ::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 message = 2; + if (!this->_internal_message().empty()) { + total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_message()); + } + + // .messages.PreconditionResponse.Status status = 1; + if (this->_internal_status() != 0) { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_status()); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData PreconditionResponse::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + PreconditionResponse::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*PreconditionResponse::GetClassData() const { return &_class_data_; } + + +void PreconditionResponse::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.PreconditionResponse) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (!from._internal_message().empty()) { + _this->_internal_set_message(from._internal_message()); + } + if (from._internal_status() != 0) { + _this->_internal_set_status(from._internal_status()); + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void PreconditionResponse::CopyFrom(const PreconditionResponse& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:messages.PreconditionResponse) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool PreconditionResponse::IsInitialized() const { + return true; +} + +void PreconditionResponse::InternalSwap(PreconditionResponse* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.message_, lhs_arena, + &other->_impl_.message_, rhs_arena); + swap(_impl_.status_, other->_impl_.status_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata PreconditionResponse::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_messages_2fVehicleRemoteHvac_2eproto_getter, &descriptor_table_messages_2fVehicleRemoteHvac_2eproto_once, + file_level_metadata_messages_2fVehicleRemoteHvac_2eproto[2]); +} +// =================================================================== + +class CabinTemperature::_Internal { + public: + static const ::messages::Temperature& temperature(const CabinTemperature* msg); + static const ::messages::HVACZone& zone(const CabinTemperature* msg); +}; + +const ::messages::Temperature& +CabinTemperature::_Internal::temperature(const CabinTemperature* msg) { + return *msg->_impl_.temperature_; +} +const ::messages::HVACZone& +CabinTemperature::_Internal::zone(const CabinTemperature* msg) { + return *msg->_impl_.zone_; +} +CabinTemperature::CabinTemperature(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:messages.CabinTemperature) +} +CabinTemperature::CabinTemperature(const CabinTemperature& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + CabinTemperature* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_.temperature_){nullptr} + , decltype(_impl_.zone_){nullptr} + , /*decltype(_impl_._cached_size_)*/{}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_temperature()) { + _this->_impl_.temperature_ = new ::messages::Temperature(*from._impl_.temperature_); + } + if (from._internal_has_zone()) { + _this->_impl_.zone_ = new ::messages::HVACZone(*from._impl_.zone_); + } + // @@protoc_insertion_point(copy_constructor:messages.CabinTemperature) +} + +inline void CabinTemperature::SharedCtor(::_pb::Arena* arena) { + (void)arena; + new (&_impl_) Impl_{ + decltype(_impl_.temperature_){nullptr} + , decltype(_impl_.zone_){nullptr} + , /*decltype(_impl_._cached_size_)*/{} + }; +} + +CabinTemperature::~CabinTemperature() { + // @@protoc_insertion_point(destructor:messages.CabinTemperature) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void CabinTemperature::SharedDtor() { + ABSL_DCHECK(GetArenaForAllocation() == nullptr); + if (this != internal_default_instance()) delete _impl_.temperature_; + if (this != internal_default_instance()) delete _impl_.zone_; +} + +void CabinTemperature::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void CabinTemperature::Clear() { +// @@protoc_insertion_point(message_clear_start:messages.CabinTemperature) + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + if (GetArenaForAllocation() == nullptr && _impl_.temperature_ != nullptr) { + delete _impl_.temperature_; + } + _impl_.temperature_ = nullptr; + if (GetArenaForAllocation() == nullptr && _impl_.zone_ != nullptr) { + delete _impl_.zone_; + } + _impl_.zone_ = nullptr; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* CabinTemperature::_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) { + // .messages.Temperature temperature = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_temperature(), ptr); + CHK_(ptr); + } else { + goto handle_unusual; + } + continue; + // .messages.HVACZone zone = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_zone(), 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: + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +::uint8_t* CabinTemperature::_InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:messages.CabinTemperature) + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + // .messages.Temperature temperature = 1; + if (this->_internal_has_temperature()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, _Internal::temperature(this), + _Internal::temperature(this).GetCachedSize(), target, stream); + } + + // .messages.HVACZone zone = 2; + if (this->_internal_has_zone()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(2, _Internal::zone(this), + _Internal::zone(this).GetCachedSize(), target, stream); + } + + 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.CabinTemperature) + return target; +} + +::size_t CabinTemperature::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:messages.CabinTemperature) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // .messages.Temperature temperature = 1; + if (this->_internal_has_temperature()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.temperature_); + } + + // .messages.HVACZone zone = 2; + if (this->_internal_has_zone()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.zone_); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData CabinTemperature::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + CabinTemperature::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*CabinTemperature::GetClassData() const { return &_class_data_; } + + +void CabinTemperature::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.CabinTemperature) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_has_temperature()) { + _this->_internal_mutable_temperature()->::messages::Temperature::MergeFrom( + from._internal_temperature()); + } + if (from._internal_has_zone()) { + _this->_internal_mutable_zone()->::messages::HVACZone::MergeFrom( + from._internal_zone()); + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void CabinTemperature::CopyFrom(const CabinTemperature& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:messages.CabinTemperature) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool CabinTemperature::IsInitialized() const { + return true; +} + +void CabinTemperature::InternalSwap(CabinTemperature* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(CabinTemperature, _impl_.zone_) + + sizeof(CabinTemperature::_impl_.zone_) + - PROTOBUF_FIELD_OFFSET(CabinTemperature, _impl_.temperature_)>( + reinterpret_cast(&_impl_.temperature_), + reinterpret_cast(&other->_impl_.temperature_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata CabinTemperature::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_messages_2fVehicleRemoteHvac_2eproto_getter, &descriptor_table_messages_2fVehicleRemoteHvac_2eproto_once, + file_level_metadata_messages_2fVehicleRemoteHvac_2eproto[3]); +} +// =================================================================== + +class Temperature::_Internal { + public: +}; + +Temperature::Temperature(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:messages.Temperature) +} +Temperature::Temperature(const Temperature& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + Temperature* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_.unit_) {} + + , decltype(_impl_.value_) {} + + , /*decltype(_impl_._cached_size_)*/{}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.unit_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.unit_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (!from._internal_unit().empty()) { + _this->_impl_.unit_.Set(from._internal_unit(), _this->GetArenaForAllocation()); + } + _this->_impl_.value_ = from._impl_.value_; + // @@protoc_insertion_point(copy_constructor:messages.Temperature) +} + +inline void Temperature::SharedCtor(::_pb::Arena* arena) { + (void)arena; + new (&_impl_) Impl_{ + decltype(_impl_.unit_) {} + + , decltype(_impl_.value_) { 0 } + + , /*decltype(_impl_._cached_size_)*/{} + }; + _impl_.unit_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.unit_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +Temperature::~Temperature() { + // @@protoc_insertion_point(destructor:messages.Temperature) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void Temperature::SharedDtor() { + ABSL_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.unit_.Destroy(); +} + +void Temperature::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void Temperature::Clear() { +// @@protoc_insertion_point(message_clear_start:messages.Temperature) + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.unit_.ClearToEmpty(); + _impl_.value_ = 0; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Temperature::_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) { + // float value = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 13)) { + _impl_.value_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else { + goto handle_unusual; + } + continue; + // string unit = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) { + auto str = _internal_mutable_unit(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + CHK_(::_pbi::VerifyUTF8(str, "messages.Temperature.unit")); + } 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* Temperature::_InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:messages.Temperature) + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + // float value = 1; + static_assert(sizeof(::uint32_t) == sizeof(float), "Code assumes ::uint32_t and float are the same size."); + float tmp_value = this->_internal_value(); + ::uint32_t raw_value; + memcpy(&raw_value, &tmp_value, sizeof(tmp_value)); + if (raw_value != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteFloatToArray( + 1, this->_internal_value(), target); + } + + // string unit = 2; + if (!this->_internal_unit().empty()) { + const std::string& _s = this->_internal_unit(); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "messages.Temperature.unit"); + target = stream->WriteStringMaybeAliased(2, _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.Temperature) + return target; +} + +::size_t Temperature::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:messages.Temperature) + ::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 unit = 2; + if (!this->_internal_unit().empty()) { + total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_unit()); + } + + // float value = 1; + static_assert(sizeof(::uint32_t) == sizeof(float), "Code assumes ::uint32_t and float are the same size."); + float tmp_value = this->_internal_value(); + ::uint32_t raw_value; + memcpy(&raw_value, &tmp_value, sizeof(tmp_value)); + if (raw_value != 0) { + total_size += 5; + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Temperature::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + Temperature::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Temperature::GetClassData() const { return &_class_data_; } + + +void Temperature::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.Temperature) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (!from._internal_unit().empty()) { + _this->_internal_set_unit(from._internal_unit()); + } + static_assert(sizeof(::uint32_t) == sizeof(float), "Code assumes ::uint32_t and float are the same size."); + float tmp_value = from._internal_value(); + ::uint32_t raw_value; + memcpy(&raw_value, &tmp_value, sizeof(tmp_value)); + if (raw_value != 0) { + _this->_internal_set_value(from._internal_value()); + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void Temperature::CopyFrom(const Temperature& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:messages.Temperature) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Temperature::IsInitialized() const { + return true; +} + +void Temperature::InternalSwap(Temperature* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.unit_, lhs_arena, + &other->_impl_.unit_, rhs_arena); + + swap(_impl_.value_, other->_impl_.value_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Temperature::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_messages_2fVehicleRemoteHvac_2eproto_getter, &descriptor_table_messages_2fVehicleRemoteHvac_2eproto_once, + file_level_metadata_messages_2fVehicleRemoteHvac_2eproto[4]); +} +// =================================================================== + +class HVACZone::_Internal { + public: + static const ::messages::Temperature& target_temperature(const HVACZone* msg); +}; + +const ::messages::Temperature& +HVACZone::_Internal::target_temperature(const HVACZone* msg) { + return *msg->_impl_.target_temperature_; +} +HVACZone::HVACZone(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:messages.HVACZone) +} +HVACZone::HVACZone(const HVACZone& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + HVACZone* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_.target_temperature_){nullptr} + , decltype(_impl_.zone_) {} + + , /*decltype(_impl_._cached_size_)*/{}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_target_temperature()) { + _this->_impl_.target_temperature_ = new ::messages::Temperature(*from._impl_.target_temperature_); + } + _this->_impl_.zone_ = from._impl_.zone_; + // @@protoc_insertion_point(copy_constructor:messages.HVACZone) +} + +inline void HVACZone::SharedCtor(::_pb::Arena* arena) { + (void)arena; + new (&_impl_) Impl_{ + decltype(_impl_.target_temperature_){nullptr} + , decltype(_impl_.zone_) { 0 } + + , /*decltype(_impl_._cached_size_)*/{} + }; +} + +HVACZone::~HVACZone() { + // @@protoc_insertion_point(destructor:messages.HVACZone) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void HVACZone::SharedDtor() { + ABSL_DCHECK(GetArenaForAllocation() == nullptr); + if (this != internal_default_instance()) delete _impl_.target_temperature_; +} + +void HVACZone::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void HVACZone::Clear() { +// @@protoc_insertion_point(message_clear_start:messages.HVACZone) + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + if (GetArenaForAllocation() == nullptr && _impl_.target_temperature_ != nullptr) { + delete _impl_.target_temperature_; + } + _impl_.target_temperature_ = nullptr; + _impl_.zone_ = 0; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* HVACZone::_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) { + // .messages.HVACZone.Zone zone = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) { + ::uint32_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + _internal_set_zone(static_cast<::messages::HVACZone_Zone>(val)); + } else { + goto handle_unusual; + } + continue; + // .messages.Temperature target_temperature = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_target_temperature(), 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: + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +::uint8_t* HVACZone::_InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:messages.HVACZone) + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + // .messages.HVACZone.Zone zone = 1; + if (this->_internal_zone() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 1, this->_internal_zone(), target); + } + + // .messages.Temperature target_temperature = 2; + if (this->_internal_has_target_temperature()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(2, _Internal::target_temperature(this), + _Internal::target_temperature(this).GetCachedSize(), target, stream); + } + + 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.HVACZone) + return target; +} + +::size_t HVACZone::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:messages.HVACZone) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // .messages.Temperature target_temperature = 2; + if (this->_internal_has_target_temperature()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.target_temperature_); + } + + // .messages.HVACZone.Zone zone = 1; + if (this->_internal_zone() != 0) { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_zone()); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData HVACZone::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + HVACZone::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*HVACZone::GetClassData() const { return &_class_data_; } + + +void HVACZone::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.HVACZone) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_has_target_temperature()) { + _this->_internal_mutable_target_temperature()->::messages::Temperature::MergeFrom( + from._internal_target_temperature()); + } + if (from._internal_zone() != 0) { + _this->_internal_set_zone(from._internal_zone()); + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void HVACZone::CopyFrom(const HVACZone& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:messages.HVACZone) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool HVACZone::IsInitialized() const { + return true; +} + +void HVACZone::InternalSwap(HVACZone* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(HVACZone, _impl_.zone_) + + sizeof(HVACZone::_impl_.zone_) + - PROTOBUF_FIELD_OFFSET(HVACZone, _impl_.target_temperature_)>( + reinterpret_cast(&_impl_.target_temperature_), + reinterpret_cast(&other->_impl_.target_temperature_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata HVACZone::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_messages_2fVehicleRemoteHvac_2eproto_getter, &descriptor_table_messages_2fVehicleRemoteHvac_2eproto_once, + file_level_metadata_messages_2fVehicleRemoteHvac_2eproto[5]); +} +// =================================================================== + +class HVACState::_Internal { + public: + static const ::messages::HVACZone& current_zone(const HVACState* msg); +}; + +const ::messages::HVACZone& +HVACState::_Internal::current_zone(const HVACState* msg) { + return *msg->_impl_.current_zone_; +} +HVACState::HVACState(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:messages.HVACState) +} +HVACState::HVACState(const HVACState& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + HVACState* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_.current_zone_){nullptr} + , decltype(_impl_.state_) {} + + , /*decltype(_impl_._cached_size_)*/{}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_current_zone()) { + _this->_impl_.current_zone_ = new ::messages::HVACZone(*from._impl_.current_zone_); + } + _this->_impl_.state_ = from._impl_.state_; + // @@protoc_insertion_point(copy_constructor:messages.HVACState) +} + +inline void HVACState::SharedCtor(::_pb::Arena* arena) { + (void)arena; + new (&_impl_) Impl_{ + decltype(_impl_.current_zone_){nullptr} + , decltype(_impl_.state_) { 0 } + + , /*decltype(_impl_._cached_size_)*/{} + }; +} + +HVACState::~HVACState() { + // @@protoc_insertion_point(destructor:messages.HVACState) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void HVACState::SharedDtor() { + ABSL_DCHECK(GetArenaForAllocation() == nullptr); + if (this != internal_default_instance()) delete _impl_.current_zone_; +} + +void HVACState::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void HVACState::Clear() { +// @@protoc_insertion_point(message_clear_start:messages.HVACState) + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + if (GetArenaForAllocation() == nullptr && _impl_.current_zone_ != nullptr) { + delete _impl_.current_zone_; + } + _impl_.current_zone_ = nullptr; + _impl_.state_ = 0; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* HVACState::_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) { + // .messages.HVACState.State state = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) { + ::uint32_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + _internal_set_state(static_cast<::messages::HVACState_State>(val)); + } else { + goto handle_unusual; + } + continue; + // .messages.HVACZone current_zone = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_current_zone(), 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: + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +::uint8_t* HVACState::_InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:messages.HVACState) + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + // .messages.HVACState.State state = 1; + if (this->_internal_state() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 1, this->_internal_state(), target); + } + + // .messages.HVACZone current_zone = 2; + if (this->_internal_has_current_zone()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(2, _Internal::current_zone(this), + _Internal::current_zone(this).GetCachedSize(), target, stream); + } + + 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.HVACState) + return target; +} + +::size_t HVACState::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:messages.HVACState) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // .messages.HVACZone current_zone = 2; + if (this->_internal_has_current_zone()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.current_zone_); + } + + // .messages.HVACState.State state = 1; + if (this->_internal_state() != 0) { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_state()); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData HVACState::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + HVACState::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*HVACState::GetClassData() const { return &_class_data_; } + + +void HVACState::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.HVACState) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_has_current_zone()) { + _this->_internal_mutable_current_zone()->::messages::HVACZone::MergeFrom( + from._internal_current_zone()); + } + if (from._internal_state() != 0) { + _this->_internal_set_state(from._internal_state()); + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void HVACState::CopyFrom(const HVACState& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:messages.HVACState) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool HVACState::IsInitialized() const { + return true; +} + +void HVACState::InternalSwap(HVACState* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(HVACState, _impl_.state_) + + sizeof(HVACState::_impl_.state_) + - PROTOBUF_FIELD_OFFSET(HVACState, _impl_.current_zone_)>( + reinterpret_cast(&_impl_.current_zone_), + reinterpret_cast(&other->_impl_.current_zone_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata HVACState::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_messages_2fVehicleRemoteHvac_2eproto_getter, &descriptor_table_messages_2fVehicleRemoteHvac_2eproto_once, + file_level_metadata_messages_2fVehicleRemoteHvac_2eproto[6]); +} +// @@protoc_insertion_point(namespace_scope) +} // namespace messages +PROTOBUF_NAMESPACE_OPEN +template<> PROTOBUF_NOINLINE ::messages::CabinConditionStatusPublish* +Arena::CreateMaybeMessage< ::messages::CabinConditionStatusPublish >(Arena* arena) { + return Arena::CreateMessageInternal< ::messages::CabinConditionStatusPublish >(arena); +} +template<> PROTOBUF_NOINLINE ::messages::PreconditionRequest* +Arena::CreateMaybeMessage< ::messages::PreconditionRequest >(Arena* arena) { + return Arena::CreateMessageInternal< ::messages::PreconditionRequest >(arena); +} +template<> PROTOBUF_NOINLINE ::messages::PreconditionResponse* +Arena::CreateMaybeMessage< ::messages::PreconditionResponse >(Arena* arena) { + return Arena::CreateMessageInternal< ::messages::PreconditionResponse >(arena); +} +template<> PROTOBUF_NOINLINE ::messages::CabinTemperature* +Arena::CreateMaybeMessage< ::messages::CabinTemperature >(Arena* arena) { + return Arena::CreateMessageInternal< ::messages::CabinTemperature >(arena); +} +template<> PROTOBUF_NOINLINE ::messages::Temperature* +Arena::CreateMaybeMessage< ::messages::Temperature >(Arena* arena) { + return Arena::CreateMessageInternal< ::messages::Temperature >(arena); +} +template<> PROTOBUF_NOINLINE ::messages::HVACZone* +Arena::CreateMaybeMessage< ::messages::HVACZone >(Arena* arena) { + return Arena::CreateMessageInternal< ::messages::HVACZone >(arena); +} +template<> PROTOBUF_NOINLINE ::messages::HVACState* +Arena::CreateMaybeMessage< ::messages::HVACState >(Arena* arena) { + return Arena::CreateMessageInternal< ::messages::HVACState >(arena); +} +PROTOBUF_NAMESPACE_CLOSE +// @@protoc_insertion_point(global_scope) +#include "google/protobuf/port_undef.inc" diff --git a/bin/main/messages/VehicleRemoteHvac.pb.h b/bin/main/messages/VehicleRemoteHvac.pb.h new file mode 100644 index 0000000..e43bc55 --- /dev/null +++ b/bin/main/messages/VehicleRemoteHvac.pb.h @@ -0,0 +1,2444 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: messages/VehicleRemoteHvac.proto + +#ifndef GOOGLE_PROTOBUF_INCLUDED_messages_2fVehicleRemoteHvac_2eproto_2epb_2eh +#define GOOGLE_PROTOBUF_INCLUDED_messages_2fVehicleRemoteHvac_2eproto_2epb_2eh + +#include +#include +#include + +#include "google/protobuf/port_def.inc" +#if PROTOBUF_VERSION < 4022000 +#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 4022000 < 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_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/generated_enum_reflection.h" +#include "google/protobuf/unknown_field_set.h" +#include "google/protobuf/timestamp.pb.h" +// @@protoc_insertion_point(includes) + +// Must be included last. +#include "google/protobuf/port_def.inc" + +#define PROTOBUF_INTERNAL_EXPORT_messages_2fVehicleRemoteHvac_2eproto + +PROTOBUF_NAMESPACE_OPEN +namespace internal { +class AnyMetadata; +} // namespace internal +PROTOBUF_NAMESPACE_CLOSE + +// Internal implementation detail -- do not use these members. +struct TableStruct_messages_2fVehicleRemoteHvac_2eproto { + static const ::uint32_t offsets[]; +}; +extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable + descriptor_table_messages_2fVehicleRemoteHvac_2eproto; +namespace messages { +class CabinConditionStatusPublish; +struct CabinConditionStatusPublishDefaultTypeInternal; +extern CabinConditionStatusPublishDefaultTypeInternal _CabinConditionStatusPublish_default_instance_; +class CabinTemperature; +struct CabinTemperatureDefaultTypeInternal; +extern CabinTemperatureDefaultTypeInternal _CabinTemperature_default_instance_; +class HVACState; +struct HVACStateDefaultTypeInternal; +extern HVACStateDefaultTypeInternal _HVACState_default_instance_; +class HVACZone; +struct HVACZoneDefaultTypeInternal; +extern HVACZoneDefaultTypeInternal _HVACZone_default_instance_; +class PreconditionRequest; +struct PreconditionRequestDefaultTypeInternal; +extern PreconditionRequestDefaultTypeInternal _PreconditionRequest_default_instance_; +class PreconditionResponse; +struct PreconditionResponseDefaultTypeInternal; +extern PreconditionResponseDefaultTypeInternal _PreconditionResponse_default_instance_; +class Temperature; +struct TemperatureDefaultTypeInternal; +extern TemperatureDefaultTypeInternal _Temperature_default_instance_; +} // namespace messages +PROTOBUF_NAMESPACE_OPEN +template <> +::messages::CabinConditionStatusPublish* Arena::CreateMaybeMessage<::messages::CabinConditionStatusPublish>(Arena*); +template <> +::messages::CabinTemperature* Arena::CreateMaybeMessage<::messages::CabinTemperature>(Arena*); +template <> +::messages::HVACState* Arena::CreateMaybeMessage<::messages::HVACState>(Arena*); +template <> +::messages::HVACZone* Arena::CreateMaybeMessage<::messages::HVACZone>(Arena*); +template <> +::messages::PreconditionRequest* Arena::CreateMaybeMessage<::messages::PreconditionRequest>(Arena*); +template <> +::messages::PreconditionResponse* Arena::CreateMaybeMessage<::messages::PreconditionResponse>(Arena*); +template <> +::messages::Temperature* Arena::CreateMaybeMessage<::messages::Temperature>(Arena*); +PROTOBUF_NAMESPACE_CLOSE + +namespace messages { +enum PreconditionResponse_Status : int { + PreconditionResponse_Status_SUCCESS = 0, + PreconditionResponse_Status_FAILURE = 1, + PreconditionResponse_Status_PENDING = 2, + PreconditionResponse_Status_PreconditionResponse_Status_INT_MIN_SENTINEL_DO_NOT_USE_ = + std::numeric_limits<::int32_t>::min(), + PreconditionResponse_Status_PreconditionResponse_Status_INT_MAX_SENTINEL_DO_NOT_USE_ = + std::numeric_limits<::int32_t>::max(), +}; + +bool PreconditionResponse_Status_IsValid(int value); +constexpr PreconditionResponse_Status PreconditionResponse_Status_Status_MIN = static_cast(0); +constexpr PreconditionResponse_Status PreconditionResponse_Status_Status_MAX = static_cast(2); +constexpr int PreconditionResponse_Status_Status_ARRAYSIZE = 2 + 1; +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* +PreconditionResponse_Status_descriptor(); +template +const std::string& PreconditionResponse_Status_Name(T value) { + static_assert(std::is_same::value || + std::is_integral::value, + "Incorrect type passed to Status_Name()."); + return PreconditionResponse_Status_Name(static_cast(value)); +} +template <> +inline const std::string& PreconditionResponse_Status_Name(PreconditionResponse_Status value) { + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfDenseEnum( + static_cast(value)); +} +inline bool PreconditionResponse_Status_Parse(absl::string_view name, PreconditionResponse_Status* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + PreconditionResponse_Status_descriptor(), name, value); +} +enum HVACZone_Zone : int { + HVACZone_Zone_DRIVER = 0, + HVACZone_Zone_PASSENGER = 1, + HVACZone_Zone_REAR_LEFT = 2, + HVACZone_Zone_REAR_RIGHT = 3, + HVACZone_Zone_HVACZone_Zone_INT_MIN_SENTINEL_DO_NOT_USE_ = + std::numeric_limits<::int32_t>::min(), + HVACZone_Zone_HVACZone_Zone_INT_MAX_SENTINEL_DO_NOT_USE_ = + std::numeric_limits<::int32_t>::max(), +}; + +bool HVACZone_Zone_IsValid(int value); +constexpr HVACZone_Zone HVACZone_Zone_Zone_MIN = static_cast(0); +constexpr HVACZone_Zone HVACZone_Zone_Zone_MAX = static_cast(3); +constexpr int HVACZone_Zone_Zone_ARRAYSIZE = 3 + 1; +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* +HVACZone_Zone_descriptor(); +template +const std::string& HVACZone_Zone_Name(T value) { + static_assert(std::is_same::value || + std::is_integral::value, + "Incorrect type passed to Zone_Name()."); + return HVACZone_Zone_Name(static_cast(value)); +} +template <> +inline const std::string& HVACZone_Zone_Name(HVACZone_Zone value) { + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfDenseEnum( + static_cast(value)); +} +inline bool HVACZone_Zone_Parse(absl::string_view name, HVACZone_Zone* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + HVACZone_Zone_descriptor(), name, value); +} +enum HVACState_State : int { + HVACState_State_OFF = 0, + HVACState_State_HEATING = 1, + HVACState_State_COOLING = 2, + HVACState_State_IDLE = 3, + HVACState_State_HVACState_State_INT_MIN_SENTINEL_DO_NOT_USE_ = + std::numeric_limits<::int32_t>::min(), + HVACState_State_HVACState_State_INT_MAX_SENTINEL_DO_NOT_USE_ = + std::numeric_limits<::int32_t>::max(), +}; + +bool HVACState_State_IsValid(int value); +constexpr HVACState_State HVACState_State_State_MIN = static_cast(0); +constexpr HVACState_State HVACState_State_State_MAX = static_cast(3); +constexpr int HVACState_State_State_ARRAYSIZE = 3 + 1; +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* +HVACState_State_descriptor(); +template +const std::string& HVACState_State_Name(T value) { + static_assert(std::is_same::value || + std::is_integral::value, + "Incorrect type passed to State_Name()."); + return HVACState_State_Name(static_cast(value)); +} +template <> +inline const std::string& HVACState_State_Name(HVACState_State value) { + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfDenseEnum( + static_cast(value)); +} +inline bool HVACState_State_Parse(absl::string_view name, HVACState_State* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + HVACState_State_descriptor(), name, value); +} + +// =================================================================== + + +// ------------------------------------------------------------------- + +class CabinConditionStatusPublish final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:messages.CabinConditionStatusPublish) */ { + public: + inline CabinConditionStatusPublish() : CabinConditionStatusPublish(nullptr) {} + ~CabinConditionStatusPublish() override; + explicit PROTOBUF_CONSTEXPR CabinConditionStatusPublish(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + CabinConditionStatusPublish(const CabinConditionStatusPublish& from); + CabinConditionStatusPublish(CabinConditionStatusPublish&& from) noexcept + : CabinConditionStatusPublish() { + *this = ::std::move(from); + } + + inline CabinConditionStatusPublish& operator=(const CabinConditionStatusPublish& from) { + CopyFrom(from); + return *this; + } + inline CabinConditionStatusPublish& operator=(CabinConditionStatusPublish&& 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 CabinConditionStatusPublish& default_instance() { + return *internal_default_instance(); + } + static inline const CabinConditionStatusPublish* internal_default_instance() { + return reinterpret_cast( + &_CabinConditionStatusPublish_default_instance_); + } + static constexpr int kIndexInFileMessages = + 0; + + friend void swap(CabinConditionStatusPublish& a, CabinConditionStatusPublish& b) { + a.Swap(&b); + } + inline void Swap(CabinConditionStatusPublish* 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(CabinConditionStatusPublish* other) { + if (other == this) return; + ABSL_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + CabinConditionStatusPublish* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const CabinConditionStatusPublish& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const CabinConditionStatusPublish& from) { + CabinConditionStatusPublish::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); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(CabinConditionStatusPublish* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::absl::string_view FullMessageName() { + return "messages.CabinConditionStatusPublish"; + } + protected: + explicit CabinConditionStatusPublish(::PROTOBUF_NAMESPACE_ID::Arena* arena); + 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 { + kEventTimeFieldNumber = 1, + kHvacStateFieldNumber = 2, + kCabinTemperatureFieldNumber = 3, + }; + // .google.protobuf.Timestamp event_time = 1; + bool has_event_time() const; + private: + bool _internal_has_event_time() const; + + public: + void clear_event_time() ; + const ::PROTOBUF_NAMESPACE_ID::Timestamp& event_time() const; + PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::Timestamp* release_event_time(); + ::PROTOBUF_NAMESPACE_ID::Timestamp* mutable_event_time(); + void set_allocated_event_time(::PROTOBUF_NAMESPACE_ID::Timestamp* event_time); + private: + const ::PROTOBUF_NAMESPACE_ID::Timestamp& _internal_event_time() const; + ::PROTOBUF_NAMESPACE_ID::Timestamp* _internal_mutable_event_time(); + public: + void unsafe_arena_set_allocated_event_time( + ::PROTOBUF_NAMESPACE_ID::Timestamp* event_time); + ::PROTOBUF_NAMESPACE_ID::Timestamp* unsafe_arena_release_event_time(); + // .messages.HVACState hvac_state = 2; + bool has_hvac_state() const; + private: + bool _internal_has_hvac_state() const; + + public: + void clear_hvac_state() ; + const ::messages::HVACState& hvac_state() const; + PROTOBUF_NODISCARD ::messages::HVACState* release_hvac_state(); + ::messages::HVACState* mutable_hvac_state(); + void set_allocated_hvac_state(::messages::HVACState* hvac_state); + private: + const ::messages::HVACState& _internal_hvac_state() const; + ::messages::HVACState* _internal_mutable_hvac_state(); + public: + void unsafe_arena_set_allocated_hvac_state( + ::messages::HVACState* hvac_state); + ::messages::HVACState* unsafe_arena_release_hvac_state(); + // .messages.CabinTemperature cabin_temperature = 3; + bool has_cabin_temperature() const; + private: + bool _internal_has_cabin_temperature() const; + + public: + void clear_cabin_temperature() ; + const ::messages::CabinTemperature& cabin_temperature() const; + PROTOBUF_NODISCARD ::messages::CabinTemperature* release_cabin_temperature(); + ::messages::CabinTemperature* mutable_cabin_temperature(); + void set_allocated_cabin_temperature(::messages::CabinTemperature* cabin_temperature); + private: + const ::messages::CabinTemperature& _internal_cabin_temperature() const; + ::messages::CabinTemperature* _internal_mutable_cabin_temperature(); + public: + void unsafe_arena_set_allocated_cabin_temperature( + ::messages::CabinTemperature* cabin_temperature); + ::messages::CabinTemperature* unsafe_arena_release_cabin_temperature(); + // @@protoc_insertion_point(class_scope:messages.CabinConditionStatusPublish) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::Timestamp* event_time_; + ::messages::HVACState* hvac_state_; + ::messages::CabinTemperature* cabin_temperature_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_messages_2fVehicleRemoteHvac_2eproto; +};// ------------------------------------------------------------------- + +class PreconditionRequest final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:messages.PreconditionRequest) */ { + public: + inline PreconditionRequest() : PreconditionRequest(nullptr) {} + ~PreconditionRequest() override; + explicit PROTOBUF_CONSTEXPR PreconditionRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + PreconditionRequest(const PreconditionRequest& from); + PreconditionRequest(PreconditionRequest&& from) noexcept + : PreconditionRequest() { + *this = ::std::move(from); + } + + inline PreconditionRequest& operator=(const PreconditionRequest& from) { + CopyFrom(from); + return *this; + } + inline PreconditionRequest& operator=(PreconditionRequest&& 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 PreconditionRequest& default_instance() { + return *internal_default_instance(); + } + static inline const PreconditionRequest* internal_default_instance() { + return reinterpret_cast( + &_PreconditionRequest_default_instance_); + } + static constexpr int kIndexInFileMessages = + 1; + + friend void swap(PreconditionRequest& a, PreconditionRequest& b) { + a.Swap(&b); + } + inline void Swap(PreconditionRequest* 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(PreconditionRequest* other) { + if (other == this) return; + ABSL_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + PreconditionRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const PreconditionRequest& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const PreconditionRequest& from) { + PreconditionRequest::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); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(PreconditionRequest* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::absl::string_view FullMessageName() { + return "messages.PreconditionRequest"; + } + protected: + explicit PreconditionRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena); + 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 { + kHvacZonesFieldNumber = 1, + kStartTimeFieldNumber = 2, + }; + // repeated .messages.HVACZone hvac_zones = 1; + int hvac_zones_size() const; + private: + int _internal_hvac_zones_size() const; + + public: + void clear_hvac_zones() ; + ::messages::HVACZone* mutable_hvac_zones(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::messages::HVACZone >* + mutable_hvac_zones(); + private: + const ::messages::HVACZone& _internal_hvac_zones(int index) const; + ::messages::HVACZone* _internal_add_hvac_zones(); + public: + const ::messages::HVACZone& hvac_zones(int index) const; + ::messages::HVACZone* add_hvac_zones(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::messages::HVACZone >& + hvac_zones() const; + // .google.protobuf.Timestamp start_time = 2; + bool has_start_time() const; + private: + bool _internal_has_start_time() const; + + public: + void clear_start_time() ; + const ::PROTOBUF_NAMESPACE_ID::Timestamp& start_time() const; + PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::Timestamp* release_start_time(); + ::PROTOBUF_NAMESPACE_ID::Timestamp* mutable_start_time(); + void set_allocated_start_time(::PROTOBUF_NAMESPACE_ID::Timestamp* start_time); + private: + const ::PROTOBUF_NAMESPACE_ID::Timestamp& _internal_start_time() const; + ::PROTOBUF_NAMESPACE_ID::Timestamp* _internal_mutable_start_time(); + public: + void unsafe_arena_set_allocated_start_time( + ::PROTOBUF_NAMESPACE_ID::Timestamp* start_time); + ::PROTOBUF_NAMESPACE_ID::Timestamp* unsafe_arena_release_start_time(); + // @@protoc_insertion_point(class_scope:messages.PreconditionRequest) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::messages::HVACZone > hvac_zones_; + ::PROTOBUF_NAMESPACE_ID::Timestamp* start_time_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_messages_2fVehicleRemoteHvac_2eproto; +};// ------------------------------------------------------------------- + +class PreconditionResponse final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:messages.PreconditionResponse) */ { + public: + inline PreconditionResponse() : PreconditionResponse(nullptr) {} + ~PreconditionResponse() override; + explicit PROTOBUF_CONSTEXPR PreconditionResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + PreconditionResponse(const PreconditionResponse& from); + PreconditionResponse(PreconditionResponse&& from) noexcept + : PreconditionResponse() { + *this = ::std::move(from); + } + + inline PreconditionResponse& operator=(const PreconditionResponse& from) { + CopyFrom(from); + return *this; + } + inline PreconditionResponse& operator=(PreconditionResponse&& 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 PreconditionResponse& default_instance() { + return *internal_default_instance(); + } + static inline const PreconditionResponse* internal_default_instance() { + return reinterpret_cast( + &_PreconditionResponse_default_instance_); + } + static constexpr int kIndexInFileMessages = + 2; + + friend void swap(PreconditionResponse& a, PreconditionResponse& b) { + a.Swap(&b); + } + inline void Swap(PreconditionResponse* 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(PreconditionResponse* other) { + if (other == this) return; + ABSL_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + PreconditionResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const PreconditionResponse& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const PreconditionResponse& from) { + PreconditionResponse::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); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(PreconditionResponse* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::absl::string_view FullMessageName() { + return "messages.PreconditionResponse"; + } + protected: + explicit PreconditionResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + using Status = PreconditionResponse_Status; + static constexpr Status SUCCESS = PreconditionResponse_Status_SUCCESS; + static constexpr Status FAILURE = PreconditionResponse_Status_FAILURE; + static constexpr Status PENDING = PreconditionResponse_Status_PENDING; + static inline bool Status_IsValid(int value) { + return PreconditionResponse_Status_IsValid(value); + } + static constexpr Status Status_MIN = PreconditionResponse_Status_Status_MIN; + static constexpr Status Status_MAX = PreconditionResponse_Status_Status_MAX; + static constexpr int Status_ARRAYSIZE = PreconditionResponse_Status_Status_ARRAYSIZE; + static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Status_descriptor() { + return PreconditionResponse_Status_descriptor(); + } + template + static inline const std::string& Status_Name(T value) { + return PreconditionResponse_Status_Name(value); + } + static inline bool Status_Parse(absl::string_view name, Status* value) { + return PreconditionResponse_Status_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + enum : int { + kMessageFieldNumber = 2, + kStatusFieldNumber = 1, + }; + // string message = 2; + void clear_message() ; + const std::string& message() const; + + + + + template + void set_message(Arg_&& arg, Args_... args); + std::string* mutable_message(); + PROTOBUF_NODISCARD std::string* release_message(); + void set_allocated_message(std::string* ptr); + + private: + const std::string& _internal_message() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_message( + const std::string& value); + std::string* _internal_mutable_message(); + + public: + // .messages.PreconditionResponse.Status status = 1; + void clear_status() ; + ::messages::PreconditionResponse_Status status() const; + void set_status(::messages::PreconditionResponse_Status value); + + private: + ::messages::PreconditionResponse_Status _internal_status() const; + void _internal_set_status(::messages::PreconditionResponse_Status value); + + public: + // @@protoc_insertion_point(class_scope:messages.PreconditionResponse) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr message_; + int status_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_messages_2fVehicleRemoteHvac_2eproto; +};// ------------------------------------------------------------------- + +class CabinTemperature final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:messages.CabinTemperature) */ { + public: + inline CabinTemperature() : CabinTemperature(nullptr) {} + ~CabinTemperature() override; + explicit PROTOBUF_CONSTEXPR CabinTemperature(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + CabinTemperature(const CabinTemperature& from); + CabinTemperature(CabinTemperature&& from) noexcept + : CabinTemperature() { + *this = ::std::move(from); + } + + inline CabinTemperature& operator=(const CabinTemperature& from) { + CopyFrom(from); + return *this; + } + inline CabinTemperature& operator=(CabinTemperature&& 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 CabinTemperature& default_instance() { + return *internal_default_instance(); + } + static inline const CabinTemperature* internal_default_instance() { + return reinterpret_cast( + &_CabinTemperature_default_instance_); + } + static constexpr int kIndexInFileMessages = + 3; + + friend void swap(CabinTemperature& a, CabinTemperature& b) { + a.Swap(&b); + } + inline void Swap(CabinTemperature* 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(CabinTemperature* other) { + if (other == this) return; + ABSL_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + CabinTemperature* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const CabinTemperature& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const CabinTemperature& from) { + CabinTemperature::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); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(CabinTemperature* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::absl::string_view FullMessageName() { + return "messages.CabinTemperature"; + } + protected: + explicit CabinTemperature(::PROTOBUF_NAMESPACE_ID::Arena* arena); + 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 { + kTemperatureFieldNumber = 1, + kZoneFieldNumber = 2, + }; + // .messages.Temperature temperature = 1; + bool has_temperature() const; + private: + bool _internal_has_temperature() const; + + public: + void clear_temperature() ; + const ::messages::Temperature& temperature() const; + PROTOBUF_NODISCARD ::messages::Temperature* release_temperature(); + ::messages::Temperature* mutable_temperature(); + void set_allocated_temperature(::messages::Temperature* temperature); + private: + const ::messages::Temperature& _internal_temperature() const; + ::messages::Temperature* _internal_mutable_temperature(); + public: + void unsafe_arena_set_allocated_temperature( + ::messages::Temperature* temperature); + ::messages::Temperature* unsafe_arena_release_temperature(); + // .messages.HVACZone zone = 2; + bool has_zone() const; + private: + bool _internal_has_zone() const; + + public: + void clear_zone() ; + const ::messages::HVACZone& zone() const; + PROTOBUF_NODISCARD ::messages::HVACZone* release_zone(); + ::messages::HVACZone* mutable_zone(); + void set_allocated_zone(::messages::HVACZone* zone); + private: + const ::messages::HVACZone& _internal_zone() const; + ::messages::HVACZone* _internal_mutable_zone(); + public: + void unsafe_arena_set_allocated_zone( + ::messages::HVACZone* zone); + ::messages::HVACZone* unsafe_arena_release_zone(); + // @@protoc_insertion_point(class_scope:messages.CabinTemperature) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::messages::Temperature* temperature_; + ::messages::HVACZone* zone_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_messages_2fVehicleRemoteHvac_2eproto; +};// ------------------------------------------------------------------- + +class Temperature final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:messages.Temperature) */ { + public: + inline Temperature() : Temperature(nullptr) {} + ~Temperature() override; + explicit PROTOBUF_CONSTEXPR Temperature(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Temperature(const Temperature& from); + Temperature(Temperature&& from) noexcept + : Temperature() { + *this = ::std::move(from); + } + + inline Temperature& operator=(const Temperature& from) { + CopyFrom(from); + return *this; + } + inline Temperature& operator=(Temperature&& 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 Temperature& default_instance() { + return *internal_default_instance(); + } + static inline const Temperature* internal_default_instance() { + return reinterpret_cast( + &_Temperature_default_instance_); + } + static constexpr int kIndexInFileMessages = + 4; + + friend void swap(Temperature& a, Temperature& b) { + a.Swap(&b); + } + inline void Swap(Temperature* 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(Temperature* other) { + if (other == this) return; + ABSL_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Temperature* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const Temperature& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const Temperature& from) { + Temperature::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); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Temperature* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::absl::string_view FullMessageName() { + return "messages.Temperature"; + } + protected: + explicit Temperature(::PROTOBUF_NAMESPACE_ID::Arena* arena); + 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 { + kUnitFieldNumber = 2, + kValueFieldNumber = 1, + }; + // string unit = 2; + void clear_unit() ; + const std::string& unit() const; + + + + + template + void set_unit(Arg_&& arg, Args_... args); + std::string* mutable_unit(); + PROTOBUF_NODISCARD std::string* release_unit(); + void set_allocated_unit(std::string* ptr); + + private: + const std::string& _internal_unit() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_unit( + const std::string& value); + std::string* _internal_mutable_unit(); + + public: + // float value = 1; + void clear_value() ; + float value() const; + void set_value(float value); + + private: + float _internal_value() const; + void _internal_set_value(float value); + + public: + // @@protoc_insertion_point(class_scope:messages.Temperature) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr unit_; + float value_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_messages_2fVehicleRemoteHvac_2eproto; +};// ------------------------------------------------------------------- + +class HVACZone final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:messages.HVACZone) */ { + public: + inline HVACZone() : HVACZone(nullptr) {} + ~HVACZone() override; + explicit PROTOBUF_CONSTEXPR HVACZone(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + HVACZone(const HVACZone& from); + HVACZone(HVACZone&& from) noexcept + : HVACZone() { + *this = ::std::move(from); + } + + inline HVACZone& operator=(const HVACZone& from) { + CopyFrom(from); + return *this; + } + inline HVACZone& operator=(HVACZone&& 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 HVACZone& default_instance() { + return *internal_default_instance(); + } + static inline const HVACZone* internal_default_instance() { + return reinterpret_cast( + &_HVACZone_default_instance_); + } + static constexpr int kIndexInFileMessages = + 5; + + friend void swap(HVACZone& a, HVACZone& b) { + a.Swap(&b); + } + inline void Swap(HVACZone* 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(HVACZone* other) { + if (other == this) return; + ABSL_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + HVACZone* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const HVACZone& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const HVACZone& from) { + HVACZone::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); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(HVACZone* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::absl::string_view FullMessageName() { + return "messages.HVACZone"; + } + protected: + explicit HVACZone(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + using Zone = HVACZone_Zone; + static constexpr Zone DRIVER = HVACZone_Zone_DRIVER; + static constexpr Zone PASSENGER = HVACZone_Zone_PASSENGER; + static constexpr Zone REAR_LEFT = HVACZone_Zone_REAR_LEFT; + static constexpr Zone REAR_RIGHT = HVACZone_Zone_REAR_RIGHT; + static inline bool Zone_IsValid(int value) { + return HVACZone_Zone_IsValid(value); + } + static constexpr Zone Zone_MIN = HVACZone_Zone_Zone_MIN; + static constexpr Zone Zone_MAX = HVACZone_Zone_Zone_MAX; + static constexpr int Zone_ARRAYSIZE = HVACZone_Zone_Zone_ARRAYSIZE; + static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Zone_descriptor() { + return HVACZone_Zone_descriptor(); + } + template + static inline const std::string& Zone_Name(T value) { + return HVACZone_Zone_Name(value); + } + static inline bool Zone_Parse(absl::string_view name, Zone* value) { + return HVACZone_Zone_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + enum : int { + kTargetTemperatureFieldNumber = 2, + kZoneFieldNumber = 1, + }; + // .messages.Temperature target_temperature = 2; + bool has_target_temperature() const; + private: + bool _internal_has_target_temperature() const; + + public: + void clear_target_temperature() ; + const ::messages::Temperature& target_temperature() const; + PROTOBUF_NODISCARD ::messages::Temperature* release_target_temperature(); + ::messages::Temperature* mutable_target_temperature(); + void set_allocated_target_temperature(::messages::Temperature* target_temperature); + private: + const ::messages::Temperature& _internal_target_temperature() const; + ::messages::Temperature* _internal_mutable_target_temperature(); + public: + void unsafe_arena_set_allocated_target_temperature( + ::messages::Temperature* target_temperature); + ::messages::Temperature* unsafe_arena_release_target_temperature(); + // .messages.HVACZone.Zone zone = 1; + void clear_zone() ; + ::messages::HVACZone_Zone zone() const; + void set_zone(::messages::HVACZone_Zone value); + + private: + ::messages::HVACZone_Zone _internal_zone() const; + void _internal_set_zone(::messages::HVACZone_Zone value); + + public: + // @@protoc_insertion_point(class_scope:messages.HVACZone) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::messages::Temperature* target_temperature_; + int zone_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_messages_2fVehicleRemoteHvac_2eproto; +};// ------------------------------------------------------------------- + +class HVACState final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:messages.HVACState) */ { + public: + inline HVACState() : HVACState(nullptr) {} + ~HVACState() override; + explicit PROTOBUF_CONSTEXPR HVACState(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + HVACState(const HVACState& from); + HVACState(HVACState&& from) noexcept + : HVACState() { + *this = ::std::move(from); + } + + inline HVACState& operator=(const HVACState& from) { + CopyFrom(from); + return *this; + } + inline HVACState& operator=(HVACState&& 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 HVACState& default_instance() { + return *internal_default_instance(); + } + static inline const HVACState* internal_default_instance() { + return reinterpret_cast( + &_HVACState_default_instance_); + } + static constexpr int kIndexInFileMessages = + 6; + + friend void swap(HVACState& a, HVACState& b) { + a.Swap(&b); + } + inline void Swap(HVACState* 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(HVACState* other) { + if (other == this) return; + ABSL_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + HVACState* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const HVACState& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const HVACState& from) { + HVACState::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); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(HVACState* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::absl::string_view FullMessageName() { + return "messages.HVACState"; + } + protected: + explicit HVACState(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + using State = HVACState_State; + static constexpr State OFF = HVACState_State_OFF; + static constexpr State HEATING = HVACState_State_HEATING; + static constexpr State COOLING = HVACState_State_COOLING; + static constexpr State IDLE = HVACState_State_IDLE; + static inline bool State_IsValid(int value) { + return HVACState_State_IsValid(value); + } + static constexpr State State_MIN = HVACState_State_State_MIN; + static constexpr State State_MAX = HVACState_State_State_MAX; + static constexpr int State_ARRAYSIZE = HVACState_State_State_ARRAYSIZE; + static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* State_descriptor() { + return HVACState_State_descriptor(); + } + template + static inline const std::string& State_Name(T value) { + return HVACState_State_Name(value); + } + static inline bool State_Parse(absl::string_view name, State* value) { + return HVACState_State_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + enum : int { + kCurrentZoneFieldNumber = 2, + kStateFieldNumber = 1, + }; + // .messages.HVACZone current_zone = 2; + bool has_current_zone() const; + private: + bool _internal_has_current_zone() const; + + public: + void clear_current_zone() ; + const ::messages::HVACZone& current_zone() const; + PROTOBUF_NODISCARD ::messages::HVACZone* release_current_zone(); + ::messages::HVACZone* mutable_current_zone(); + void set_allocated_current_zone(::messages::HVACZone* current_zone); + private: + const ::messages::HVACZone& _internal_current_zone() const; + ::messages::HVACZone* _internal_mutable_current_zone(); + public: + void unsafe_arena_set_allocated_current_zone( + ::messages::HVACZone* current_zone); + ::messages::HVACZone* unsafe_arena_release_current_zone(); + // .messages.HVACState.State state = 1; + void clear_state() ; + ::messages::HVACState_State state() const; + void set_state(::messages::HVACState_State value); + + private: + ::messages::HVACState_State _internal_state() const; + void _internal_set_state(::messages::HVACState_State value); + + public: + // @@protoc_insertion_point(class_scope:messages.HVACState) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::messages::HVACZone* current_zone_; + int state_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_messages_2fVehicleRemoteHvac_2eproto; +}; + +// =================================================================== + + + + +// =================================================================== + + +#ifdef __GNUC__ +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wstrict-aliasing" +#endif // __GNUC__ +// ------------------------------------------------------------------- + +// CabinConditionStatusPublish + +// .google.protobuf.Timestamp event_time = 1; +inline bool CabinConditionStatusPublish::_internal_has_event_time() const { + return this != internal_default_instance() && _impl_.event_time_ != nullptr; +} +inline bool CabinConditionStatusPublish::has_event_time() const { + return _internal_has_event_time(); +} +inline const ::PROTOBUF_NAMESPACE_ID::Timestamp& CabinConditionStatusPublish::_internal_event_time() const { + const ::PROTOBUF_NAMESPACE_ID::Timestamp* p = _impl_.event_time_; + return p != nullptr ? *p : reinterpret_cast( + ::PROTOBUF_NAMESPACE_ID::_Timestamp_default_instance_); +} +inline const ::PROTOBUF_NAMESPACE_ID::Timestamp& CabinConditionStatusPublish::event_time() const { + // @@protoc_insertion_point(field_get:messages.CabinConditionStatusPublish.event_time) + return _internal_event_time(); +} +inline void CabinConditionStatusPublish::unsafe_arena_set_allocated_event_time( + ::PROTOBUF_NAMESPACE_ID::Timestamp* event_time) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.event_time_); + } + _impl_.event_time_ = event_time; + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:messages.CabinConditionStatusPublish.event_time) +} +inline ::PROTOBUF_NAMESPACE_ID::Timestamp* CabinConditionStatusPublish::release_event_time() { + + ::PROTOBUF_NAMESPACE_ID::Timestamp* temp = _impl_.event_time_; + _impl_.event_time_ = 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 ::PROTOBUF_NAMESPACE_ID::Timestamp* CabinConditionStatusPublish::unsafe_arena_release_event_time() { + // @@protoc_insertion_point(field_release:messages.CabinConditionStatusPublish.event_time) + + ::PROTOBUF_NAMESPACE_ID::Timestamp* temp = _impl_.event_time_; + _impl_.event_time_ = nullptr; + return temp; +} +inline ::PROTOBUF_NAMESPACE_ID::Timestamp* CabinConditionStatusPublish::_internal_mutable_event_time() { + + if (_impl_.event_time_ == nullptr) { + auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Timestamp>(GetArenaForAllocation()); + _impl_.event_time_ = p; + } + return _impl_.event_time_; +} +inline ::PROTOBUF_NAMESPACE_ID::Timestamp* CabinConditionStatusPublish::mutable_event_time() { + ::PROTOBUF_NAMESPACE_ID::Timestamp* _msg = _internal_mutable_event_time(); + // @@protoc_insertion_point(field_mutable:messages.CabinConditionStatusPublish.event_time) + return _msg; +} +inline void CabinConditionStatusPublish::set_allocated_event_time(::PROTOBUF_NAMESPACE_ID::Timestamp* event_time) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.event_time_); + } + if (event_time) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena( + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(event_time)); + if (message_arena != submessage_arena) { + event_time = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, event_time, submessage_arena); + } + + } else { + + } + _impl_.event_time_ = event_time; + // @@protoc_insertion_point(field_set_allocated:messages.CabinConditionStatusPublish.event_time) +} + +// .messages.HVACState hvac_state = 2; +inline bool CabinConditionStatusPublish::_internal_has_hvac_state() const { + return this != internal_default_instance() && _impl_.hvac_state_ != nullptr; +} +inline bool CabinConditionStatusPublish::has_hvac_state() const { + return _internal_has_hvac_state(); +} +inline void CabinConditionStatusPublish::clear_hvac_state() { + if (GetArenaForAllocation() == nullptr && _impl_.hvac_state_ != nullptr) { + delete _impl_.hvac_state_; + } + _impl_.hvac_state_ = nullptr; +} +inline const ::messages::HVACState& CabinConditionStatusPublish::_internal_hvac_state() const { + const ::messages::HVACState* p = _impl_.hvac_state_; + return p != nullptr ? *p : reinterpret_cast( + ::messages::_HVACState_default_instance_); +} +inline const ::messages::HVACState& CabinConditionStatusPublish::hvac_state() const { + // @@protoc_insertion_point(field_get:messages.CabinConditionStatusPublish.hvac_state) + return _internal_hvac_state(); +} +inline void CabinConditionStatusPublish::unsafe_arena_set_allocated_hvac_state( + ::messages::HVACState* hvac_state) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.hvac_state_); + } + _impl_.hvac_state_ = hvac_state; + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:messages.CabinConditionStatusPublish.hvac_state) +} +inline ::messages::HVACState* CabinConditionStatusPublish::release_hvac_state() { + + ::messages::HVACState* temp = _impl_.hvac_state_; + _impl_.hvac_state_ = 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::HVACState* CabinConditionStatusPublish::unsafe_arena_release_hvac_state() { + // @@protoc_insertion_point(field_release:messages.CabinConditionStatusPublish.hvac_state) + + ::messages::HVACState* temp = _impl_.hvac_state_; + _impl_.hvac_state_ = nullptr; + return temp; +} +inline ::messages::HVACState* CabinConditionStatusPublish::_internal_mutable_hvac_state() { + + if (_impl_.hvac_state_ == nullptr) { + auto* p = CreateMaybeMessage<::messages::HVACState>(GetArenaForAllocation()); + _impl_.hvac_state_ = p; + } + return _impl_.hvac_state_; +} +inline ::messages::HVACState* CabinConditionStatusPublish::mutable_hvac_state() { + ::messages::HVACState* _msg = _internal_mutable_hvac_state(); + // @@protoc_insertion_point(field_mutable:messages.CabinConditionStatusPublish.hvac_state) + return _msg; +} +inline void CabinConditionStatusPublish::set_allocated_hvac_state(::messages::HVACState* hvac_state) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.hvac_state_; + } + if (hvac_state) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(hvac_state); + if (message_arena != submessage_arena) { + hvac_state = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, hvac_state, submessage_arena); + } + + } else { + + } + _impl_.hvac_state_ = hvac_state; + // @@protoc_insertion_point(field_set_allocated:messages.CabinConditionStatusPublish.hvac_state) +} + +// .messages.CabinTemperature cabin_temperature = 3; +inline bool CabinConditionStatusPublish::_internal_has_cabin_temperature() const { + return this != internal_default_instance() && _impl_.cabin_temperature_ != nullptr; +} +inline bool CabinConditionStatusPublish::has_cabin_temperature() const { + return _internal_has_cabin_temperature(); +} +inline void CabinConditionStatusPublish::clear_cabin_temperature() { + if (GetArenaForAllocation() == nullptr && _impl_.cabin_temperature_ != nullptr) { + delete _impl_.cabin_temperature_; + } + _impl_.cabin_temperature_ = nullptr; +} +inline const ::messages::CabinTemperature& CabinConditionStatusPublish::_internal_cabin_temperature() const { + const ::messages::CabinTemperature* p = _impl_.cabin_temperature_; + return p != nullptr ? *p : reinterpret_cast( + ::messages::_CabinTemperature_default_instance_); +} +inline const ::messages::CabinTemperature& CabinConditionStatusPublish::cabin_temperature() const { + // @@protoc_insertion_point(field_get:messages.CabinConditionStatusPublish.cabin_temperature) + return _internal_cabin_temperature(); +} +inline void CabinConditionStatusPublish::unsafe_arena_set_allocated_cabin_temperature( + ::messages::CabinTemperature* cabin_temperature) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.cabin_temperature_); + } + _impl_.cabin_temperature_ = cabin_temperature; + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:messages.CabinConditionStatusPublish.cabin_temperature) +} +inline ::messages::CabinTemperature* CabinConditionStatusPublish::release_cabin_temperature() { + + ::messages::CabinTemperature* temp = _impl_.cabin_temperature_; + _impl_.cabin_temperature_ = 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::CabinTemperature* CabinConditionStatusPublish::unsafe_arena_release_cabin_temperature() { + // @@protoc_insertion_point(field_release:messages.CabinConditionStatusPublish.cabin_temperature) + + ::messages::CabinTemperature* temp = _impl_.cabin_temperature_; + _impl_.cabin_temperature_ = nullptr; + return temp; +} +inline ::messages::CabinTemperature* CabinConditionStatusPublish::_internal_mutable_cabin_temperature() { + + if (_impl_.cabin_temperature_ == nullptr) { + auto* p = CreateMaybeMessage<::messages::CabinTemperature>(GetArenaForAllocation()); + _impl_.cabin_temperature_ = p; + } + return _impl_.cabin_temperature_; +} +inline ::messages::CabinTemperature* CabinConditionStatusPublish::mutable_cabin_temperature() { + ::messages::CabinTemperature* _msg = _internal_mutable_cabin_temperature(); + // @@protoc_insertion_point(field_mutable:messages.CabinConditionStatusPublish.cabin_temperature) + return _msg; +} +inline void CabinConditionStatusPublish::set_allocated_cabin_temperature(::messages::CabinTemperature* cabin_temperature) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.cabin_temperature_; + } + if (cabin_temperature) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(cabin_temperature); + if (message_arena != submessage_arena) { + cabin_temperature = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, cabin_temperature, submessage_arena); + } + + } else { + + } + _impl_.cabin_temperature_ = cabin_temperature; + // @@protoc_insertion_point(field_set_allocated:messages.CabinConditionStatusPublish.cabin_temperature) +} + +// ------------------------------------------------------------------- + +// PreconditionRequest + +// repeated .messages.HVACZone hvac_zones = 1; +inline int PreconditionRequest::_internal_hvac_zones_size() const { + return _impl_.hvac_zones_.size(); +} +inline int PreconditionRequest::hvac_zones_size() const { + return _internal_hvac_zones_size(); +} +inline void PreconditionRequest::clear_hvac_zones() { + _impl_.hvac_zones_.Clear(); +} +inline ::messages::HVACZone* PreconditionRequest::mutable_hvac_zones(int index) { + // @@protoc_insertion_point(field_mutable:messages.PreconditionRequest.hvac_zones) + return _impl_.hvac_zones_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::messages::HVACZone >* +PreconditionRequest::mutable_hvac_zones() { + // @@protoc_insertion_point(field_mutable_list:messages.PreconditionRequest.hvac_zones) + return &_impl_.hvac_zones_; +} +inline const ::messages::HVACZone& PreconditionRequest::_internal_hvac_zones(int index) const { + return _impl_.hvac_zones_.Get(index); +} +inline const ::messages::HVACZone& PreconditionRequest::hvac_zones(int index) const { + // @@protoc_insertion_point(field_get:messages.PreconditionRequest.hvac_zones) + return _internal_hvac_zones(index); +} +inline ::messages::HVACZone* PreconditionRequest::_internal_add_hvac_zones() { + return _impl_.hvac_zones_.Add(); +} +inline ::messages::HVACZone* PreconditionRequest::add_hvac_zones() { + ::messages::HVACZone* _add = _internal_add_hvac_zones(); + // @@protoc_insertion_point(field_add:messages.PreconditionRequest.hvac_zones) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::messages::HVACZone >& +PreconditionRequest::hvac_zones() const { + // @@protoc_insertion_point(field_list:messages.PreconditionRequest.hvac_zones) + return _impl_.hvac_zones_; +} + +// .google.protobuf.Timestamp start_time = 2; +inline bool PreconditionRequest::_internal_has_start_time() const { + return this != internal_default_instance() && _impl_.start_time_ != nullptr; +} +inline bool PreconditionRequest::has_start_time() const { + return _internal_has_start_time(); +} +inline const ::PROTOBUF_NAMESPACE_ID::Timestamp& PreconditionRequest::_internal_start_time() const { + const ::PROTOBUF_NAMESPACE_ID::Timestamp* p = _impl_.start_time_; + return p != nullptr ? *p : reinterpret_cast( + ::PROTOBUF_NAMESPACE_ID::_Timestamp_default_instance_); +} +inline const ::PROTOBUF_NAMESPACE_ID::Timestamp& PreconditionRequest::start_time() const { + // @@protoc_insertion_point(field_get:messages.PreconditionRequest.start_time) + return _internal_start_time(); +} +inline void PreconditionRequest::unsafe_arena_set_allocated_start_time( + ::PROTOBUF_NAMESPACE_ID::Timestamp* start_time) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.start_time_); + } + _impl_.start_time_ = start_time; + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:messages.PreconditionRequest.start_time) +} +inline ::PROTOBUF_NAMESPACE_ID::Timestamp* PreconditionRequest::release_start_time() { + + ::PROTOBUF_NAMESPACE_ID::Timestamp* temp = _impl_.start_time_; + _impl_.start_time_ = 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 ::PROTOBUF_NAMESPACE_ID::Timestamp* PreconditionRequest::unsafe_arena_release_start_time() { + // @@protoc_insertion_point(field_release:messages.PreconditionRequest.start_time) + + ::PROTOBUF_NAMESPACE_ID::Timestamp* temp = _impl_.start_time_; + _impl_.start_time_ = nullptr; + return temp; +} +inline ::PROTOBUF_NAMESPACE_ID::Timestamp* PreconditionRequest::_internal_mutable_start_time() { + + if (_impl_.start_time_ == nullptr) { + auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Timestamp>(GetArenaForAllocation()); + _impl_.start_time_ = p; + } + return _impl_.start_time_; +} +inline ::PROTOBUF_NAMESPACE_ID::Timestamp* PreconditionRequest::mutable_start_time() { + ::PROTOBUF_NAMESPACE_ID::Timestamp* _msg = _internal_mutable_start_time(); + // @@protoc_insertion_point(field_mutable:messages.PreconditionRequest.start_time) + return _msg; +} +inline void PreconditionRequest::set_allocated_start_time(::PROTOBUF_NAMESPACE_ID::Timestamp* start_time) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.start_time_); + } + if (start_time) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena( + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(start_time)); + if (message_arena != submessage_arena) { + start_time = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, start_time, submessage_arena); + } + + } else { + + } + _impl_.start_time_ = start_time; + // @@protoc_insertion_point(field_set_allocated:messages.PreconditionRequest.start_time) +} + +// ------------------------------------------------------------------- + +// PreconditionResponse + +// .messages.PreconditionResponse.Status status = 1; +inline void PreconditionResponse::clear_status() { + _impl_.status_ = 0; +} +inline ::messages::PreconditionResponse_Status PreconditionResponse::status() const { + // @@protoc_insertion_point(field_get:messages.PreconditionResponse.status) + return _internal_status(); +} +inline void PreconditionResponse::set_status(::messages::PreconditionResponse_Status value) { + _internal_set_status(value); + // @@protoc_insertion_point(field_set:messages.PreconditionResponse.status) +} +inline ::messages::PreconditionResponse_Status PreconditionResponse::_internal_status() const { + return static_cast<::messages::PreconditionResponse_Status>(_impl_.status_); +} +inline void PreconditionResponse::_internal_set_status(::messages::PreconditionResponse_Status value) { + ; + _impl_.status_ = value; +} + +// string message = 2; +inline void PreconditionResponse::clear_message() { + _impl_.message_.ClearToEmpty(); +} +inline const std::string& PreconditionResponse::message() const { + // @@protoc_insertion_point(field_get:messages.PreconditionResponse.message) + return _internal_message(); +} +template +inline PROTOBUF_ALWAYS_INLINE void PreconditionResponse::set_message(Arg_&& arg, + Args_... args) { + ; + _impl_.message_.Set(static_cast(arg), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:messages.PreconditionResponse.message) +} +inline std::string* PreconditionResponse::mutable_message() { + std::string* _s = _internal_mutable_message(); + // @@protoc_insertion_point(field_mutable:messages.PreconditionResponse.message) + return _s; +} +inline const std::string& PreconditionResponse::_internal_message() const { + return _impl_.message_.Get(); +} +inline void PreconditionResponse::_internal_set_message(const std::string& value) { + ; + + + _impl_.message_.Set(value, GetArenaForAllocation()); +} +inline std::string* PreconditionResponse::_internal_mutable_message() { + ; + return _impl_.message_.Mutable( GetArenaForAllocation()); +} +inline std::string* PreconditionResponse::release_message() { + // @@protoc_insertion_point(field_release:messages.PreconditionResponse.message) + return _impl_.message_.Release(); +} +inline void PreconditionResponse::set_allocated_message(std::string* value) { + _impl_.message_.SetAllocated(value, GetArenaForAllocation()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.message_.IsDefault()) { + _impl_.message_.Set("", GetArenaForAllocation()); + } + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:messages.PreconditionResponse.message) +} + +// ------------------------------------------------------------------- + +// CabinTemperature + +// .messages.Temperature temperature = 1; +inline bool CabinTemperature::_internal_has_temperature() const { + return this != internal_default_instance() && _impl_.temperature_ != nullptr; +} +inline bool CabinTemperature::has_temperature() const { + return _internal_has_temperature(); +} +inline void CabinTemperature::clear_temperature() { + if (GetArenaForAllocation() == nullptr && _impl_.temperature_ != nullptr) { + delete _impl_.temperature_; + } + _impl_.temperature_ = nullptr; +} +inline const ::messages::Temperature& CabinTemperature::_internal_temperature() const { + const ::messages::Temperature* p = _impl_.temperature_; + return p != nullptr ? *p : reinterpret_cast( + ::messages::_Temperature_default_instance_); +} +inline const ::messages::Temperature& CabinTemperature::temperature() const { + // @@protoc_insertion_point(field_get:messages.CabinTemperature.temperature) + return _internal_temperature(); +} +inline void CabinTemperature::unsafe_arena_set_allocated_temperature( + ::messages::Temperature* temperature) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.temperature_); + } + _impl_.temperature_ = temperature; + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:messages.CabinTemperature.temperature) +} +inline ::messages::Temperature* CabinTemperature::release_temperature() { + + ::messages::Temperature* temp = _impl_.temperature_; + _impl_.temperature_ = 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::Temperature* CabinTemperature::unsafe_arena_release_temperature() { + // @@protoc_insertion_point(field_release:messages.CabinTemperature.temperature) + + ::messages::Temperature* temp = _impl_.temperature_; + _impl_.temperature_ = nullptr; + return temp; +} +inline ::messages::Temperature* CabinTemperature::_internal_mutable_temperature() { + + if (_impl_.temperature_ == nullptr) { + auto* p = CreateMaybeMessage<::messages::Temperature>(GetArenaForAllocation()); + _impl_.temperature_ = p; + } + return _impl_.temperature_; +} +inline ::messages::Temperature* CabinTemperature::mutable_temperature() { + ::messages::Temperature* _msg = _internal_mutable_temperature(); + // @@protoc_insertion_point(field_mutable:messages.CabinTemperature.temperature) + return _msg; +} +inline void CabinTemperature::set_allocated_temperature(::messages::Temperature* temperature) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.temperature_; + } + if (temperature) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(temperature); + if (message_arena != submessage_arena) { + temperature = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, temperature, submessage_arena); + } + + } else { + + } + _impl_.temperature_ = temperature; + // @@protoc_insertion_point(field_set_allocated:messages.CabinTemperature.temperature) +} + +// .messages.HVACZone zone = 2; +inline bool CabinTemperature::_internal_has_zone() const { + return this != internal_default_instance() && _impl_.zone_ != nullptr; +} +inline bool CabinTemperature::has_zone() const { + return _internal_has_zone(); +} +inline void CabinTemperature::clear_zone() { + if (GetArenaForAllocation() == nullptr && _impl_.zone_ != nullptr) { + delete _impl_.zone_; + } + _impl_.zone_ = nullptr; +} +inline const ::messages::HVACZone& CabinTemperature::_internal_zone() const { + const ::messages::HVACZone* p = _impl_.zone_; + return p != nullptr ? *p : reinterpret_cast( + ::messages::_HVACZone_default_instance_); +} +inline const ::messages::HVACZone& CabinTemperature::zone() const { + // @@protoc_insertion_point(field_get:messages.CabinTemperature.zone) + return _internal_zone(); +} +inline void CabinTemperature::unsafe_arena_set_allocated_zone( + ::messages::HVACZone* zone) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.zone_); + } + _impl_.zone_ = zone; + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:messages.CabinTemperature.zone) +} +inline ::messages::HVACZone* CabinTemperature::release_zone() { + + ::messages::HVACZone* temp = _impl_.zone_; + _impl_.zone_ = 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::HVACZone* CabinTemperature::unsafe_arena_release_zone() { + // @@protoc_insertion_point(field_release:messages.CabinTemperature.zone) + + ::messages::HVACZone* temp = _impl_.zone_; + _impl_.zone_ = nullptr; + return temp; +} +inline ::messages::HVACZone* CabinTemperature::_internal_mutable_zone() { + + if (_impl_.zone_ == nullptr) { + auto* p = CreateMaybeMessage<::messages::HVACZone>(GetArenaForAllocation()); + _impl_.zone_ = p; + } + return _impl_.zone_; +} +inline ::messages::HVACZone* CabinTemperature::mutable_zone() { + ::messages::HVACZone* _msg = _internal_mutable_zone(); + // @@protoc_insertion_point(field_mutable:messages.CabinTemperature.zone) + return _msg; +} +inline void CabinTemperature::set_allocated_zone(::messages::HVACZone* zone) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.zone_; + } + if (zone) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(zone); + if (message_arena != submessage_arena) { + zone = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, zone, submessage_arena); + } + + } else { + + } + _impl_.zone_ = zone; + // @@protoc_insertion_point(field_set_allocated:messages.CabinTemperature.zone) +} + +// ------------------------------------------------------------------- + +// Temperature + +// float value = 1; +inline void Temperature::clear_value() { + _impl_.value_ = 0; +} +inline float Temperature::value() const { + // @@protoc_insertion_point(field_get:messages.Temperature.value) + return _internal_value(); +} +inline void Temperature::set_value(float value) { + _internal_set_value(value); + // @@protoc_insertion_point(field_set:messages.Temperature.value) +} +inline float Temperature::_internal_value() const { + return _impl_.value_; +} +inline void Temperature::_internal_set_value(float value) { + ; + _impl_.value_ = value; +} + +// string unit = 2; +inline void Temperature::clear_unit() { + _impl_.unit_.ClearToEmpty(); +} +inline const std::string& Temperature::unit() const { + // @@protoc_insertion_point(field_get:messages.Temperature.unit) + return _internal_unit(); +} +template +inline PROTOBUF_ALWAYS_INLINE void Temperature::set_unit(Arg_&& arg, + Args_... args) { + ; + _impl_.unit_.Set(static_cast(arg), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:messages.Temperature.unit) +} +inline std::string* Temperature::mutable_unit() { + std::string* _s = _internal_mutable_unit(); + // @@protoc_insertion_point(field_mutable:messages.Temperature.unit) + return _s; +} +inline const std::string& Temperature::_internal_unit() const { + return _impl_.unit_.Get(); +} +inline void Temperature::_internal_set_unit(const std::string& value) { + ; + + + _impl_.unit_.Set(value, GetArenaForAllocation()); +} +inline std::string* Temperature::_internal_mutable_unit() { + ; + return _impl_.unit_.Mutable( GetArenaForAllocation()); +} +inline std::string* Temperature::release_unit() { + // @@protoc_insertion_point(field_release:messages.Temperature.unit) + return _impl_.unit_.Release(); +} +inline void Temperature::set_allocated_unit(std::string* value) { + _impl_.unit_.SetAllocated(value, GetArenaForAllocation()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.unit_.IsDefault()) { + _impl_.unit_.Set("", GetArenaForAllocation()); + } + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:messages.Temperature.unit) +} + +// ------------------------------------------------------------------- + +// HVACZone + +// .messages.HVACZone.Zone zone = 1; +inline void HVACZone::clear_zone() { + _impl_.zone_ = 0; +} +inline ::messages::HVACZone_Zone HVACZone::zone() const { + // @@protoc_insertion_point(field_get:messages.HVACZone.zone) + return _internal_zone(); +} +inline void HVACZone::set_zone(::messages::HVACZone_Zone value) { + _internal_set_zone(value); + // @@protoc_insertion_point(field_set:messages.HVACZone.zone) +} +inline ::messages::HVACZone_Zone HVACZone::_internal_zone() const { + return static_cast<::messages::HVACZone_Zone>(_impl_.zone_); +} +inline void HVACZone::_internal_set_zone(::messages::HVACZone_Zone value) { + ; + _impl_.zone_ = value; +} + +// .messages.Temperature target_temperature = 2; +inline bool HVACZone::_internal_has_target_temperature() const { + return this != internal_default_instance() && _impl_.target_temperature_ != nullptr; +} +inline bool HVACZone::has_target_temperature() const { + return _internal_has_target_temperature(); +} +inline void HVACZone::clear_target_temperature() { + if (GetArenaForAllocation() == nullptr && _impl_.target_temperature_ != nullptr) { + delete _impl_.target_temperature_; + } + _impl_.target_temperature_ = nullptr; +} +inline const ::messages::Temperature& HVACZone::_internal_target_temperature() const { + const ::messages::Temperature* p = _impl_.target_temperature_; + return p != nullptr ? *p : reinterpret_cast( + ::messages::_Temperature_default_instance_); +} +inline const ::messages::Temperature& HVACZone::target_temperature() const { + // @@protoc_insertion_point(field_get:messages.HVACZone.target_temperature) + return _internal_target_temperature(); +} +inline void HVACZone::unsafe_arena_set_allocated_target_temperature( + ::messages::Temperature* target_temperature) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.target_temperature_); + } + _impl_.target_temperature_ = target_temperature; + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:messages.HVACZone.target_temperature) +} +inline ::messages::Temperature* HVACZone::release_target_temperature() { + + ::messages::Temperature* temp = _impl_.target_temperature_; + _impl_.target_temperature_ = 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::Temperature* HVACZone::unsafe_arena_release_target_temperature() { + // @@protoc_insertion_point(field_release:messages.HVACZone.target_temperature) + + ::messages::Temperature* temp = _impl_.target_temperature_; + _impl_.target_temperature_ = nullptr; + return temp; +} +inline ::messages::Temperature* HVACZone::_internal_mutable_target_temperature() { + + if (_impl_.target_temperature_ == nullptr) { + auto* p = CreateMaybeMessage<::messages::Temperature>(GetArenaForAllocation()); + _impl_.target_temperature_ = p; + } + return _impl_.target_temperature_; +} +inline ::messages::Temperature* HVACZone::mutable_target_temperature() { + ::messages::Temperature* _msg = _internal_mutable_target_temperature(); + // @@protoc_insertion_point(field_mutable:messages.HVACZone.target_temperature) + return _msg; +} +inline void HVACZone::set_allocated_target_temperature(::messages::Temperature* target_temperature) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.target_temperature_; + } + if (target_temperature) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(target_temperature); + if (message_arena != submessage_arena) { + target_temperature = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, target_temperature, submessage_arena); + } + + } else { + + } + _impl_.target_temperature_ = target_temperature; + // @@protoc_insertion_point(field_set_allocated:messages.HVACZone.target_temperature) +} + +// ------------------------------------------------------------------- + +// HVACState + +// .messages.HVACState.State state = 1; +inline void HVACState::clear_state() { + _impl_.state_ = 0; +} +inline ::messages::HVACState_State HVACState::state() const { + // @@protoc_insertion_point(field_get:messages.HVACState.state) + return _internal_state(); +} +inline void HVACState::set_state(::messages::HVACState_State value) { + _internal_set_state(value); + // @@protoc_insertion_point(field_set:messages.HVACState.state) +} +inline ::messages::HVACState_State HVACState::_internal_state() const { + return static_cast<::messages::HVACState_State>(_impl_.state_); +} +inline void HVACState::_internal_set_state(::messages::HVACState_State value) { + ; + _impl_.state_ = value; +} + +// .messages.HVACZone current_zone = 2; +inline bool HVACState::_internal_has_current_zone() const { + return this != internal_default_instance() && _impl_.current_zone_ != nullptr; +} +inline bool HVACState::has_current_zone() const { + return _internal_has_current_zone(); +} +inline void HVACState::clear_current_zone() { + if (GetArenaForAllocation() == nullptr && _impl_.current_zone_ != nullptr) { + delete _impl_.current_zone_; + } + _impl_.current_zone_ = nullptr; +} +inline const ::messages::HVACZone& HVACState::_internal_current_zone() const { + const ::messages::HVACZone* p = _impl_.current_zone_; + return p != nullptr ? *p : reinterpret_cast( + ::messages::_HVACZone_default_instance_); +} +inline const ::messages::HVACZone& HVACState::current_zone() const { + // @@protoc_insertion_point(field_get:messages.HVACState.current_zone) + return _internal_current_zone(); +} +inline void HVACState::unsafe_arena_set_allocated_current_zone( + ::messages::HVACZone* current_zone) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.current_zone_); + } + _impl_.current_zone_ = current_zone; + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:messages.HVACState.current_zone) +} +inline ::messages::HVACZone* HVACState::release_current_zone() { + + ::messages::HVACZone* temp = _impl_.current_zone_; + _impl_.current_zone_ = 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::HVACZone* HVACState::unsafe_arena_release_current_zone() { + // @@protoc_insertion_point(field_release:messages.HVACState.current_zone) + + ::messages::HVACZone* temp = _impl_.current_zone_; + _impl_.current_zone_ = nullptr; + return temp; +} +inline ::messages::HVACZone* HVACState::_internal_mutable_current_zone() { + + if (_impl_.current_zone_ == nullptr) { + auto* p = CreateMaybeMessage<::messages::HVACZone>(GetArenaForAllocation()); + _impl_.current_zone_ = p; + } + return _impl_.current_zone_; +} +inline ::messages::HVACZone* HVACState::mutable_current_zone() { + ::messages::HVACZone* _msg = _internal_mutable_current_zone(); + // @@protoc_insertion_point(field_mutable:messages.HVACState.current_zone) + return _msg; +} +inline void HVACState::set_allocated_current_zone(::messages::HVACZone* current_zone) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.current_zone_; + } + if (current_zone) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(current_zone); + if (message_arena != submessage_arena) { + current_zone = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, current_zone, submessage_arena); + } + + } else { + + } + _impl_.current_zone_ = current_zone; + // @@protoc_insertion_point(field_set_allocated:messages.HVACState.current_zone) +} + +#ifdef __GNUC__ +#pragma GCC diagnostic pop +#endif // __GNUC__ + +// @@protoc_insertion_point(namespace_scope) +} // namespace messages + + +PROTOBUF_NAMESPACE_OPEN + +template <> +struct is_proto_enum<::messages::PreconditionResponse_Status> : std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor<::messages::PreconditionResponse_Status>() { + return ::messages::PreconditionResponse_Status_descriptor(); +} +template <> +struct is_proto_enum<::messages::HVACZone_Zone> : std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor<::messages::HVACZone_Zone>() { + return ::messages::HVACZone_Zone_descriptor(); +} +template <> +struct is_proto_enum<::messages::HVACState_State> : std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor<::messages::HVACState_State>() { + return ::messages::HVACState_State_descriptor(); +} + +PROTOBUF_NAMESPACE_CLOSE + +// @@protoc_insertion_point(global_scope) + +#include "google/protobuf/port_undef.inc" + +#endif // GOOGLE_PROTOBUF_INCLUDED_messages_2fVehicleRemoteHvac_2eproto_2epb_2eh -- cgit